115 lines
9.9 KiB
JavaScript
115 lines
9.9 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import { randomUUID } from 'node:crypto';
|
|
import { fixture, launchWorkbench } from './helpers.mjs';
|
|
import { beginPlanTask, completeRead } from './fixtures/task-plan-fixture.mjs';
|
|
import { Runtime } from '../src/server/runtime.mjs';
|
|
import { Provider } from '../src/server/provider.mjs';
|
|
import { Store } from '../src/server/store.mjs';
|
|
import { RequirementReview } from '../src/core/tasks/requirement-review.mjs';
|
|
import { inspectDiagnosticContext } from '../src/core/tasks/diagnostic-context.mjs';
|
|
import { DeliveryReporter, renderDeliveryMarkdown } from '../src/core/delivery-report.mjs';
|
|
|
|
const answer = { message: { role: 'assistant', content: '只读解释已完成,原任务仍待处理。' }, usage: { prompt_tokens: 10, completion_tokens: 4 } };
|
|
function originalFailure(f) {
|
|
const original = beginPlanTask(f, '修复原工程并通过测试');
|
|
f.session.status = 'failed';
|
|
const diagnostic = { id: randomUUID(), source: 'model_connection', kind: 'network', stage: 'model_request', title: '原连接失败', message: '原POST结果未知,不得重放。', runId: original.id };
|
|
const event = f.store.event(f.session, { kind: 'error', phase: 'failed', diagnostic });
|
|
f.session.lastFailure = diagnostic; f.store.save(f.session);
|
|
return { original, diagnostic, event };
|
|
}
|
|
const requirement = (f, extra = {}) => ({ key: 'research', role: 'requirement', title: '解释原工程', criterion: '核对原读取', kind: 'analysis', tools: ['read_file'], method: 'evidence',
|
|
source: { kind: 'goal', id: f.session.taskId, start: 0, end: f.store.core.task.get(f.session.taskId).goal.length }, ...extra });
|
|
|
|
test('diagnostic failures and repeated questions retain the original execution error, task, checks and read-only authority', async t => {
|
|
const f = fixture(t), origin = originalFailure(f), provider = new Provider(); let round = 0;
|
|
provider.complete = async (_config, _messages, _project, _signal, _progress, _plan, tools) => {
|
|
assert.ok(tools.every(tool => !['propose_file', 'run_command', 'run_checks'].includes(tool.function.name)));
|
|
if (round++ === 0) throw new Error('本次诊断自身的独立错误');
|
|
return answer;
|
|
};
|
|
const runtime = new Runtime(f.store, provider); f.onCleanup(() => runtime.stopAll());
|
|
const task = f.store.core.task.get(f.session.taskId); task.verification.status = 'failed';
|
|
const instructions = structuredClone(task.instructions);
|
|
runtime.start(f.session.id, '前面的错误是怎么回事?'); await runtime.active.get(f.session.id).promise;
|
|
const first = f.store.core.run.get(f.session.runId), context = inspectDiagnosticContext(f.store, f.session, first);
|
|
assert.equal(first.status, 'failed'); assert.equal(context.evidenceVerified, true);
|
|
assert.equal(context.originalRunId, origin.original.id); assert.equal(context.failure.id, origin.diagnostic.id);
|
|
assert.deepEqual(context.failure.value, origin.diagnostic); assert.equal(f.session.lastFailure.runId, first.id);
|
|
runtime.start(f.session.id, '请解释刚才执行的错误'); await runtime.active.get(f.session.id).promise;
|
|
const second = f.store.core.run.get(f.session.runId), next = inspectDiagnosticContext(f.store, f.session, second);
|
|
assert.equal(second.status, 'completed'); assert.equal(second.stopReason, 'diagnostic_answered');
|
|
assert.equal(next.failure.sha256, context.failure.sha256); assert.equal(next.originalRunId, origin.original.id);
|
|
assert.equal(f.session.status, 'failed'); assert.equal(task.status, 'failed'); assert.equal(task.verification.status, 'failed');
|
|
assert.deepEqual(task.instructions, instructions); assert.equal(f.session.changes.length, 0); assert.equal(f.store.core.check_job.size, 0);
|
|
const report = await new DeliveryReporter(f.store).inspect(f.session);
|
|
assert.equal(report.status, 'needs_checks'); assert.equal(report.diagnostics.length, 2); assert.match(renderDeliveryMarkdown(report), /原POST结果未知/);
|
|
assert.match(report.diagnostics[0].failure.message, /诊断自身的独立错误/);
|
|
});
|
|
|
|
test('diagnostic binding survives reopen, rejects foreign Task references and detects original error or artifact tampering', t => {
|
|
const f = fixture(t), origin = originalFailure(f), run = f.store.beginRun(f.session, '解释下这个错误', false, f.store.config);
|
|
f.session.status = 'failed'; f.store.finishRun(f.session, run, 'diagnostic_answered', { status: 'completed' }); f.store.close();
|
|
const restored = new Store(f.data); f.onCleanup(() => restored.close()); const session = restored.session(f.session.id), saved = restored.core.run.get(run.id);
|
|
assert.equal(inspectDiagnosticContext(restored, session, saved).failure.id, origin.diagnostic.id);
|
|
assert.equal(inspectDiagnosticContext(restored, { ...session, taskId: randomUUID() }, saved).evidenceVerified, false);
|
|
const event = session.events.find(value => value.id === origin.event.id); event.diagnostic.message += 'changed';
|
|
assert.match(inspectDiagnosticContext(restored, session, saved).error, /原失败/); event.diagnostic.message = origin.diagnostic.message;
|
|
const artifact = restored.core.artifact.get(saved.diagnosticContext.artifactId); fs.writeFileSync(path.join(restored.artifactStore.root, artifact.relative), 'corrupt');
|
|
assert.match(inspectDiagnosticContext(restored, session, saved).error, /校验/);
|
|
});
|
|
|
|
test('a new Task never adopts a previous Task error from session.lastFailure', t => {
|
|
const f = fixture(t); originalFailure(f);
|
|
f.store.core.task.get(f.session.taskId).status = 'completed'; const current = beginPlanTask(f, '只解释当前新工程');
|
|
const run = f.store.beginRun(f.session, '前面的错误是怎么回事?', false, f.store.config), context = inspectDiagnosticContext(f.store, f.session, run);
|
|
assert.equal(context.evidenceVerified, true); assert.equal(context.failure, null); assert.equal(context.originalRunId, current.id);
|
|
assert.equal(context.taskId, current.taskId);
|
|
});
|
|
|
|
test('verified research and explicit no-test scopes do not demand an unrelated test job or claim engineering success', async t => {
|
|
for (const skip of [false, true]) {
|
|
const f = fixture(t); beginPlanTask(f, '只研究原README.md,不修改。' + (skip ? '无需测试。' : '')); const read = completeRead(f);
|
|
const manager = new RequirementReview(f.store), rows = [requirement(f), requirement(f, { key: 'ref', role: 'reference', method: 'scope' }),
|
|
requirement(f, { key: 'boundary', role: 'prohibition', method: 'scope' })].map(value => { if (value.method === 'scope') delete value.tools; return value; });
|
|
await manager.save(f.session, { expected_revision: 0, requirements: rows });
|
|
await manager.verify(f.session, { expected_revision: 1, key: 'research', evidence_id: read.id });
|
|
const reporter = new DeliveryReporter(f.store), report = await reporter.inspect(f.session);
|
|
assert.equal(report.status, skip ? 'scope_verified' : 'research_verified'); assert.equal(report.verifiedCheckJobId, null);
|
|
assert.equal(f.store.core.check_job.size, 0); assert.equal(report.followUp.gaps.length, 0);
|
|
const text = renderDeliveryMarkdown(report); assert.match(text, /不自动要求修改/); assert.match(text, /是否遵守仍需实际证据/);
|
|
if (!skip) { f.store.core.task.get(f.session.taskId).verification.status = 'failed'; assert.equal((await reporter.inspect(f.session)).status, 'needs_checks'); }
|
|
}
|
|
});
|
|
|
|
test('unknown scope and unknown operations remain actionable even after a diagnostic answer or read proof', async t => {
|
|
const f = fixture(t); beginPlanTask(f, '研究原工程,无需测试。'); const read = completeRead(f), manager = new RequirementReview(f.store);
|
|
const unknownScope = requirement(f, { key: 'unknown', role: 'unknown', method: 'scope' }); delete unknownScope.tools;
|
|
await manager.save(f.session, { expected_revision: 0, requirements: [requirement(f), unknownScope] });
|
|
await manager.verify(f.session, { expected_revision: 1, key: 'research', evidence_id: read.id });
|
|
const reporter = new DeliveryReporter(f.store), report = await reporter.inspect(f.session);
|
|
assert.equal(report.status, 'needs_requirements'); assert.match(report.followUp.nextStep, /澄清原文用途/);
|
|
f.store.core.tool.get(read.id).requiresVerification = true;
|
|
const unknown = await reporter.inspect(f.session); assert.equal(unknown.status, 'needs_verification'); assert.match(unknown.followUp.nextStep, /不要重放/);
|
|
});
|
|
|
|
test('delivery status HTTP is read-only, selection-bound and equal to the saved report after host restart', async t => {
|
|
const f = fixture(t); const origin = originalFailure(f);
|
|
const diagnostic = f.store.beginRun(f.session, '这个报错是什么意思', false, f.store.config);
|
|
f.session.status = 'failed'; f.store.finishRun(f.session, diagnostic, 'diagnostic_answered', { status: 'completed' }); f.store.close();
|
|
let host = await launchWorkbench(t, f.data); const route = '/sessions/' + f.session.id;
|
|
const url = route + '/delivery-status?taskId=' + f.session.taskId + '&runId=' + diagnostic.id;
|
|
const before = await host.api(route + '/export'), view = await host.api(url), after = await host.api(route + '/export');
|
|
const { exportedAt: beforeAt, ...beforeData } = before, { exportedAt: afterAt, ...afterData } = after;
|
|
assert.ok(beforeAt && afterAt); assert.deepEqual(afterData, beforeData); assert.equal(view.diagnostics[0].context.failure.id, origin.diagnostic.id);
|
|
await assert.rejects(host.api(url.replace(diagnostic.id, origin.original.id)), /所选原任务或运行/);
|
|
await host.api(route + '/delivery-reports', {});
|
|
const saved = await host.api(route), reportArtifact = saved.execution.artifacts.findLast(row => row.kind === 'delivery-report');
|
|
const report = JSON.parse((await host.api('/artifacts/' + reportArtifact.id + '?session=' + f.session.id + '&limit=64000')).content);
|
|
assert.deepEqual(report.followUp, view.followUp);
|
|
await host.close(); host = await launchWorkbench(t, f.data); assert.deepEqual((await host.api(url)).followUp, view.followUp);
|
|
});
|