fix: preserve task intent across diagnostics and review continuation

This commit is contained in:
Agent Workbench Dev
2026-11-01 13:03:20 +08:00
parent 16f89838dd
commit 0736eca4cd
11 changed files with 213 additions and 17 deletions
+1 -1
View File
@@ -4,7 +4,7 @@
## 范围与目标
当前接续优先级:用户要求先保留后续计划、审查react-source实际会话,1.21实施暂缓。案例事实/根因/修复A–F见docs/CASE-REACT-SOURCE-2026-11-01.md及其证据摘要。该审查已完成,产品修复尚未实施;不要自动续接原任务、重跑其检查或调用真实模型。先按案例修复与针对性验收回顾,再恢复PLAN-1.21;本次文档审查不改变1.20正式交付身份或用户工程。
当前接续优先级:用户已明确要求“先修复系统”,在fix/task-control-1.20.1按docs/CASE-REACT-SOURCE-2026-11-01.md的A–F实施缺陷修复,1.21新功能继续暂缓。审查原证据保持;不续跑原react-source任务、重跑其检查或主动调用真实模型。采用独立数据/工程与协议验证,完成修复、针对性回归、实际UI、不可变候选和保留状态本地升级后回顾及Git。修复尚在进行,当前正式1.20身份不因此变化。
本仓库专注AI编程与能力研究工作台。其他项目不纳入本项目计划或代码。用户确定的研究对象为Codex、Claude Code、Cursor、DeepSeek Harness、WorkBuddy及DSH-purge;目标是将有证据的机制独立开发成自有Harness内置能力。
+2
View File
@@ -1,5 +1,7 @@
# 汇总发现
- 1.20.1 A/B实现已验证:目标契约与诊断Run分离、续接保留同Task、系统审查来源、无需测试文件应用结束、失败核验不能用文字冒充完成。29项专项/既有执行回归通过;协议/消费、无进展、实际模型UI与不可变发行仍在实施,未用正式模型或改动原react-source工程。
- react-source真实案例:完整35消息/120事件/14个Run和模型中心47尝试已核对;附件project/session/execution与当前正式只读导出一致。HTML实际8,378字节与applied SHA一致;原目标“无需测试”在故障解释结束原Task后丢出新Task,“审查后继续”又三次生成user角色的通用工程修复要求,四轮同源码/工程指纹检查均7/9失败,没有新的修复提案。
- 两次协议错误的原SSE均有tool_calls终结和[DONE],具体是inspect_project空字符串参数不符合JSON;拒绝整组派发有效,但需要受schema约束的兼容适配。两条原流含59,429已报告tokens却未入账;当前Task账本429,062、整个会话492,289不能当完整消费或HTML生成成本。Run启动配置与实际池成员的界面标签也有误;DeepSeek两条记录仅连接核验,未执行工程任务。详见docs/CASE-REACT-SOURCE-2026-11-01.md及去敏证据摘要。
- 历史诊断原件记录1.19.0,当前展示服务1.20.0/PID36552,不能混用历史/当前身份。先修报告A–F并针对性验收,再恢复保留的PLAN-1.21;本轮没有改产品源码、用户工程或正式服务。
+4
View File
@@ -1,5 +1,9 @@
# 统一执行进度
## 1.20.1 修复实施
A/B已完成首个切片:Task保留原目标与显式无需测试限制;简短续接不创建丢失原目标的新Task;只读诊断Run单独记录答复、保持原任务状态并在执行层拒绝副作用。审查续接改为系统来源、中性动作;无需测试的文件应用后给出路径与完成反馈,工程检查失败不能被最终文字覆盖为完成。专项与runtime/execution相关回归29/29通过,原TAP在.qa/task-control-initial.tap;当前尚未构建发行或改变正式服务。
## 当前:react-source实际案例审查与计划保留
已从头读用户附件和指定内置浏览器会话,逐项核对Task/Run、四次审批/检查、文件SHA、三份发送上下文、模型中心47尝试及原SSE。完整报告与去敏证据写入docs/CASE-REACT-SOURCE-2026-11-01.md和docs/CASE-REACT-SOURCE-EVIDENCE.json;原1.21及安装性能计划保留并暂缓。下一实施先处理报告A–F;诊断记录不等于已修复,当前仅文档和计划改动。本轮无真实模型请求、任务续接、用户工程测试、代码修改或升级。两次文档补丁因锚点不符在预检阶段拒绝、均无写入,核对实际标题后修正;过量只读输出改为结构化短段核对,未将截断当完整证据。
+2
View File
@@ -8,6 +8,7 @@ import { assertWorkspacesResolved } from '../../shared/contracts/workspaces.mjs'
import { verifyWorkspaceProject } from './git-workspaces.mjs';
import { assertMcpResolved } from '../tools/mcp-contract.mjs';
import { assertWorkersResolved, assertWorkerWriteScope } from '../../shared/contracts/workers.mjs';
import { settleAppliedTask } from '../../shared/contracts/task-control.mjs';
const at = () => new Date().toISOString();
const conflict = message => Object.assign(new Error(message), { status: 409 });
@@ -258,6 +259,7 @@ export class ChangeSetManager {
}
if (!set.requiresVerification) {
session.status = session.changes.some(change => ['pending', 'conflict'].includes(change.status)) ? 'needs_review' : 'completed';
if (complete) settleAppliedTask(this.store, session);
session.recoveryNotice = null;
} else { session.status = 'paused'; session.recoveryNotice = set.summary; }
session.events.push({ id: randomUUID(), kind: 'change_set', label: '多文件变更集 · ' + set.files.length + ' 个文件',
+2 -1
View File
@@ -7,6 +7,7 @@ import { assertChangeSetsResolved, assertProposalUnsealed } from '../shared/cont
import { assertWorkspacePath, assertWorkspacesResolved } from '../shared/contracts/workspaces.mjs';
import { assertMcpResolved } from '../core/tools/mcp-contract.mjs';
import { assertWorkersResolved, assertWorkerWriteScope } from '../shared/contracts/workers.mjs';
import { settleAppliedTask } from '../shared/contracts/task-control.mjs';
export const hash = bytes => createHash('sha256').update(bytes).digest('hex');
const ignored = new Set(['node_modules', '.git', '.next', '.data', 'bin', 'obj', 'dist', 'dist-client', 'dist-server', '__pycache__', '.venv', 'venv', '.tox', '.pytest_cache', '.mypy_cache', '.ruff_cache', 'htmlcov']);
@@ -223,7 +224,7 @@ export function applyChange(store, session, id) {
} finally { if (fs.existsSync(temporary)) fs.unlinkSync(temporary); }
change.status = 'applied'; change.appliedAt = now();
store.invalidateChecks(project.id);
if (session.status === 'needs_review' && !session.changes.some(item => ['pending', 'conflict'].includes(item.status))) session.status = 'completed';
if (session.status === 'needs_review') settleAppliedTask(store, session);
store.event(session, { kind: 'change', label: '已应用 ' + change.path, phase: 'completed', output: exists ? '写入前基线检查通过,原文已备份。' : '写入前基线检查通过,已创建新文件。' });
return change;
}
+21 -7
View File
@@ -8,6 +8,7 @@ import { projectContext, toolDefinitions, researchToolDefinitions, engineToolDef
import { now, repairToolPairs } from './store.mjs';
import { executionEnvironment, sessionContext, sessionSnapshot } from './diagnostics.mjs';
import { BudgetExceeded, checkBudget } from '../shared/contracts/execution.mjs';
import { taskToolAllowed, taskContract } from '../shared/contracts/task-control.mjs';
import { CheckRunner } from '../core/check-runner.mjs';
import { inspectProject } from '../core/project-inspector.mjs';
import { projectEnvironment } from '../core/process-environment.mjs';
@@ -208,7 +209,9 @@ export class Runtime {
const deadline = record.budget.maxDurationMs > 0 ? setTimeout(() => controller.abort(new BudgetExceeded('time_limit', '已到达本次运行的时间预算,执行记录已保存。')), record.budget.maxDurationMs) : null;
run.promise = this.run(session, config, run).finally(() => {
clearTimeout(deadline); this.active.delete(id);
this.store.finishRun(session, record, run.stopReason ?? null);
const status = session.status;
if (record.purpose === 'diagnostic') session.status = record.taskStatusBefore;
this.store.finishRun(session, record, run.stopReason ?? null, { status });
});
run.promise.catch(() => {});
return session;
@@ -228,8 +231,10 @@ export class Runtime {
if (!task || run?.taskId !== task.id || !stoppedForReview || pendingDeliveryReview(this.store, session) || session.changes.some(change => ['pending', 'conflict'].includes(change.status))
|| [...this.store.core.tool.values()].some(tool => tool.taskId === task.id && tool.requiresVerification)
|| !session.changes.some(change => change.status === 'applied' && (!change.taskId || change.taskId === task.id))) throw Object.assign(new Error('当前没有已审查并应用、需要继续交付的任务改动。'), { status: 409 });
const content = '本任务的改动已经审查并应用。请继续原始目标,识别并实际执行工程检查,依据失败日志修复,完成审查和交付说明。';
return this.start(id, content, true, { instructionSource: 'review-action' });
if (taskContract(task).checks === 'skip' && task.delivery?.status === 'files_applied') throw Object.assign(new Error('文件已按原要求应用完成,无需自动检查;如需追加工作,请明确发送新的要求。'), { status: 409 });
const result = this.start(id, '', true, { instructionSource: 'review-action' });
this.store.message(session, 'system', '审查操作:改动已应用,继续核对原目标。原有范围与限制保留,此操作没有追加测试要求。');
return result;
}
async run(session, config, run) {
const signal = run.controller.signal;
@@ -257,8 +262,9 @@ export class Runtime {
}) : '') + '\n当前项目/会话/任务身份:' + JSON.stringify({
project_id: run.project.id, session_id: session.id, task_id: task.id, workspace: projectWorkspaceIdentity(run.project) }) + '\n当前Task文件提案状态:' + JSON.stringify(state)
+ '\n当前任务目标与全部追加要求(用户任务数据,完整保留):\n' + JSON.stringify({
goal: task.goal, instructions: task.instructions, constraints: task.constraints ?? [], acceptance: task.acceptance ?? [],
}) + '\n结果未知的调用,不得假定成功或重放:' + JSON.stringify(unknown)
goal: taskContract(task).goal, instructions: task.instructions, constraints: task.constraints ?? [], acceptance: task.acceptance ?? [], contract: taskContract(task),
}) + (run.record.purpose === 'diagnostic' ? '\n本次仅回答运行诊断问题,允许读取所属结果;不得修改文件、执行命令或将解释视为原任务交付。诊断问题:' + run.record.question : '')
+ '\n结果未知的调用,不得假定成功或重放:' + JSON.stringify(unknown)
+ '\n' + sessionContext(session, run.project, config, value => this.provider.redact(value))
+ (task.readProgress?.warning ? '\n当前读取进展:' + task.readProgress.warning : '')
+ (taskPlan ? '\n当前Task依赖计划与尚未核验的原步骤(任务数据,不授权额外操作):\n' + JSON.stringify({
@@ -273,7 +279,7 @@ export class Runtime {
...([...this.store.core.research_target.values()].some(target => target.sessionId === session.id && target.taskId === run.taskId) ? researchToolDefinitions : []),
...([...this.store.core.engine_job.values()].some(job => job.sessionId === session.id && job.taskId === run.taskId) ? engineToolDefinitions : []),
...(this.browserManager().builds(run.project).length || [...this.store.core.browser_plan.values()].some(plan => plan.sessionId === session.id && plan.taskId === run.taskId) ? browserToolDefinitions : [])];
const tools = run.worker ? availableTools.filter(tool => WORKER_TOOLS.has(tool.function.name)) : availableTools;
const tools = availableTools.filter(tool => (!run.worker || WORKER_TOOLS.has(tool.function.name)) && taskToolAllowed(task, run.record, tool.function.name));
const projectMemory = await this.memoryManager().context(session, { redact: value => this.provider.redact(value) });
signal.throwIfAborted();
const planned = this.requestPlanner().prepare(session, run.record, config, { system: context, tools, stepId: stepRecord.id, projectMemory, skillCatalog, mcpCatalog });
@@ -354,6 +360,12 @@ export class Runtime {
if (!calls.length) {
this.store.finishStep(session, stepRecord);
session.status = session.changes.some(change => ['pending', 'conflict'].includes(change.status)) ? 'needs_review' : 'completed';
if (run.record.purpose === 'diagnostic') { session.status = 'completed'; run.stopReason = 'diagnostic_answered'; }
else if (session.status === 'completed' && taskContract(task).checks !== 'skip' && (['failed', 'stale', 'unknown', 'unverified', 'running'].includes(task.verification?.status)
|| taskContract(task).checks === 'required' && task.verification?.status !== 'passed')) {
session.status = 'paused'; run.stopReason = 'verification_incomplete';
this.store.message(session, 'system', '答复已收到,但当前任务的工程检查尚未通过,不能视为交付完成。原目标与检查结果已保留。');
}
if (externalEngine) await this.engineRunner().finish(session, run);
if (session.status === 'completed' && run.worker) {
try { await this.workerManager().output(session, run.worker); signal.throwIfAborted(); }
@@ -363,7 +375,7 @@ export class Runtime {
this.store.message(session, 'system', '子任务还不能交付:' + this.provider.redact(error.message ?? String(error)) + '。原目标和结果已保存。');
}
}
if (session.status === 'completed' && task.currentTaskPlanId) {
if (session.status === 'completed' && task.currentTaskPlanId && run.record.purpose !== 'diagnostic') {
const finalPlan = await this.taskPlanner().inspect(session, { candidates: false });
if (!finalPlan.all_verified) {
session.status = 'paused'; run.stopReason = 'task_plan_incomplete';
@@ -456,6 +468,8 @@ export class Runtime {
try {
const args = JSON.parse(call.function.arguments);
validateToolArgs(tool, args);
if (!taskToolAllowed(this.store.core.task.get(run.taskId), run.record, tool, args)) throw new Error(run.record.purpose === 'diagnostic'
? '本次是只读运行诊断,不执行文件修改、命令或其他副作用操作。原任务目标保持。' : '原任务明确无需测试;这项自动检查没有执行。请直接完成原目标,追加测试需要用户明确要求。');
assertWorkerTool(this.store, session, tool, args);
if (run.worker?.engine) this.engineRunner().assertCurrent(session, run);
event.input = JSON.parse(this.provider.redact(JSON.stringify(args)));
+18 -6
View File
@@ -7,6 +7,7 @@ import { StateDatabase, runtimeOwnerAlive } from '../core/storage/state-database
import { ArtifactStore } from '../core/storage/artifact-store.mjs';
import { collectLegacy, cleanConfig } from '../core/storage/legacy-import.mjs';
import { ACTIVE_STATES, CORE_KINDS, createTask, createRun, ownedRecord, emptyUsage, accumulateUsage, accountedTokens, isId } from '../shared/contracts/execution.mjs';
import { isContinuation, isDiagnosticQuestion, taskContract, updateTaskContract } from '../shared/contracts/task-control.mjs';
import { WORKSPACE_ACTIVE, projectWorkspaceIdentity, assertWorkspacePath } from '../shared/contracts/workspaces.mjs';
import { RESEARCH_ACTIVE } from '../shared/contracts/research.mjs';
import { ENGINE_ACTIVE, publicEngineJob } from '../shared/contracts/engines.mjs';
@@ -362,7 +363,7 @@ export class Store extends EventEmitter {
session.revision = (session.revision ?? 0) + 1;
session.updatedAt = now();
const task = this.core.task.get(session.taskId), run = this.core.run.get(session.runId);
if (task) { task.status = session.status; task.updatedAt = session.updatedAt; }
if (task) { if (run?.purpose !== 'diagnostic') task.status = session.status; task.updatedAt = session.updatedAt; }
if (run && !run.finishedAt) run.status = session.status;
let committed;
try { committed = this.storage.save(session, this.recordsFor(session), type, { status: session.status, ...detail }); }
@@ -465,11 +466,18 @@ export class Store extends EventEmitter {
});
if (inputs.length>1 || inputs.length && !forceNewTask && task?.attachmentIds?.length && (resume || !['completed','idle'].includes(task.status))) throw new Error('当前任务已有截图,请新建任务再添加。');
const previousRunId = session.runId ?? null;
if (forceNewTask || !task || !resume && ['completed', 'idle'].includes(task.status)) {
if (task) task.contract ??= taskContract(task, id => this.core.task.get(id));
const purpose = !forceNewTask && task && !resume && isDiagnosticQuestion(content) ? 'diagnostic' : 'execution';
const continuing = task && isContinuation(content);
if (forceNewTask || !task || !resume && !continuing && purpose !== 'diagnostic' && ['completed', 'idle'].includes(task.status)) {
const previous = task?.id ?? null;
const goal = content || session.messages.find(message => message.role === 'user')?.content || session.title;
task = createTask(session, goal, config, previous); this.core.task.set(task.id, task);
} else if (content && (!resume || instructionSource)) task.instructions.push({ id: randomUUID(), content, createdAt: now(), ...(instructionSource ? { source: instructionSource } : {}) });
} else if (content && purpose !== 'diagnostic' && (!resume || instructionSource)) {
task.instructions.push({ id: randomUUID(), content, createdAt: now(), source: instructionSource ?? 'user' });
updateTaskContract(task, content);
}
task.contract ??= taskContract(task, id => this.core.task.get(id));
if (task.readProgress) {
task.readProgress.repeated = 0; task.readProgress.changingIndexes = []; task.readProgress.warning = null; task.readProgress.pause = false;
task.readProgress.sessionInspection = null;
@@ -477,7 +485,10 @@ export class Store extends EventEmitter {
const workspaceIdentity = projectWorkspaceIdentity(this.project(session.projectId));
task.workspaceIdentity ??= structuredClone(workspaceIdentity);
if (JSON.stringify(task.workspaceIdentity) !== JSON.stringify(workspaceIdentity)) throw Object.assign(new Error('任务的工作区身份已变化,不能将原任务移动到另一个工作区。'), { status: 409 });
const run = createRun(session, task, config, resume ? previousRunId : null);
const run = createRun(session, task, config, resume || continuing ? previousRunId : null);
run.purpose = purpose;
if (purpose === 'diagnostic') { run.question = String(content); run.taskStatusBefore = task.status; }
if (instructionSource) run.source = instructionSource;
if(resumePlan){task.budget.maxTokens=config.maxTaskTokens;run.resumePlanId=resumePlan.id;resumePlan.status='consumed';resumePlan.newRunId=run.id;}
run.workspaceIdentity = structuredClone(workspaceIdentity);
this.core.run.set(run.id, run); task.activeRunId = run.id;
@@ -515,8 +526,8 @@ export class Store extends EventEmitter {
session.usage = usage;
}
finishRun(session, run, stopReason = null) {
run.status = session.status; run.finishedAt = now(); run.stopReason = stopReason;
finishRun(session, run, stopReason = null, { status = session.status } = {}) {
run.status = status; run.finishedAt = now(); run.stopReason = stopReason;
const step = this.core.step.get(run.checkpoint.stepId);
if (step && ['running', 'waiting'].includes(step.status)) { step.status = session.status === 'completed' || session.status === 'needs_review' ? 'completed' : 'interrupted'; step.finishedAt = now(); }
this.save(session, { type: 'run.finished', detail: { stopReason } });
@@ -630,6 +641,7 @@ export class Store extends EventEmitter {
runs: [...this.core.run.values()].filter(value => value.sessionId === session.id).slice(-20).map(value => ({ id: value.id, taskId: value.taskId,
status: value.status, startedAt: value.startedAt, finishedAt: value.finishedAt, steps: value.steps, toolCalls: value.toolCalls,
usage: value.usage, stopReason: value.stopReason, model: value.model, budget: value.budget, resumeOf: value.resumeOf,
...(value.purpose ? { purpose: value.purpose, source: value.source, taskStatusBefore: value.taskStatusBefore } : {}),
...(value.workspaceIdentity ? { workspaceIdentity: value.workspaceIdentity } : {}), ...(value.review ? { review: value.review } : {}) })),
progress: { totalTools: tools.length, completedTools: tools.filter(value => value.state === 'completed').length,
requiresVerification: tools.filter(value => value.requiresVerification).map(value => ({ id: value.id, tool: value.tool, callId: value.callId, state: value.state })) },
+5 -1
View File
@@ -1,4 +1,5 @@
import { randomUUID } from 'node:crypto';
import { taskContract } from './task-control.mjs';
export const EXECUTION_SCHEMA = 1;
export const ACTIVE_STATES = new Set(['running', 'awaiting_approval', 'stopping']);
@@ -49,13 +50,16 @@ export const accountedTokens = usage => (usage?.totalTokens ?? 0) + (usage?.esti
export function createTask(session, goal, config, previousTaskId = null) {
const at = timestamp();
return {
const task = {
schemaVersion: EXECUTION_SCHEMA, id: randomUUID(), sessionId: session.id, projectId: session.projectId,
goal: String(goal), instructions: [], constraints: [], acceptance: [], status: 'idle',
previousTaskId, createdAt: at, updatedAt: at, activeRunId: null,
usage: emptyUsage(), budget: { maxTokens: executionBudget(config).maxTaskTokens },
verification: { status: 'not_configured', checkJobId: null }, origin: 'workbench',
};
task.contract = taskContract(task);
if (task.contract.checks === 'skip') task.constraints.push('用户明确要求无需测试;不得自动扩大为工程测试任务。');
return task;
}
export function createRun(session, task, config, resumeOf = null) {
+58
View File
@@ -0,0 +1,58 @@
// Task intent is retained independently of short follow-ups and system actions.
export const isContinuation = content => /^(?:请)?(?:继续(?:完成|执行|开发|原任务|这个任务)?|接着(?:完成|执行)?|continue(?:\s+(?:the\s+)?(?:task|work))?)[。.!!\s]*$/i.test(String(content).trim());
export function isDiagnosticQuestion(content) {
const text = String(content).trim();
if (/(?:请|帮我|继续|需要|先).{0,12}(?:修复|修改|实现|开发|执行|重跑)|\b(?:fix|implement|change|rerun)\b/i.test(text)) return false;
return /(?:怎么回事|什么原因|为什么.{0,30}(?:报错|失败|错误)|(?:前面|刚才|这个).{0,15}(?:错误|报错|失败).{0,15}(?:解释|原因|情况))|\b(?:what (?:went wrong|happened)|why did .{0,40}fail)\b/i.test(text);
}
export function taskContract(task, lookup = () => null) {
if (task.contract?.schemaVersion === 1) return task.contract;
let original = task;
const seen = new Set();
while (isContinuation(original.goal) && original.previousTaskId && !seen.has(original.id)) {
seen.add(original.id);
const previous = lookup(original.previousTaskId);
if (!previous || previous.sessionId !== task.sessionId || previous.projectId !== task.projectId) break;
original = previous;
}
const goal = original.contract?.goal ?? original.goal;
const skip = /无需(?:任何)?测试|不(?:需要|用|要)(?:进行|做|运行)?测试|\b(?:no tests?(?: needed|required)?|without (?:running )?tests?)\b/i.test(goal);
const required = !skip && /(?:运行|执行|通过|修复|补充|添加).{0,12}(?:测试|工程检查)|\b(?:run|pass|fix|add)\b.{0,24}\b(?:tests?|checks?)\b/i.test(goal);
return { schemaVersion: 1, goal, checks: skip ? 'skip' : required ? 'required' : 'unspecified',
...(original.id !== task.id ? { inheritedFromTaskId: original.id } : {}) };
}
export function updateTaskContract(task, instruction) {
const current = taskContract(task);
// Only an explicit new user instruction changes the check policy.
if (/无需(?:任何)?测试|不(?:需要|用|要)(?:进行|做|运行)?测试|\b(?:no tests?|without (?:running )?tests?)\b/i.test(instruction)) current.checks = 'skip';
else if (/(?:运行|执行|通过|修复|补充|添加).{0,12}(?:测试|工程检查)|\b(?:run|pass|fix|add)\b.{0,24}\b(?:tests?|checks?)\b/i.test(instruction)) current.checks = 'required';
task.contract = current;
task.constraints = (task.constraints ?? []).filter(value => value !== '用户明确要求无需测试;不得自动扩大为工程测试任务。');
if (current.checks === 'skip') task.constraints.push('用户明确要求无需测试;不得自动扩大为工程测试任务。');
}
export const DIAGNOSTIC_TOOLS = new Set(['inspect_session', 'inspect_project', 'list_files', 'read_file', 'search_files', 'read_artifact', 'inspect_task_plan', 'read_browser_result', 'read_registered_skill']);
export const AUTOMATIC_CHECK_TOOLS = new Set(['plan_checks', 'run_checks', 'plan_browser', 'run_browser']);
export function taskToolAllowed(task, run, tool, args = {}) {
if (run.purpose === 'diagnostic') return DIAGNOSTIC_TOOLS.has(tool);
if (taskContract(task).checks !== 'skip') return true;
if (AUTOMATIC_CHECK_TOOLS.has(tool)) return false;
return tool !== 'run_command' || !/(?:\b(?:test|pytest|vitest|jest|mocha|playwright)\b|--test\b)/i.test(args.command ?? '');
}
export function settleAppliedTask(store, session) {
const task = store.core.task.get(session.taskId);
if (!task || session.changes.some(change => ['pending', 'conflict'].includes(change.status))) return;
const applied = session.changes.filter(change => change.status === 'applied' && (!change.taskId || change.taskId === task.id));
if (!applied.length) return;
const contract = taskContract(task, id => store.core.task.get(id));
task.delivery = { status: 'files_applied', paths: applied.map(change => change.path), at: new Date().toISOString(),
checks: contract.checks === 'skip' ? 'not_requested' : task.verification?.status ?? 'not_configured' };
session.status = contract.checks === 'required' || task.currentTaskPlanId || ['failed', 'stale', 'unknown', 'unverified'].includes(task.verification?.status) && contract.checks !== 'skip'
? 'paused' : 'completed';
if (contract.checks === 'skip') store.message(session, 'system', '文件已审查并应用:' + task.delivery.paths.join('、') + '。按照原要求未运行测试,可在文件列表打开结果。');
}
+12 -1
View File
@@ -1,6 +1,17 @@
# Agent Workbench:核心代理能力研究与产品计划
## 当前任务:react-source 真实会话审查
## 当前任务:1.20.1 真实案例缺陷修复
用户已明确要求“先修复系统”。基线16f8983,分支fix/task-control-1.20.1;按案例报告A–F实施,1.21新功能继续暂缓。保留原会话/工件与用户工程,不续跑原任务或读取真实Key;用独立工程、数据与固定协议验证。完成相关构建/回归、实际桌面/窄屏流程、不可变候选及保留状态本地部署,本地Git保存并回顾。
1. [in_progress] A/B:保留原始目标与显式限制,诊断问答不结束未交付任务;审查续接不追加通用工程检查,提供应用后结束路径。
2. [pending] C:受schema约束的空参数适配、精确错误、按模型attempt去重的成功/失败/unknown消费记账。
3. [pending] D:识别跨步骤/续接的同输入无进展,保留合理分页和显式重跑。
4. [pending] E:分别显示答复/文件/检查状态、系统动作来源和实际模型路由。
5. [pending] F:针对性契约/HTTP/隔离工程/UI与回归,修复发现、构建并本地Git。
6. [pending] 本地发行及保留状态升级、证据/回顾与剩余计划;未经运行的真实推理不宣称验收完成。
## react-source 真实会话审查(已完成)
按用户最新要求,先保存后续开发计划,暂停启动1.21新功能,优先从头审查导出会话f8a5a714-183d-4d6c-af27-ed56c60225b2及指定内置浏览器中的react-source实际运行。当前阶段只读核对会话、任务/运行、变更、检查、模型路由与原日志,记录事实、根因及修复门槛;不重跑原任务或测试,不调用真实模型,不修改用户工程或正式服务配置。
+88
View File
@@ -0,0 +1,88 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import path from 'node:path';
import { Runtime } from '../src/server/runtime.mjs';
import { Provider } from '../src/server/provider.mjs';
import { applyChange } from '../src/server/files.mjs';
import { fixture, call, assertToolPairs } from './helpers.mjs';
const answer = content => ({ message: { role: 'assistant', content }, usage: { prompt_tokens: 11, completion_tokens: 3 } });
const calls = (...tools) => ({ ...answer(''), message: { role: 'assistant', content: '', tool_calls: tools } });
function harness(t, respond) {
const f = fixture(t), provider = new Provider(); let round = 0;
provider.complete = async (config, messages, project, signal, progress, plan, tools) => respond(round++, { messages, tools, f });
const runtime = new Runtime(f.store, provider); f.onCleanup(() => runtime.stopAll());
return { ...f, runtime, wait: () => runtime.active.get(f.session.id).promise };
}
test('HTML without tests ends at reviewed file delivery and never offers automatic rechecking', async t => {
const f = harness(t, (round, { tools }) => {
assert.ok(!tools.some(tool => ['run_checks', 'plan_checks'].includes(tool.function.name)));
return round === 0 ? calls(call('html', 'propose_file', { path: 'bike.html', content: '<!doctype html><svg><circle r="4"/></svg>', reason: '原请求' })) : answer('文件提案已生成。');
});
f.runtime.start(f.session.id, '创建一个 HTML,使用 SVG 动画,无需测试。'); await f.wait();
const task = f.store.core.task.get(f.session.taskId), id = task.id;
assert.equal(f.session.status, 'needs_review');
applyChange(f.store, f.session, f.session.changes[0].id);
assert.equal(f.session.status, 'completed'); assert.equal(task.status, 'completed');
assert.equal(task.delivery.checks, 'not_requested'); assert.deepEqual(task.delivery.paths, ['bike.html']);
assert.match(fs.readFileSync(path.join(f.projectRoot, 'bike.html'), 'utf8'), /<svg>/);
assert.throws(() => f.runtime.continueReviewed(f.session.id), { status: 409 });
assert.equal(f.store.core.check_job.size, 0); assert.equal(f.session.approvals.length, 0);
f.runtime.start(f.session.id, '继续完成'); await f.wait();
assert.equal(f.session.taskId, id); assert.match(task.contract.goal, /SVG 动画/);
assertToolPairs(f.session.providerMessages);
});
test('diagnostic answers retain the unfinished task, limits and check result, and enforce read-only tools', async t => {
const f = harness(t, (round, { tools }) => {
if (round === 0) return answer('尚未交付。');
if (round === 1) {
assert.ok(tools.every(tool => !['run_command', 'propose_file', 'run_checks'].includes(tool.function.name)));
return calls(call('bad-diagnostic-write', 'propose_file', { path: 'unwanted.txt', content: 'wrong', reason: '诊断不应写入' }), call('inspect-error', 'inspect_session', {}));
}
return answer('所属任务的检查失败,原任务仍需修复。');
});
f.runtime.start(f.session.id, '修复工程并通过测试'); await f.wait();
const task = f.store.core.task.get(f.session.taskId), taskId = task.id;
task.verification = { status: 'failed', checkJobId: null }; f.session.status = 'paused'; f.store.save(f.session);
const instructions = structuredClone(task.instructions);
f.runtime.start(f.session.id, '前面的错误是怎么回事?'); await f.wait();
assert.equal(f.session.taskId, taskId); assert.equal(task.status, 'paused'); assert.equal(f.session.status, 'paused');
assert.deepEqual(task.instructions, instructions); assert.equal(task.verification.status, 'failed');
const run = f.store.core.run.get(f.session.runId);
assert.equal(run.purpose, 'diagnostic'); assert.equal(run.status, 'completed'); assert.equal(run.stopReason, 'diagnostic_answered');
assert.equal(f.session.changes.length, 0); assert.ok(!fs.existsSync(path.join(f.projectRoot, 'unwanted.txt')));
const denied = JSON.parse(f.session.providerMessages.find(message => message.tool_call_id === 'bad-diagnostic-write').content);
assert.equal(denied.status, 'error'); assert.match(denied.message, /只读/);
f.runtime.start(f.session.id, '继续完成'); await f.wait();
assert.equal(f.session.taskId, taskId); assert.equal(f.session.status, 'paused');
assert.equal(f.store.core.run.get(f.session.runId).stopReason, 'verification_incomplete');
});
test('review continuation is a system action and adds no testing demand or fake user instruction', async t => {
let continued;
const f = harness(t, (round, { messages }) => {
if (round === 0) return calls(call('doc', 'propose_file', { path: 'result.txt', content: 'done', reason: 'requested' }));
if (round === 2) continued = messages;
return answer('改动已生成。');
});
f.runtime.start(f.session.id, '创建 result.txt'); await f.wait();
applyChange(f.store, f.session, f.session.changes[0].id);
const task = f.store.core.task.get(f.session.taskId), users = f.session.messages.filter(message => message.role === 'user').length;
f.runtime.continueReviewed(f.session.id); await f.wait();
assert.equal(task.instructions.length, 0);
assert.equal(f.session.messages.filter(message => message.role === 'user').length, users);
assert.equal(f.store.core.run.get(f.session.runId).source, 'review-action');
assert.match(JSON.stringify(continued), /创建 result.txt/);
assert.doesNotMatch(JSON.stringify(continued), /识别并实际执行工程检查/);
});
test('a provider cannot execute tests against an explicit no-test task even if it ignores advertised tools', async t => {
const f = harness(t, round => round === 0 ? calls(call('blocked-check', 'plan_checks', {}), call('blocked-command', 'run_command', { command: 'npm test', reason: 'ignored constraint' })) : answer('按照原要求不测试。'));
f.runtime.start(f.session.id, '创建 HTML,无需测试'); await f.wait();
assert.equal(f.session.approvals.length, 0); assert.equal(f.store.core.check_plan.size, 0);
for (const id of ['blocked-check', 'blocked-command']) assert.match(JSON.parse(f.session.providerMessages.find(message => message.tool_call_id === id).content).message, /无需测试/);
assertToolPairs(f.session.providerMessages);
});