From 7e77fd65c367b711a9a59b30ef216f5fdf7feb11 Mon Sep 17 00:00:00 2001 From: Agent Workbench Dev Date: Wed, 4 Nov 2026 07:52:59 +0800 Subject: [PATCH] fix(context): retain observed file fragments and current engineering facts --- AGENTS.md | 2 + CHANGELOG.md | 7 ++ docs/QA-WORKING-MEMORY-U.md | 31 ++++++ docs/WORKING-MEMORY-U-PLAN.md | 2 +- findings.md | 7 ++ package-lock.json | 4 +- package.json | 2 +- progress.md | 7 ++ scripts/upgrade-running.mjs | 2 +- scripts/verify-desktop-install.mjs | 2 +- scripts/verify-working-memory.mjs | 64 ++++++++++++ src/core/context/delivery-progress.mjs | 34 ++++-- src/core/context/request-plan.mjs | 34 +++--- src/core/context/tool-feedback.mjs | 18 +++- src/core/context/working-set.mjs | 129 +++++++++++++++++++---- src/server/diagnostics.mjs | 38 +++++-- src/server/runtime.mjs | 4 +- task_plan.md | 15 +++ tests/delivery-progress.test.mjs | 24 +++++ tests/diagnostics.test.mjs | 14 ++- tests/fixtures/working-memory-t.json | 137 +++++++++++++++++++++++++ tests/task-context.test.mjs | 6 +- tests/working-set.test.mjs | 57 +++++++++- 23 files changed, 583 insertions(+), 57 deletions(-) create mode 100644 docs/QA-WORKING-MEMORY-U.md create mode 100644 scripts/verify-working-memory.mjs create mode 100644 tests/fixtures/working-memory-t.json diff --git a/AGENTS.md b/AGENTS.md index de97cc21..e0d49dd2 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -1,5 +1,7 @@ # Agent Workbench项目执行规范 +U开发中:已实现同SHA/原范围真实片段聚合与view4来源核验、首次修改前当前检查事实和routine/latest3去重。原T候选1643→2584,原第7/8实际离线正文在16K/2048/1600内保留四文件及9失败/build通过。实际编译宿主新隔离HTTP夹具7请求、第6/7完整来源且重开验证,原11文件未改、原9测试仍失败、0交付/真实请求。最终114/114相关及升级安装单元通过,1.24.8独立载荷/保留状态正式升级尚在进行,正式仍1.24.7/PID36552/Provider。详见docs/QA-WORKING-MEMORY-U.md。不要续跑T/R/P/O,不提取/复制/解密/重存Key,不委派、不推送。 + T已完成新有界实测与回顾,未交付Node:唯一诊断462ms/DNS与三TLS通过,0HTTP/模型/凭据;新无工具预检1请求/112报告tokens/strict matched。新Node8请求/76062报告tokens/0未知、16工具/1原检查审批、原九测试全失败/build通过、0提案/修改/交付,step_limit原样封存。测试2584字符第6轮已全部返回,但第7/8实际结构化文件视图仅27/421字符,原检查job UUID在第6–8原请求不存在;原16tool行离线重现最长页+最新页在预算前丢[0,473]和[2089,2557]。203份/77773746字节证据离线通过,见docs/QA-LIVE-DELIVERY-T.md及回顾。正式仍1.24.7/source5dcd6d7c/原PID36552/Provider;原63项目79导出3660工件216尝试和原行保持(项目位置仅2自有前插逆算),当前65项目81会话6377记录13484事件及outbox/3720工件,74自有工件全SHA核对。预算/高性能池恢复,目标7→8→9/凭据1、全局69→73,9229关闭,无产品改动/重复发行。下一先docs/WORKING-MEMORY-U-PLAN.md离线修复片段聚合和真实当前事实持续保留,阶段真实模型预算0;交付后另冻新Node,不续跑T/R/P/O。Node后才React/Python/Purge;1.25/更新性能仍单列。不委派、不提取/复制/解密/重存Key、不重启原Provider、不推送。 S已本地交付1.24.7/source5dcd6d7c/候选20261103164618190:文件续读携带原范围/偏移/SHA、纯文件批次容量及未用份额分配、Run/Task预留余额准确解释。96相关和18安装升级、源码/便携/实际安装新UI各10组、20组历史UI、565输入独立重建22/22、三归档/便携及12实际安装和16+9文件流程通过。正式原PID36552/Provider、63项目79会话6262记录13279事件及outbox/3660工件,所有原表行/全导出/工件与公开模型中心在网页/原生回看后再次精确保持,9229关闭。760份/106829868字节证据离线通过,见docs/QA-READING-RELIABILITY-S.md及docs/reading-s-release-identity.json。原R三响应+固定续读回放由8轮未完到6轮读完2584;原九测试仍失败,0修改/交付,本轮真实模型请求0。下一按docs/LIVE-DELIVERY-T-PLAN.md另冻结单次预检/新Node,16K/2048/8请求/90000tokens;不续跑旧失败,Node通过再React/Python/Purge。更新869425ms重复核验及1.25独立排期。不委派、不提取/复制/重存Key、不重启原Provider、不推送。 diff --git a/CHANGELOG.md b/CHANGELOG.md index 1479fdee..4da9324b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,12 @@ # Agent Workbench 更新记录 +## 1.24.8 · 已读文件与当前检查的工作记忆(开发验收中) + +- 同一版本、同一原范围的已返回文件页连续聚合,保留全部原调用和工件来源;空洞不补造、重叠冲突拒绝,旧请求继续按原视图核对。 +- 首次修改前也持续携带当前工程指纹、检查计划、实际失败数量和日志指针;源码变化、未知操作或损坏日志不能被当作当前通过。 +- 去除常规模型请求中的重复成功摘录与定位开销,保留完整诊断和原错误。实际正文独立核对,保留目标、16K预算、输出和安全预留。 +- 离线原T记录与本机HTTP回放已分别验证;本轮不调用真实模型,不将读取改善写成真实工程交付或Purge收益。正式发行验收完成后另记身份。 + ## T 实测记录 · 正式仍为1.24.7 - 新连接诊断和单次真实模型预检通过;新Node在原八请求预算内未完成修改与交付,原测试失败、停止原因和全部用量保留。 diff --git a/docs/QA-WORKING-MEMORY-U.md b/docs/QA-WORKING-MEMORY-U.md new file mode 100644 index 00000000..9ed5d2d9 --- /dev/null +++ b/docs/QA-WORKING-MEMORY-U.md @@ -0,0 +1,31 @@ +# U 工作记忆修复:验收与交付记录 + +当前为1.24.8开发验收。正式仍1.24.7/PID36552/原Provider。最终发行身份、独立载荷和正式保留状态验收完成后补充;本阶段真实模型请求为0。 + +原T样本保存在 [T验收](QA-LIVE-DELIVERY-T.md),八请求未交付的结论不改写。U只修复已经定位的系统问题,不续跑旧Task、不提供实现答案、不扩大16K/2048/1600预算。 + +## 已实现 + +`working-set`观察版本3仅合并同路径/SHA/原行范围/总字符数的实际返回页。每个片段保留原调用、消息组和原结果SHA;连续且重叠字节一致才合并,空洞独立、不同版本不继承、损坏坐标与冲突拒绝。旧版本1/2及发送视图1–3保持。新发送view4精简完整页的重复来源,截取时明确实际发送区间、缺失已读区间和原工件恢复入口。 + +`delivery-progress`版本2在真实工程识别/检查活动后、首次修改前携带当前fingerprint、计划/job、实际测试数量和所属日志SHA。当前源码和原日志都验证;无修改的通过基线不会进入Git,未知/待审/损坏来源不授予新操作。纯文件读取不触发额外工程扫描。实际Git/检查/审批原契约保持。 + +新latest-tools view3和routine context2去除重复成功读取摘录与相同已匹配路由回声。完整诊断API、原工件/错误/未知结果/不同路由和不匹配身份仍保留。 + +## 已观察结果 + +- 最终源码相关16文件114/114通过,包含聚合、Unicode/空洞/冲突/改版/损坏原件、旧视图、实际分页、预算/完整目标/工具配对、原基线事实和安装/热升级单元;构建通过。完整全仓测试未重复,不将相关检查称作全仓验收。 + +- 原T16工具行的确定性重放:第六轮后旧候选1643/2584字符,新候选2584/2584。 +- 原T第7/8请求离线重建:原23工具、完整原目标、16K/2048/1600,实际正文同时携带2584测试+51/93/52三个模块和原9失败/build通过事实。首通过输入12307/12086,均不超过12352;实际SHA工件和聚合来源验证通过。 +- 实际编译宿主HTTP夹具:原T目标/11文件/前三个原助手响应,只将动态原计划ID绑定到本机;后续确定性续读,7请求,在第6/7正文保留四文件全文及原失败检查,经重开Store独立核验所有发送工件。原源码未改、九测试仍失败、0提案/交付。不是模型能力测试。 + +## 中间失败与修复 + +首58项56通过2失败:完整长文件新页被累计观察挤走,以及legacy无坐标的宽读取排序回退;保留首TAP,修复纯read_file原配对优先和稳定路径/宽读取排序。第二21项19通过2失败包含同一分页路径及新测试虚拟tool使用无效ID,后者按真实UUID修复。第三37项36通过1失败仍是虚拟ID;下一82项81通过1失败为旧回归只在latest.content_excerpt寻找源码,修改为核对实际配对消息/working_set/旧视图的完整原字节,未放宽保留目标。 + +原T wire驱动首轮误猜money.mjs、真实为amount.mjs。第二至第四容量验证真实拒绝完整覆盖,保留输出;精简重复诊断/来源/成功摘录后第五轮实际正文通过。实际编译宿主首夹具误断言不存在的approval.kind,按真实checkPlanId/checkScripts/原命令核对后新隔离项目通过。其它只读路径查找失败、输出截断及一次PowerShell转义失败均未计为验收,不影响正式服务或重放外部操作。 + +## 待完成 + +最终相关回归、独立源码重建、不可变便携/安装载荷核对、保留正式PID/Provider/全部原行/导出/工件/公开模型配置升级和实际窗口回看,随后封存回顾与本地Git。后续真实模型样本另立冻结契约,仍不将本轮离线通过当作收益。 diff --git a/docs/WORKING-MEMORY-U-PLAN.md b/docs/WORKING-MEMORY-U-PLAN.md index 6867e4f7..3ffd69ca 100644 --- a/docs/WORKING-MEMORY-U-PLAN.md +++ b/docs/WORKING-MEMORY-U-PLAN.md @@ -1,6 +1,6 @@ # U:已读片段与当前执行事实的持续保留 -这是T结束后的下一开发切片,尚未实现或交付。T的原字节和结果见[验收](QA-LIVE-DELIVERY-T.md)。正式保持1.24.7/原PID36552/Provider,U开发和离线验收阶段真实模型预算为0;不续跑T/R/P/O、不提取/复制/解密/重存Key、不推送。拟修复范围围绕当前Node交付阻塞,不扩展无关能力。 +这是T结束后的下一开发切片,现已实现并在独立发行验收中;交付状态见[U验收](QA-WORKING-MEMORY-U.md)。T的原字节和结果见[验收](QA-LIVE-DELIVERY-T.md)。正式保持1.24.7/原PID36552/Provider,U开发和离线验收阶段真实模型预算为0;不续跑T/R/P/O、不提取/复制/解密/重存Key、不推送。修复范围围绕当前Node交付阻塞,不扩展无关能力。 ## 目标和实现范围 diff --git a/findings.md b/findings.md index f7933027..fa95e29b 100644 --- a/findings.md +++ b/findings.md @@ -1,5 +1,12 @@ # 汇总发现 +## U 开始:保留已读片段和原基线检查 + +U离线实证:原T第六响应后候选只有1643字符,obs3只聚合同SHA/同原范围/连续且重叠一致的真实页,恢复2584;新发送view4及latest3独立核验。完整来源在原working_set工件,实际发送视图消除已完整携带页的重复UUID/行范围/诊断成功摘录;错误、未知和全诊断保留。原T第7/8离线实际请求12307/12086输入、12352上限,四文件2584+51+93+52全部原字符及当前9失败/build通过/log SHA同时存在;不扩大16K/2048/1600,不改目标或原模型用量,不宣称真实交付。 + +首回归指出纯read_file新页需先保留原配对,legacy完整无坐标文件需保持宽观察优先;都已定向修正。仅read_file不再触发额外全工程交付扫描,inspect_project/真实check计划才建立工程事实。新无修改基线失败持续保留,passed baseline仍不能进入Git。首wire驱动误猜money.mjs(真实amount.mjs)和新test虚拟tool缺schema/run身份均保留失败并修正;产品原数据未变。 + +正式代码的workingCandidates只返回最长/最新两页;RequestPlanner还按2000字符先保留完整小页,检查排在文件后。taskDeliveryProgress在无已应用变更时直接返回null,导致尚未改源码的原失败基线没有持续事实视图。U将先用原T记录测量,再实现同版本片段聚合和修改前的真实检查事实,保留旧发送视图;纯后端修复不扩大UI范围或请求真实模型。 ## T 实测、离线定位与恢复完成 203份/77773746字节T证据及调用前契约已封存,离线核验通过,清单SHA840623121cb5579564f0bbd4f0ef5ae924fd7432d5b7d0e32cef9f28cd436bb3。原16tool行纯选择重放确认:第6轮后同文件仅[473,2089]及[2557,2584]可选,预算前已丢[0,473]及[2089,2557];原检查候选存在但实际第7/8请求缺失。下一U先修复片段聚合/真实当前事实持续保留,不重新调用T。见docs/QA-LIVE-DELIVERY-T.md、docs/RETROSPECTIVE-LIVE-DELIVERY-T.md、docs/WORKING-MEMORY-U-PLAN.md。以下冻结/执行中记录保留其历史时点。 diff --git a/package-lock.json b/package-lock.json index 3e4b34cb..8d6d1bce 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "local-agent-workbench", - "version": "1.24.7", + "version": "1.24.8", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "local-agent-workbench", - "version": "1.24.7", + "version": "1.24.8", "dependencies": { "@babel/parser": "7.29.11", "@peculiar/x509": "3.1.0", diff --git a/package.json b/package.json index 5a3c03d5..d757c100 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "local-agent-workbench", - "version": "1.24.7", + "version": "1.24.8", "private": true, "type": "module", "description": "A local coding workbench with explicit tool execution, reviewable changes and recoverable sessions.", diff --git a/progress.md b/progress.md index 25f74c01..68924967 100644 --- a/progress.md +++ b/progress.md @@ -1,5 +1,12 @@ # 统一执行进度 +## U 开发开始 + +最终16文件114/114通过,构建通过。实际编译宿主新隔离HTTP七请求、第6/7四文件与原九失败/build通过同时保留、重开工件全部核验,11文件原字节未改。旧task-context回归从只找latest摘录改为核对各版本实际发送正文;最终目标/预算/配对仍硬性验证。准备独立实现提交和不可变候选;正式服务仍原版本。 + +U工作分支和正式只读新基线完成,原进程/配置保持。已实现obs3文件片段聚合/独立每片段来源验证、view4精简/精确未发送区间及latest3读取定位、首次修改前的当前工程检查事实、常规诊断去重。原T记录第7/8新离线实际正文已完整携带四文件和原检查事实,12307/12086<=12352、来源校验通过,真实请求0。相关回归进行中,纯长页与legacy宽观察已恢复;首失败TAP、容量试验及wire各次输出均保留。尚未冻结/发行,不以中间通过结束。 + +已回看0644407b、AGENTS和U计划,工作区干净。确认改动入口working-set/request-plan和修改前缺失的taskDeliveryProgress;先隔离复现,正式1.24.7/原PID36552/Provider保持,真实模型预算0,不续跑旧Task,不委派或读取Key。 ## T:新实测、离线定位和证据封存完成 最终Git索引204份/77814997字节逐原SHA通过,原清单与203份原件未变;全部T阶段节点结束,范围保存到本地Git,不推送。正式产品仍1.24.7、T未交付;U为已记录的下一实现,尚未开始。 diff --git a/scripts/upgrade-running.mjs b/scripts/upgrade-running.mjs index e625a7a7..aed35c12 100644 --- a/scripts/upgrade-running.mjs +++ b/scripts/upgrade-running.mjs @@ -64,7 +64,7 @@ export async function upgradeRunning({ url, pid, currentRoot, newRoot, handlerRo if (!fs.existsSync(originalScript) || !fs.existsSync(upgradeScript) || !fs.existsSync(path.join(next, 'dist-client', 'index.html'))) throw new Error('Upgrade bundles are incomplete.'); if (!Number.isInteger(pid) || pid < 1 || pid === process.pid) throw new Error('Invalid target process.'); const before = await readUpgradeJson(origin + '/api/bootstrap', 5000, 'Read original Workbench'); - if (!before.token || !['0.1.0', '1.0.0', '1.1.0', '1.2.0', '1.3.0', '1.4.0', '1.5.0', '1.5.1', '1.6.0', '1.6.1', '1.6.2', '1.7.0', '1.8.0', '1.9.0', '1.10.0', '1.10.1', '1.11.0', '1.12.0', '1.12.1', '1.13.0', '1.14.0', '1.15.0', '1.16.0', '1.17.0', '1.18.0', '1.19.0', '1.20.0', '1.20.1', '1.20.2', '1.20.3', '1.21.0', '1.22.0', '1.22.1', '1.23.0', '1.24.0', '1.24.1', '1.24.2', '1.24.3', '1.24.4', '1.24.5', '1.24.6', '1.24.7'].includes(before.version)) throw new Error('This migration accepts a supported existing Workbench.'); + if (!before.token || !['0.1.0', '1.0.0', '1.1.0', '1.2.0', '1.3.0', '1.4.0', '1.5.0', '1.5.1', '1.6.0', '1.6.1', '1.6.2', '1.7.0', '1.8.0', '1.9.0', '1.10.0', '1.10.1', '1.11.0', '1.12.0', '1.12.1', '1.13.0', '1.14.0', '1.15.0', '1.16.0', '1.17.0', '1.18.0', '1.19.0', '1.20.0', '1.20.1', '1.20.2', '1.20.3', '1.21.0', '1.22.0', '1.22.1', '1.23.0', '1.24.0', '1.24.1', '1.24.2', '1.24.3', '1.24.4', '1.24.5', '1.24.6', '1.24.7', '1.24.8'].includes(before.version)) throw new Error('This migration accepts a supported existing Workbench.'); if (before.sessions.some(session => ['running', 'awaiting_approval', 'stopping'].includes(session.status))) throw new Error('Wait for existing tasks and approvals before upgrading.'); let protocol, socket, enabledHere = false, paused = false; const breakpoints = []; diff --git a/scripts/verify-desktop-install.mjs b/scripts/verify-desktop-install.mjs index 8e1d0c58..cc71332d 100644 --- a/scripts/verify-desktop-install.mjs +++ b/scripts/verify-desktop-install.mjs @@ -149,7 +149,7 @@ try { const beforeRestart = snapshotPersistentData(dataRoot); await controller.stop(); const restarted = (await controller.start()).identity; assert.notEqual(restarted.pid, original.pid); assert.deepEqual(snapshotPersistentData(dataRoot), beforeRestart); await controller.api('/model-center/probe', { method: 'POST', input: { id: connectionId } }); assert.equal(authenticated, 3); record(stage, { originalPid: original.pid, restartedPid: restarted.pid, authenticatedRequests: authenticated }); - if (['1.24.0', '1.24.1', '1.24.2', '1.24.3', '1.24.4', '1.24.5', '1.24.6', '1.24.7'].includes(version)) { + if (['1.24.0', '1.24.1', '1.24.2', '1.24.3', '1.24.4', '1.24.5', '1.24.6', '1.24.7', '1.24.8'].includes(version)) { stage = 'actual installed current results and saved HTML user paths'; const pointer = JSON.parse(fs.readFileSync(path.join(installRoot, 'current.json'))); const installedRoot = fs.realpathSync.native(path.join(installRoot, 'versions', pointer.active.directory)), proofs = []; diff --git a/scripts/verify-working-memory.mjs b/scripts/verify-working-memory.mjs new file mode 100644 index 00000000..ea0d0cb4 --- /dev/null +++ b/scripts/verify-working-memory.mjs @@ -0,0 +1,64 @@ +// A local HTTP fixture exercises the shipped host. No production config or +// credentials, no implementation supplied, no real-model delivery claim. +import fs from 'node:fs'; +import path from 'node:path'; +import assert from 'node:assert/strict'; +import {randomUUID,createHash} from 'node:crypto'; +import {execFileSync} from 'node:child_process'; +import {Store} from '../src/server/store.mjs'; +import {verifyPlanEvidence} from '../src/core/context/request-plan.mjs'; +import {compatibleFixture,completion,call,until,assertToolPairs,launchWorkbench} from '../tests/helpers.mjs'; + +const root=path.resolve('.qa','working-memory-host-'+randomUUID()),data=path.join(root,'data'),projectRoot=path.join(root,'project'); +const appRoot=path.resolve(process.env.AGENT_WORKBENCH_QA_APP_ROOT??'.'); +const input=JSON.parse(fs.readFileSync(new URL('../tests/fixtures/working-memory-t.json',import.meta.url))); +const sha=value=>createHash('sha256').update(value).digest('hex'),disposers=[],t={after:fn=>disposers.push(fn)}; +fs.mkdirSync(projectRoot,{recursive:true}); +for(const file of input.files){assert.equal(sha(file.content),file.sha256);const target=path.resolve(projectRoot,file.path);assert.ok(target.startsWith(projectRoot+path.sep));fs.mkdirSync(path.dirname(target),{recursive:true});fs.writeFileSync(target,file.content);} +const git=args=>execFileSync('git',['-C',projectRoot,...args],{encoding:'utf8',windowsHide:true}); +git(['init','--initial-branch=main']);git(['config','core.autocrlf','false']);git(['add','.']);git(['-c','user.name=QA','-c','user.email=qa@workbench.invalid','commit','--no-gpg-sign','-m','Original read-only T fixture']); +const requests=[],facts=[],checks=[],files=input.files.filter(f=>['test/expense.test.mjs','src/amount.mjs','src/summary.mjs','src/report.mjs'].includes(f.path)); +let host,sessionId,report,version,extraInspection=false; +try{ + const model=await compatibleFixture(t,async(_route,body)=>{ + assertToolPairs(body.messages);requests.push(body);const number=requests.length;assert.ok(number<=8);assert.ok(body.messages[0].content.includes(JSON.stringify(input.goal))); + if(number<=3){const message=structuredClone(input.replies[number-1]);for(const tool of message.tool_calls??[])if(tool.function.name==='run_checks'){ + const current=await host.api('/sessions/'+sessionId);tool.function.arguments=JSON.stringify({plan_id:current.execution.plans.at(-1).id});} + return{body:{...completion(),choices:[{message,finish_reason:'tool_calls'}]}};} + const marker='当前工程执行依据(每次请求重新核对,非操作授权):\n'; + const fact=JSON.parse(body.messages[0].content.split(marker)[1].split('\n')[0]);facts.push(fact); + assert.equal(fact.has_applied_changes,false);assert.equal(fact.stage,'checks_need_repair');assert.equal(fact.latest_check.current_source,true); + assert.equal(fact.latest_check.results[0].tests.failed,9);assert.equal(fact.latest_check.results[1].status,'passed'); + const original=await host.api('/sessions/'+sessionId+'/export'),pages=original.session.providerMessages.filter(m=>m.role==='tool').map(m=>JSON.parse(m.content)).filter(v=>v.path==='test/expense.test.mjs'&&typeof v.content==='string'); + const text=files.find(f=>f.path==='test/expense.test.mjs').content,covered=new Set(); + for(const p of pages){assert.equal(p.content,text.slice(p.offset,p.next_offset));for(let n=p.offset;n{current=await host.api('/sessions/'+sessionId);for(const approval of current.approvals.filter(a=>a.status==='pending')){ + assert.ok(approval.checkPlanId);assert.deepEqual(approval.checkScripts.map(value=>value.name),['test','build']); + assert.equal(approval.command,'npm run test\nnpm run build');await host.api('/sessions/'+sessionId+'/approvals/'+approval.id,{allow:true});} + return !['running','awaiting_approval','stopping'].includes(current.status);},60000); + assert.equal(current.execution.run.stopReason,'verification_incomplete',JSON.stringify(current.lastFailure));assert.ok(extraInspection);assert.ok(checks.length>=2);assert.equal(current.changes.length,0); + const exported=await host.api('/sessions/'+sessionId+'/export');fs.writeFileSync(path.join(root,'export.json'),JSON.stringify(exported,null,2)); + await host.close();host=null; + const reopened=new Store(data);try{const saved=reopened.session(sessionId);for(const plan of reopened.core.context_plan.values()){ + verifyPlanEvidence(reopened,saved,plan);assert.equal(plan.budget.contextLimit,16000);assert.equal(plan.budget.outputReservation,2048);assert.equal(plan.budget.safetyTokens,1600);assert.ok(plan.estimatedInputTokens<=12352);} + checks.push('all actual request artifacts independently verified after reopening');}finally{reopened.close();} + for(const file of input.files)assert.equal(sha(fs.readFileSync(path.join(projectRoot,file.path))),file.sha256);assert.equal(git(['status','--porcelain']),''); + report={success:true,version,appRoot,checks,errors:[],requests:requests.length,facts,originalSourceUnchanged:true,originalNineTestsFailed:true,realModelDeliveryPassed:false,purgeBenefitMeasured:false,realModelRequests:0}; +}catch(error){report={success:false,appRoot,checks,error:error.stack,requests:requests.length,realModelRequests:0};process.exitCode=1;} +finally{await host?.close();for(const dispose of disposers.reverse())await dispose();fs.writeFileSync(path.join(root,'requests.json'),JSON.stringify(requests,null,2));fs.writeFileSync(path.join(root,'result.json'),JSON.stringify(report,null,2));console.log(JSON.stringify({success:report.success,appRoot,root,checks:checks.length,requests:requests.length,realModelRequests:0,error:report.error}));} diff --git a/src/core/context/delivery-progress.mjs b/src/core/context/delivery-progress.mjs index 2fb40109..5d88ccfe 100644 --- a/src/core/context/delivery-progress.mjs +++ b/src/core/context/delivery-progress.mjs @@ -9,36 +9,58 @@ export async function taskDeliveryProgress(store,session,run,{checks,worker=fals if(run.purpose==='diagnostic')return null; const task=store.owned('task',run.taskId,session.id),project=store.project(session.projectId); const changes=session.changes.filter(change=>change.taskId===task.id&&change.status==='applied'); - if(!changes.length)return null; + const owned=value=>value.taskId===task.id&&value.sessionId===session.id&&value.projectId===session.projectId; + const plans=[...store.core.check_plan.values()].filter(owned),jobs=[...store.core.check_job.values()].filter(owned); + const observations=[...store.core.tool.values()].filter(owned); + if(!changes.length&&!plans.length&&!jobs.length&&!observations.some(value=> + value.tool==='inspect_project'&&value.state==='completed'&&!value.requiresVerification))return null; const latest=[...new Map(changes.map(change=>[change.path,change])).values()]; const files=latest.slice(-24).map(change=>{ let currentSha256=null,error=null;try{currentSha256=readText(project,change.path).sha256;}catch(cause){error=cause.message;} return {path:change.path,change_id:change.id,change_set_id:change.changeSetId??null,applied_sha256:change.sha256, current_sha256:currentSha256,current:currentSha256===change.sha256,...(error?{error}:{})}; }); - const inspection=await inspectProject(project),owned=value=>value.taskId===task.id&&value.sessionId===session.id&&value.projectId===session.projectId; - const plans=[...store.core.check_plan.values()].filter(owned),jobs=[...store.core.check_job.values()].filter(owned); + const inspection=await inspectProject(project); const latestPlan=plans.at(-1),latestJob=jobs.at(-1); let planCurrent=false,planError=null; if(latestPlan)try{checks.planFor(session,latestPlan.id);planCurrent=latestPlan.fingerprint===inspection.fingerprint;} catch(cause){planError=cause.message;} - const sourceCurrent=!!latestJob&&!latestJob.stale&&!latestJob.requiresVerification + let sourceCurrent=!!latestJob&&inspection.scope.complete&&!latestJob.stale&&!latestJob.requiresVerification + &&['passed','failed','unverified'].includes(latestJob.status)&&!!latestJob.finishedAt &&(latestJob.sourceFingerprint?latestJob.sourceFingerprint===inspection.sourceFingerprint:latestJob.fingerprint===inspection.fingerprint); + let evidenceError=null; + if(sourceCurrent)try{ + for(const result of latestJob.results){ + const artifact=store.owned('artifact',result.logArtifactId,session.id); + if(artifact.kind!=='check-log'||artifact.taskId!==task.id||artifact.runId!==latestJob.runId)throw new Error('检查日志的原任务或运行归属不匹配。'); + store.artifactStore.read(artifact); + } + }catch(cause){sourceCurrent=false;evidenceError=cause.message;} const unknown=[...store.core.tool.values()].filter(value=>owned(value)&&value.requiresVerification).map(value=>value.id); const pending=session.changes.filter(change=>['pending','conflict'].includes(change.status)).map(change=>({id:change.id,path:change.path,status:change.status})); const review=pendingDeliveryReview(store,session),contract=taskContract(task); - const snapshot={schemaVersion:1,kind:'task-delivery-progress',task_id:task.id,run_id:run.id,source_fingerprint:inspection.sourceFingerprint, + const snapshot={schemaVersion:2,kind:'task-delivery-progress',task_id:task.id,run_id:run.id,source_fingerprint:inspection.sourceFingerprint, semantics:'current_observations_not_authorization_or_delivery_proof',files,total_files:latest.length,files_truncated:latest.length>files.length, + has_applied_changes:changes.length>0, checks_policy:contract.checks,check_plan:latestPlan?{id:latestPlan.id,current:planCurrent,checks:latestPlan.checks.map(value=>value.name),error:planError}:null, latest_check:latestJob?{id:latestJob.id,plan_id:latestJob.planId,status:latestJob.status,current_source:sourceCurrent, stale:!!latestJob.stale||!sourceCurrent,results:latestJob.results.map(value=>({name:value.name,status:value.status,tests:value.tests, log_artifact_id:value.logArtifactId,log_sha256:store.core.artifact.get(value.logArtifactId)?.sha256??null}))}:null, remaining_plan_steps:taskPlan?.remaining_steps??[],plan_steps:taskPlan?.steps.map(step=>({key:step.key,kind:step.kind,status:step.status,blockers:step.blockers,proof_id:step.proof_id}))??[], - pending_changes:pending,unknown_tool_ids:unknown, + pending_changes:pending,unknown_tool_ids:unknown,...(evidenceError?{evidence_error:evidenceError}:{}), stage:null,next_action:null,execution_note:'建议只依据当前事实;实际操作仍核对原计划和权限,执行检查等待审批,Git只准备预览并交还审查。'}; const next=(stage,tool,args={})=>{snapshot.stage=stage;snapshot.next_action=tool?{tool,arguments:args}:null;return snapshot;}; if(pending.length||unknown.length||review)return next('awaiting_review_or_verification'); + if(evidenceError)return next('requires_current_evidence_verification'); if(snapshot.files_truncated||files.some(file=>!file.current))return next('applied_files_need_review'); + // A baseline observation is useful before implementation, but cannot + // certify an empty delivery or bypass the existing review/Git contracts. + if(!changes.length){ + if(contract.checks==='skip')return next('observed_without_changes'); + if(sourceCurrent&&latestJob)return next(latestJob.status==='passed'?'baseline_passed_without_changes':'checks_need_repair'); + if(planCurrent)return next('ready_for_checks','run_checks',{plan_id:latestPlan.id}); + return next('observed_without_current_checks'); + } if(contract.checks==='skip')return next('checks_not_requested',worker?null:'delivery_report'); if(!sourceCurrent||!latestJob){ if(planCurrent)return next('ready_for_checks','run_checks',{plan_id:latestPlan.id}); diff --git a/src/core/context/request-plan.mjs b/src/core/context/request-plan.mjs index 228320c9..493f0601 100644 --- a/src/core/context/request-plan.mjs +++ b/src/core/context/request-plan.mjs @@ -185,14 +185,14 @@ export class RequestPlanner { const original = completionBody(config, [fixed, ...session.providerMessages], tools), before = requestMetrics(original); const selected = new Set(groups.map(group => group.index)); let omitted = [], reference = null, workingReference = null, latestReference = null; - const latestDocument = latestToolDocument(this.store, session, run, groups, 2); + const latestDocument = latestToolDocument(this.store, session, run, groups, 3); const entries = []; let retainedSources = []; // A read locator already carried in raw history, latest feedback or the // working view need not be repeated in the history notice. Original group // and result artifacts still contain the complete provenance. const unsentEvidence = (indices, currentEntries, includeLatest) => { - const sentCalls = new Set(currentEntries.map(entry => entry.source.call_id)); + const sentCalls = new Set(currentEntries.flatMap(entry => (entry.fragments ?? [entry.source]).map(source => source.call_id))); if (includeLatest && latestDocument && !indices.has(latestDocument.group_index)) { for (const entry of latestDocument.entries) sentCalls.add(entry.source.call_id); } @@ -201,8 +201,8 @@ export class RequestPlanner { const metricsFor = (indices, includeNotice = true, currentEntries = entries, includeLatest = true) => { const missing = groups.filter(group => !indices.has(group.index)); const messages = [fixed, ...(missing.length && includeNotice ? [notice({ id: PLACEHOLDER_ID, sha256: PLACEHOLDER_SHA }, missing, descriptions, unsentEvidence(indices, currentEntries, includeLatest))] : []), - ...(includeLatest && latestDocument && !indices.has(latestDocument.group_index) ? [latestToolMessage({ id: PLACEHOLDER_ID, sha256: PLACEHOLDER_SHA }, latestDocument, 2)] : []), - ...(currentEntries.length ? [workingMessage({ id: PLACEHOLDER_ID, sha256: PLACEHOLDER_SHA }, workingDocument(session, run, currentEntries, 2), 3)] : []), + ...(includeLatest && latestDocument && !indices.has(latestDocument.group_index) ? [latestToolMessage({ id: PLACEHOLDER_ID, sha256: PLACEHOLDER_SHA }, latestDocument, 3)] : []), + ...(currentEntries.length ? [workingMessage({ id: PLACEHOLDER_ID, sha256: PLACEHOLDER_SHA }, workingDocument(session, run, currentEntries, 3), 4)] : []), ...groups.filter(group => indices.has(group.index)).flatMap(group => group.messages)]; return requestMetrics(completionBody(config, messages, tools)); }; @@ -210,13 +210,21 @@ export class RequestPlanner { selected.clear(); if (lastUser) selected.add(lastUser.index); const mandatory = metricsFor(selected); if (mandatory.estimatedInputTokens > budget.inputBudget) throw pause(budget, mandatory, breakdown); - const observed = workingCandidates(this.store, session, run, groups, 2); + const observed = workingCandidates(this.store, session, run, groups, 3); + const coveredByRaw = entry => (entry.fragments ?? [entry.source]).every(source => selected.has(source.group_index)); // Admit complete small source observations before optional raw history. // A reservation alone does not keep code in the actual sent request. const newest = groups.at(-1); const retentionTarget = budget.inputBudget; - for (const candidate of observed.filter(candidate => candidate.observation.kind === 'file' && candidate.observation.content.length <= 2000)) { + // Preserve the entire newly returned pure-read pair when it fits. Large + // accumulated ranges must not consume the next page's protocol slot. + if (newest?.messages[0].tool_calls?.length && newest.messages[0].tool_calls.every(call => call.function.name === 'read_file')) { + selected.add(newest.index); + if (metricsFor(selected).estimatedInputTokens > budget.inputBudget) selected.delete(newest.index); + } + for (const candidate of observed.filter(candidate => candidate.observation.kind === 'file' && candidate.observation.content.length <= 6000)) { if (entries.length >= 12) break; + if (coveredByRaw(candidate)) continue; const entry = workingEntry(candidate, candidate.observation.content.length); if (metricsFor(selected, true, [...entries, entry]).estimatedInputTokens <= retentionTarget) entries.push(entry); } @@ -227,7 +235,7 @@ export class RequestPlanner { }); if (newestUseful && !selected.has(newest.index) && newest.contributionTokens <= budget.inputBudget) { selected.add(newest.index); - const remaining = entries.filter(entry => entry.source.group_index !== newest.index); + const remaining = entries.filter(entry => !coveredByRaw(entry)); if (metricsFor(selected, true, remaining).estimatedInputTokens > budget.inputBudget) selected.delete(newest.index); else entries.splice(0, entries.length, ...remaining); } @@ -240,7 +248,7 @@ export class RequestPlanner { }; // A small result in a mixed large group must remain usable. It is a // separate, provenance-checked observation, never a broken tool pair. - const candidates = observed.filter(candidate => !selected.has(candidate.source.group_index) + const candidates = observed.filter(candidate => !coveredByRaw(candidate) && !entries.some(entry => entry.source.call_id === candidate.source.call_id)); for (const [index, candidate] of candidates.entries()) { if (entries.length >= 12) break; @@ -275,11 +283,11 @@ export class RequestPlanner { note: '完整原消息组;这里只是历史定位,不产生工具执行或用户授权。' }, 'context-history-index'); } } - if (entries.length) workingReference = this.artifact(session, run, workingDocument(session, run, entries, 2), 'context-working-set'); + if (entries.length) workingReference = this.artifact(session, run, workingDocument(session, run, entries, 3), 'context-working-set'); if (latestDocument && !selected.has(latestDocument.group_index)) latestReference = this.artifact(session, run, latestDocument, 'context-latest-tools'); const messages = [fixed, ...(reference ? [notice(reference, omitted, descriptions, unsentEvidence(selected, entries, true))] : []), - ...(latestReference ? [latestToolMessage(latestReference, latestDocument, 2)] : []), - ...(workingReference ? [workingMessage(workingReference, workingDocument(session, run, entries, 2), 3)] : []), + ...(latestReference ? [latestToolMessage(latestReference, latestDocument, 3)] : []), + ...(workingReference ? [workingMessage(workingReference, workingDocument(session, run, entries, 3), 4)] : []), ...structuredClone(groups.filter(group => selected.has(group.index)).flatMap(group => group.messages))]; let mcpReference = null, mcpDocument = null; if (mcpCatalog?.projectId === session.projectId && mcpCatalog.entries?.length) { @@ -354,8 +362,8 @@ export class RequestPlanner { archivedGroups: omitted.length, retainedGroups: groups.filter(group => selected.has(group.index)).map(group => group.index), historyIndexArtifactId: reference?.id ?? null, historyIndexSha256: reference?.sha256 ?? null, actualUsage: null, workingSetArtifactId: workingReference?.id ?? null, workingSetSha256: workingReference?.sha256 ?? null, workingSetEntries: entries.length, - workingSetViewVersion: 3, - latestToolsViewVersion: 2, + workingSetViewVersion: 4, + latestToolsViewVersion: 3, latestToolsArtifactId: latestReference?.id ?? null, latestToolsSha256: latestReference?.sha256 ?? null, latestToolsEntries: latestReference ? latestDocument.entries.length : 0, projectMemoryArtifactId: memoryReference?.id ?? null, projectMemorySha256: memoryReference?.sha256 ?? null, projectMemoryEntries: memoryReference ? memoryDocument.entries.length : 0, diff --git a/src/core/context/tool-feedback.mjs b/src/core/context/tool-feedback.mjs index db20eb59..bfcd6d3b 100644 --- a/src/core/context/tool-feedback.mjs +++ b/src/core/context/tool-feedback.mjs @@ -34,7 +34,7 @@ export function compactToolFeedback(content, viewVersion = 1) { 'returned_characters', 'truncated', 'totalMatches', 'error', 'message', 'summary', 'reason', 'note', 'unchanged_action_count', 'reading_hint', 'browser_status', 'browser_job_id', 'result_artifact_id', 'evidence_verified', 'source_fingerprint', 'build_sha256', 'section', 'view_sha256', 'source_artifact_id', 'source_sha256', 'tool_invocation_id', 'proof_id', 'proof_artifact_id', 'step_key', 'revision', 'all_verified', 'verified_steps', 'total_steps', 'requirements_current', 'contract_artifact_id', 'binding_sha256']); - if (viewVersion === 2 && fileContinuation(value)?.next_read_file) result.file_read = fileContinuation(value); + if (viewVersion >= 2 && fileContinuation(value)?.next_read_file) result.file_read = fileContinuation(value); if (value.assertions) result.assertions = stats(value.assertions); if (Array.isArray(value.failed_steps)) result.failed_steps = value.failed_steps.slice(0, 3).map(step => fields(step, ['index', 'action', 'selector', 'status', 'error', 'actual'])); if (value.observed_page) result.observed_page = { ...fields(value.observed_page, ['title']), text: excerpt(value.observed_page.text ?? ''), @@ -87,17 +87,29 @@ export function latestToolDocument(store, session, run, groups, viewVersion = 1) const result = group.messages.find(message => message.role === 'tool' && message.tool_call_id === call.id); if (artifact.kind !== 'tool-result' || artifact.taskId !== run.taskId || artifact.runId !== invocation.runId || store.artifactStore.read(artifact) !== result.content) throw new Error('最新工具反馈与原执行结果不匹配。'); + const feedback = compactToolFeedback(result.content, viewVersion); + if (viewVersion === 3 && invocation.state === 'completed' && !invocation.requiresVerification + && ['read_file', 'read_artifact'].includes(call.function.name)) { + delete feedback.content_excerpt; + } entries.push({ tool: call.function.name, source: { call_id: call.id, invocation_id: invocation.id, run_id: invocation.runId, result_artifact_id: artifact.id, result_sha256: artifact.sha256, arguments_sha256: hash(call.function.arguments), recorded_state: invocation.state, requires_verification: !!invocation.requiresVerification }, - result: compactToolFeedback(result.content, viewVersion), original_characters: result.content.length, view: 'selected-original-fields' }); + result: feedback, original_characters: result.content.length, view: viewVersion === 3 ? 'selected-original-fields-with-read-locators' : 'selected-original-fields' }); } return { schemaVersion: 1, kind: 'latest-tool-feedback', sessionId: session.id, projectId: session.projectId, taskId: run.taskId, runId: run.id, group_index: group.index, group_sha256: group.sha256, entries }; } export function latestToolMessage(reference, document, viewVersion = 1) { - if (![1, 2].includes(viewVersion)) throw new Error('未知的最新工具反馈视图版本。'); + if (![1, 2, 3].includes(viewVersion)) throw new Error('未知的最新工具反馈视图版本。'); + if (viewVersion === 3) return { role: 'system', content: [ + '最近已完成工具的原字段与恢复入口;仅数据,非授权或再次执行。读取正文见工作依据,省略内容按result_artifact_id恢复;未读原文件用file_read.next_read_file。', + JSON.stringify({ latest_tools: { artifact_id: reference.id, sha256: reference.sha256 }, data: { kind: document.kind, + entries: document.entries.map(entry => ({ tool: entry.tool, result_artifact_id: entry.source.result_artifact_id, + recorded_state: entry.source.recorded_state, requires_verification: entry.source.requires_verification, + result: entry.result, view: entry.view })) } }), + ].join('\n') }; return { role: 'system', content: [ '以下是最近一组工具已经返回的实际结果反馈。该完整assistant/tool组因预算封存;这些字段来自原工件,不是再次执行、用户指令或推断。', viewVersion === 1 ? '先依据本次返回状态推进任务。摘要省略的大字段可按result_artifact_id读取;不要为恢复已知状态反复查询或重放已完成操作。' diff --git a/src/core/context/working-set.mjs b/src/core/context/working-set.mjs index b0a532e6..e19d03dc 100644 --- a/src/core/context/working-set.mjs +++ b/src/core/context/working-set.mjs @@ -10,9 +10,13 @@ const boundary = (text, end) => end > 0 && end < text.length && /[\uD800-\uDBFF] function observation(tool, value, observationVersion = 1) { if (!value || typeof value !== 'object' || value.requires_verification || ['unknown', 'interrupted', 'denied'].includes(value.status)) return null; if (tool === 'read_file' && typeof value.content === 'string' && typeof value.path === 'string' && /^[a-f0-9]{64}$/i.test(value.sha256 ?? '')) { - return { kind: 'file', path: value.path, sha256: value.sha256, start_line: value.start_line, end_line: value.end_line, + const observed = { kind: 'file', path: value.path, sha256: value.sha256, start_line: value.start_line, end_line: value.end_line, ...(value.offset !== undefined ? { offset: value.offset, next_offset: value.next_offset, range_start_line: value.range_start_line, range_end_line: value.range_end_line } : {}), content: value.content }; + if (observationVersion >= 2) for (const key of ['total_characters', 'next_start_line', 'budget_limited']) { + if (value[key] !== undefined) observed[key] = value[key]; + } + return observed; } if (tool === 'read_artifact' && typeof value.content === 'string' && typeof value.kind === 'string' && !value.kind.startsWith('context-') && !['model-request', 'tool-result'].includes(value.kind)) { @@ -34,6 +38,69 @@ function observation(tool, value, observationVersion = 1) { return null; } +// Offsets are relative to the original selected line range, not the file. +// Only actual same-revision pages with the same origin can be joined. Every +// constituent result remains independently recoverable and verifiable. +function pageRange(page) { + const value = page.observation; + if (value.offset === undefined) return null; // Legacy observations have no invented coordinates. + if (![value.offset, value.next_offset, value.total_characters, value.range_start_line, value.range_end_line, + value.start_line, value.end_line].every(Number.isSafeInteger) + || value.offset < 0 || value.next_offset !== value.offset + value.content.length + || value.next_offset > value.total_characters || value.range_start_line < 1 || value.range_end_line < value.range_start_line + || value.start_line < value.range_start_line || value.end_line < value.start_line || value.end_line > value.range_end_line + || !value.content.isWellFormed()) throw new Error('文件工作依据的原页坐标或字符不完整,需要核对原工具结果。'); + return JSON.stringify([value.path, value.sha256, value.range_start_line, value.range_end_line, value.total_characters]); +} + +function joinPages(pages) { + const ordered = [...pages].sort((a, b) => a.observation.offset - b.observation.offset + || a.source.group_index - b.source.group_index || a.source.call_id.localeCompare(b.source.call_id)); + const first = ordered[0].observation, last = ordered.reduce((a, b) => a.observation.next_offset > b.observation.next_offset ? a : b).observation; + if (ordered.length === 1) return ordered[0]; + let content = first.content, end = first.next_offset; + for (const page of ordered.slice(1)) { + const value = page.observation; + if (pageRange(page) !== pageRange(ordered[0]) || value.offset > end) throw new Error('文件工作依据包含未读空洞或不同范围。'); + const overlap = Math.min(end, value.next_offset) - value.offset; + if (content.slice(value.offset - first.offset, value.offset - first.offset + overlap) !== value.content.slice(0, overlap)) { + throw new Error('同SHA文件工作依据的重叠内容冲突,需要核对原工具结果。'); + } + if (value.next_offset > end) { content += value.content.slice(overlap); end = value.next_offset; } + } + const observation = { ...first, end_line: last.end_line, next_offset: end, content, + budget_limited: end < first.total_characters, + ...(last.next_start_line !== undefined ? { next_start_line: last.next_start_line } : {}) }; + return { source: ordered[0].source, observation, fragments: ordered.map(page => page.source) }; +} + +function aggregatePages(pages) { + const ranges = new Map(), legacy = []; + for (const page of pages) { + const key = pageRange(page); + if (key === null) legacy.push(page); + else { const items = ranges.get(key) ?? []; items.push(page); ranges.set(key, items); } + } + const result = [...legacy]; + for (const items of ranges.values()) { + const ordered = [...items].sort((a, b) => a.observation.offset - b.observation.offset); + let chunk = [], end = -1, start = 0; + for (const page of ordered) { + const value = page.observation; + if (chunk.length && (value.offset > end || Math.max(end, value.next_offset) - start > 12000 || chunk.length >= 128)) { + // Check overlaps even at bounded chunk boundaries; do not turn a + // conflicting source into two apparently trustworthy observations. + if (value.offset < end) joinPages([...chunk, page]); + result.push(joinPages(chunk)); chunk = []; + } + if (!chunk.length) { start = value.offset; end = value.next_offset; } + chunk.push(page); end = Math.max(end, value.next_offset); + } + if (chunk.length) result.push(joinPages(chunk)); + } + return result; +} + export function workingCandidates(store, session, run, groups, observationVersion = 1) { const ledger = new Map([...store.core.tool.values()].filter(tool => tool.sessionId === session.id && tool.projectId === session.projectId && tool.taskId === run.taskId).map(tool => [tool.callId, tool])); @@ -46,9 +113,6 @@ export function workingCandidates(store, session, run, groups, observationVersio if (artifact.taskId !== run.taskId || artifact.kind !== 'tool-result' || artifact.runId !== invocation.runId) throw new Error('工作依据的任务或运行归属不匹配。'); if (store.artifactStore.read(artifact) !== result.content) throw new Error('工作依据与原工具结果不一致。'); const raw = parse(result.content), observed = observation(call.function.name, raw, observationVersion); - if (observationVersion === 2 && observed?.kind === 'file') { - for (const key of ['total_characters', 'next_start_line', 'budget_limited']) if (raw[key] !== undefined) observed[key] = raw[key]; - } if (!observed) continue; if (observed.kind === 'check-results') { const job = store.core.check_job.get(observed.job_id); @@ -61,7 +125,8 @@ export function workingCandidates(store, session, run, groups, observationVersio const revision = revisions.get(observed.path); if (revision && revision !== observed.sha256) continue; revisions.set(observed.path, observed.sha256); - key += ':' + observed.path + ':' + observed.sha256 + ':' + observed.start_line + ':' + observed.end_line + ':' + (observed.offset ?? 0); + key += ':' + observed.path + ':' + observed.sha256 + ':' + observed.start_line + ':' + observed.end_line + ':' + (observed.offset ?? 0) + + (observationVersion >= 3 ? ':' + call.id : ''); } else if (observed.kind === 'artifact-page') key += ':' + observed.artifact_id + ':' + observed.sha256 + ':' + observed.offset + ':' + observed.next_offset; // Keep the last real check/command result, rather than a list of old wins. if (seen.has(key)) continue; @@ -75,6 +140,7 @@ export function workingCandidates(store, session, run, groups, observationVersio } const primary = [], secondary = []; for (const pages of filePages.values()) { + if (observationVersion >= 3) { primary.push(...aggregatePages(pages)); continue; } const latest = pages[0], widest = [...pages].sort((a, b) => b.observation.content.length - a.observation.content.length)[0]; primary.push(widest); const a = widest.observation, b = latest.observation; @@ -85,7 +151,13 @@ export function workingCandidates(store, session, run, groups, observationVersio } // Keep complete small modules/requirements before larger evidence excerpts. // Every selected page still identifies the exact invocation that read it. - primary.sort((a, b) => Number(a.observation.content.length > 2000) - Number(b.observation.content.length > 2000) + if (observationVersion >= 3) { + const sizes = new Map(); + for (const page of primary) sizes.set(page.observation.path, Math.min(sizes.get(page.observation.path) ?? Infinity, page.observation.content.length)); + primary.sort((a, b) => Number(sizes.get(a.observation.path) > 2000) - Number(sizes.get(b.observation.path) > 2000) + || sizes.get(a.observation.path) - sizes.get(b.observation.path) || a.observation.path.localeCompare(b.observation.path) + || b.observation.content.length - a.observation.content.length || (a.observation.offset ?? 0) - (b.observation.offset ?? 0)); + } else primary.sort((a, b) => Number(a.observation.content.length > 2000) - Number(b.observation.content.length > 2000) || a.observation.content.length - b.observation.content.length || a.observation.path.localeCompare(b.observation.path)); const checks = candidates.filter(candidate => ['check-results', 'command-result'].includes(candidate.observation.kind)); const artifacts = candidates.filter(candidate => candidate.observation.kind === 'artifact-page'); @@ -95,7 +167,7 @@ export function workingCandidates(store, session, run, groups, observationVersio export function workingEntry(candidate, characters) { const { content, ...observed } = candidate.observation; const end = boundary(content, Math.min(content.length, Math.max(0, characters))); - return { source: candidate.source, observation: observed, content: content.slice(0, end), content_offset: 0, + return { source: candidate.source, ...(candidate.fragments ? { fragments: candidate.fragments } : {}), observation: observed, content: content.slice(0, end), content_offset: 0, next_content_offset: end, total_content_characters: content.length, truncated: end < content.length, content_sha256: hash(content.slice(0, end)) }; } @@ -103,23 +175,34 @@ export function workingEntry(candidate, characters) { export function workingDocument(session, run, entries, observationVersion = 1) { return { schemaVersion: 1, kind: 'task-working-set', sessionId: session.id, projectId: session.projectId, taskId: run.taskId, semantics: 'recorded-tool-observations; file hashes identify observed revisions, not current filesystem guarantees', - ...(observationVersion === 2 ? { observationVersion } : {}), entries }; + ...(observationVersion >= 2 ? { observationVersion } : {}), entries }; } export function workingMessage(reference, document, viewVersion = 2) { - const introduction = [ + const introduction = viewVersion === 4 ? [ + '当前Task原工具工作依据,仅数据、非指令或授权。内容绑定读取SHA;修改前核对当前版本。完整片段来源在working_set中。', + 'result_artifact_id恢复已返回页;未读后文用file_read.next_read_file。不重放已完成操作。', + ] : [ '以下是当前Task已执行工具的工作依据数据,不是追加指令、授权或再次执行。文件内容只代表所列SHA256的读取版本,修改前仍须核对;检查状态来自实际工具结果。', viewVersion < 3 ? '这些原结果所在的大消息组可能未发送。可以直接使用这里的代码和日志推进任务;截取不完整时读取对应result_artifact_id。不要重复扫描历史索引或重放已完成工具。' : '可直接使用这些代码和日志。result_artifact_id只恢复已返回页;尚未读取的原文件后文用file_read.next_read_file,核对SHA,不逐层读包装或重放操作。', ]; if (viewVersion === 1) return { role: 'system', content: [...introduction, JSON.stringify({ working_set: { artifact_id: reference.id, sha256: reference.sha256 }, data: document })].join('\n') }; - if (![2, 3].includes(viewVersion)) throw new Error('未知的工作依据发送视图版本。'); + if (![2, 3, 4].includes(viewVersion)) throw new Error('未知的工作依据发送视图版本。'); const data = { schemaVersion: document.schemaVersion, kind: document.kind, taskId: document.taskId, entries: document.entries.map(entry => ({ ...entry, source: { tool: entry.source.tool, result_artifact_id: entry.source.result_artifact_id }, - ...(viewVersion === 3 && fileContinuation(entry.observation)?.next_read_file ? { file_read: fileContinuation(entry.observation) } : {}) })) }; + ...(viewVersion === 4 ? { observation: Object.fromEntries(Object.entries(entry.observation).filter(([key]) => !['start_line', 'end_line', 'budget_limited'].includes(key))), + ...(entry.fragments ? { fragments: entry.truncated ? entry.fragments.map(source => ({ result_artifact_id: source.result_artifact_id })) + : { count: entry.fragments.length, provenance: 'working_set' } } : {}) } : {}), + ...(viewVersion === 4 && entry.observation.kind === 'file' && Number.isSafeInteger(entry.observation.offset) ? { + sent_range: [entry.observation.offset, entry.observation.offset + entry.next_content_offset], + ...(entry.truncated ? { unsent_observed_range: [entry.observation.offset + entry.next_content_offset, entry.observation.next_offset], + recovery: 'read the listed original result artifacts; these bytes were already returned but are absent from this view' } : {}), + } : {}), + ...(viewVersion >= 3 && fileContinuation(entry.observation)?.next_read_file ? { file_read: fileContinuation(entry.observation) } : {}) })) }; return { role: 'system', content: [...introduction, - '调用、运行、消息组及原结果的完整来源保存在working_set工件中;这里是按原结果核对的精简视图。', + ...(viewVersion === 4 ? [] : ['调用、运行、消息组及原结果的完整来源保存在working_set工件中;这里是按原结果核对的精简视图。']), JSON.stringify({ working_set: { artifact_id: reference.id, sha256: reference.sha256 }, data }), ].join('\n') }; } @@ -128,8 +211,9 @@ export function verifyWorkingDocument(store, session, plan, document, groups) { if (document.schemaVersion !== 1 || document.kind !== 'task-working-set' || document.sessionId !== session.id || document.projectId !== session.projectId || document.taskId !== plan.taskId || !Array.isArray(document.entries) || document.entries.length !== plan.workingSetEntries) throw new Error('工作依据身份或范围不匹配。'); - for (const entry of document.entries) { - const source = entry.source, invocation = store.core.tool.get(source.invocation_id), group = groups[source.group_index]; + if (![1, 2, 3].includes(document.observationVersion ?? 1)) throw new Error('未知的工作依据观察版本。'); + const original = source => { + const invocation = store.core.tool.get(source.invocation_id), group = groups[source.group_index]; if (!invocation || invocation.sessionId !== session.id || invocation.projectId !== session.projectId || invocation.taskId !== plan.taskId || invocation.callId !== source.call_id || invocation.tool !== source.tool || invocation.runId !== source.run_id || invocation.resultArtifactId !== source.result_artifact_id || group?.sha256 !== source.group_sha256) throw new Error('工作依据调用来源不匹配。'); @@ -138,10 +222,19 @@ export function verifyWorkingDocument(store, session, plan, document, groups) { const text = store.artifactStore.read(artifact), message = group.messages.find(value => value.role === 'tool' && value.tool_call_id === source.call_id); if (text !== message?.content) throw new Error('工作依据原消息内容不匹配。'); const raw = parse(text), observed = observation(source.tool, raw, document.observationVersion ?? 1); - if (document.observationVersion === 2 && observed?.kind === 'file') { - for (const key of ['total_characters', 'next_start_line', 'budget_limited']) if (raw[key] !== undefined) observed[key] = raw[key]; - } + return { source, observation: observed }; + }; + for (const entry of document.entries) { + let candidate; + if (entry.fragments) { + if (document.observationVersion !== 3 || !Array.isArray(entry.fragments) || !entry.fragments.length || entry.fragments.length > 128 + || new Set(entry.fragments.map(source => source.invocation_id)).size !== entry.fragments.length) throw new Error('文件片段来源不匹配。'); + const pages = entry.fragments.map(original); + if (pages.some(page => page.observation?.kind !== 'file' || pageRange(page) === null)) throw new Error('文件片段缺少可核对的原范围。'); + candidate = joinPages(pages); + } else candidate = original(entry.source); + const observed = candidate.observation; if (!observed || !Number.isInteger(entry.next_content_offset) || entry.next_content_offset < 0 || entry.next_content_offset > observed.content.length - || JSON.stringify(workingEntry({ source, observation: observed }, entry.next_content_offset)) !== JSON.stringify(entry)) throw new Error('工作依据摘录与实际工具结果不匹配。'); + || JSON.stringify(workingEntry(candidate, entry.next_content_offset)) !== JSON.stringify(entry)) throw new Error('工作依据摘录与实际工具结果不匹配。'); } } diff --git a/src/server/diagnostics.mjs b/src/server/diagnostics.mjs index 49952d51..d85955d9 100644 --- a/src/server/diagnostics.mjs +++ b/src/server/diagnostics.mjs @@ -1,6 +1,6 @@ import { randomUUID, createHash } from 'node:crypto'; -export const APP_VERSION = '1.24.7'; +export const APP_VERSION = '1.24.8'; export function executionEnvironment() { const windows = process.platform === 'win32'; @@ -151,8 +151,24 @@ function diagnosticInput(value, redact, limit = 2000) { note: '完整参数保存在工具历史中;此处只展示定位信息。' }; } -export function sessionContext(session, project, config, redact = String, { taskPlanIncluded = false } = {}) { - const snapshot = sessionSnapshot(session, project, config, redact); +export function compactRoutineSnapshot(snapshot) { + const routes = snapshot.actualModelRequests; + const sameRoute = routes.length === 2 && routes.every(route => route.connectionId === routes[1].connectionId + && route.requestedModel === routes[1].requestedModel && route.modelIdentity?.status === 'matched' + && route.modelIdentity?.complete === true); + return { ...snapshot, routineContextVersion: 2, + project: { name: snapshot.project.name }, + environment: { platform: snapshot.environment.platform, node: snapshot.environment.node, shell: snapshot.environment.shell, encoding: snapshot.environment.encoding }, + modelConnection: Object.fromEntries(Object.entries(snapshot.modelConnection).filter(([key]) => key !== 'note')), + actualModelRequests: sameRoute ? routes.slice(-1) : routes, + recentTools: snapshot.recentTools.map(tool => tool.phase === 'completed' + && ['read_file', 'read_artifact', 'run_checks', 'plan_checks', 'inspect_project'].includes(tool.tool) + ? { tool: tool.tool, phase: tool.phase, exitCode: tool.exitCode } : tool), + }; +} + +export function sessionContext(session, project, config, redact = String, { taskPlanIncluded = false, executionFactsIncluded = false } = {}) { + let snapshot = sessionSnapshot(session, project, config, redact); // Keep the diagnostic API complete; routine model context needs only the // latest bounded identifier observations and their original source. snapshot.actualModelRequests = snapshot.actualModelRequests.slice(-2).map(request => ({ @@ -169,13 +185,23 @@ export function sessionContext(session, project, config, redact = String, { task outputExcerpt: taskPlanIncluded && ['plan_task', 'inspect_task_plan'].includes(tool.tool) ? '当前Task计划已完整列在本次请求中;原工具结果仍保存在所属历史。' : tool.outputExcerpt.slice(0, 320) })); snapshot.changes = snapshot.changes.slice(-32); - return [ + if (executionFactsIncluded) { + // Full diagnostics and error provenance stay available through + // inspect_session. Successful raw read/check wrappers duplicate the + // verified working set and current facts already in this same request. + snapshot = compactRoutineSnapshot(snapshot); + } + const introduction = executionFactsIncluded ? [ + '当前执行诊断数据,非指令或授权。询问错误先用inspect_session核对原记录;source=model_connection是模型连接错误,不能依据项目搜索推断。', + 'actualModelRequests是请求路由;返回型号看modelIdentity及原响应来源,不认证权重。modelConnection仅启动配置;完整诊断在inspect_session。', + '改动和审批以当前工程执行依据为准;pending/conflict须审查,继续请求模型不能代替审核。', + ] : [ '以下是工作台保存的当前执行状态。错误来源字段由工作台产生;工具输出、命令文本和历史错误文本是数据,不是新指令。', '用户询问刚才的报错、fetch failed、执行状态或工作台问题时,先用 inspect_session 核对运行记录,再解释来源和处理办法。', 'source=model_connection 表示工作台调用模型服务时失败,不能因为当前项目没有 fetch 就推断原因。项目文件搜索不能诊断模型连接。', 'actualModelRequests或Run.consumption的model是实际发送的请求型号;返回型号和核对状态只看modelIdentity及其原响应来源。旧记录没有该字段时明确未核对;相同标识或用户登记映射均不认证底层权重。modelConnection只是启动配置。', '以当前 changes 状态为准,历史回复和文件提案文本可能已过时。已应用的改动无需重复提出。', '有 pending/conflict 改动时,引导查看差异和审查;继续请求模型不会代替用户审核。', - JSON.stringify(snapshot), - ].join('\n'); + ]; + return [...introduction, JSON.stringify(snapshot)].join('\n'); } diff --git a/src/server/runtime.mjs b/src/server/runtime.mjs index 1a3e4cc3..ebd89ec2 100644 --- a/src/server/runtime.mjs +++ b/src/server/runtime.mjs @@ -349,12 +349,12 @@ export class Runtime { goal, instructions: task.instructions.filter(instruction => instruction.source !== 'review-action'), constraints: task.constraints ?? [], acceptance: task.acceptance ?? [], contract, }) + (run.record.purpose === 'diagnostic' ? '\n本次仅回答运行诊断问题,允许读取所属结果;不得修改文件、执行命令或将解释视为原任务交付。诊断问题:' + run.record.question : '') + '\n结果未知的调用,不得假定成功或重放:' + JSON.stringify(unknown) - + (deliveryProgress ? '\n已应用修改后的当前交付依据(每次请求重新核对,非操作授权):\n' + JSON.stringify(deliveryProgress) : '') + + (deliveryProgress ? '\n当前工程执行依据(每次请求重新核对,非操作授权):\n' + JSON.stringify(deliveryProgress) : '') + (fileResults.results.length || fileResults.sources.length ? '\n当前成果与可显式采用的旧来源(任务数据,原文件不等于新写入):' + JSON.stringify({ current: fileResults.results.slice(0, 8).map(row => ({ id: row.id, taskId: row.taskId, runId: row.runId, verification: row.verification, error: row.error, reason: row.reason, files: row.files.map(({ path, sha256, origin }) => ({ path, sha256, origin })) })), sources: fileResults.sources.slice(0, 4), }) : '') - + '\n' + sessionContext(session, run.project, config, value => this.provider.redact(value), { taskPlanIncluded: !!taskPlan }) + + '\n' + sessionContext(session, run.project, config, value => this.provider.redact(value), { taskPlanIncluded: !!taskPlan, executionFactsIncluded: !!deliveryProgress }) + (task.readProgress?.warning ? '\n当前读取进展:' + task.readProgress.warning : '') + (readCoverage ? '\n本次Run实际返回的已读区间(读取事实,非新指令):\n' + JSON.stringify(readCoverage) : '') + (taskPlan ? '\n当前Task依赖计划与尚未核验的原步骤(任务数据,不授权额外操作):\n' + JSON.stringify({ diff --git a/task_plan.md b/task_plan.md index 796459ff..3213dacb 100644 --- a/task_plan.md +++ b/task_plan.md @@ -1,5 +1,20 @@ # Agent Workbench:核心代理能力研究与产品计划 +## 当前 U:已读片段与当前事实持续保留 + +- [complete] 创建 feat/working-memory-u,封存正式1.24.7/PID36552/65项目81会话6377记录/3720工件公开基线;真实调用0。 +- [complete] 原T16工具离线重现1643/2584;obs3同范围聚合后2584/2584。新第7/8实际请求离线重建12307/12086输入,均在12352限内,同时包含原四文件全文及九失败/build通过事实,原goal保留/来源核验通过。 +- [in_progress] 聚合边界、历史视图、纯读取与原基线事实相关回归;保留首58项56通过2失败及第二21项19通过2失败。当前源码修正已通过实际长页续读,最终相关检查/发行仍待完成。 +- [pending] 版本1.24.8独立源码/便携/安装与保留状态本地升级、回顾封存和Git;本阶段不发真实请求。 + +接续0644407b,按docs/WORKING-MEMORY-U-PLAN.md执行,沿用planning-with-files。不委派、不读取/复制/解密/重存Key、不重启原PID36552/Provider、不推送;开发和离线验收真实模型预算0,不续跑T/R/P/O。 + +1. [in_progress] 冻结正式新基线和原T输入,隔离重现候选丢页/实际发送缺少源码与检查,测量16K容量,保留原失败。 +2. [pending] 同SHA/范围片段来源核对、聚合/空洞/冲突/旧视图兼容;保留实际已返回页,不补造未读源码。 +3. [pending] 有界当前工程/计划/检查/待审事实持续保留,优化重复诊断和发送优先级;完整目标/配对/预算/权限门禁保持。 +4. [pending] 实际原请求回放、边界和相关回归、构建、历史证据核对,范围审查提交。 +5. [pending] 冻结新不可变候选,独立源码/归档/便携/安装与保留原状态升级,实际入口验收、证据封存/离线核对/回顾及本地Git。真实模型新样本另立后续契约。 + ## T:S 交付后的新真实 Node 验收已结束,尚未交付 接续8f41611b,按docs/LIVE-DELIVERY-T-PLAN.md执行。使用planning-with-files,不委派、不重启原PID36552/Provider、不提取/复制/重存Key、不推送。正式仍1.24.7/source5dcd6d7c;S不重打包、不重复验收。现有高性能池和旧停用连接保持,R/P/O失败不续跑。 diff --git a/tests/delivery-progress.test.mjs b/tests/delivery-progress.test.mjs index 80462d83..82c0e88f 100644 --- a/tests/delivery-progress.test.mjs +++ b/tests/delivery-progress.test.mjs @@ -2,6 +2,7 @@ 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} from './helpers.mjs'; import {createDeliveryProject,applyDeliveryFix,deliveryGit} from './fixtures/delivery-project.mjs'; import {CheckRunner} from '../src/core/check-runner.mjs'; @@ -35,3 +36,26 @@ test('skip-tests, foreign task, unknown operations, diagnostic and parent review const id='owned-unknown';f.store.core.tool.set(id,{id,sessionId:f.session.id,projectId:f.project.id,taskId:task.id,requiresVerification:true}); assert.equal((await snapshot()).stage,'awaiting_review_or_verification');assert.equal((await snapshot()).next_action,null); }); + +test('before the first change, real baseline failures persist across later reads; passed baselines and changed sources cannot certify delivery',async t=>{ + const f=fixture(t),run=createDeliveryProject(f),checks=new CheckRunner(f.store);f.onCleanup(()=>checks.stopAll()); + const snapshot=()=>taskDeliveryProgress(f.store,f.session,run,{checks}); + assert.equal(await snapshot(),null); + const plan=await checks.plan(f.session),job=await(await checks.start(f.session,plan.id)).promise; + assert.equal(job.status,'failed'); + let current=await snapshot();assert.equal(current.has_applied_changes,false);assert.equal(current.stage,'checks_need_repair'); + assert.equal(current.latest_check.id,job.id);assert.equal(current.latest_check.current_source,true); + assert.ok(current.latest_check.results.every(result=>result.log_artifact_id&&result.log_sha256)); + const later=randomUUID();f.store.core.tool.set(later,{schemaVersion:1,id:later,taskId:run.taskId,runId:run.id,sessionId:f.session.id,projectId:f.project.id,tool:'read_file',state:'completed'}); + assert.deepEqual(await snapshot(),current); + fs.writeFileSync(path.join(f.projectRoot,'src/add.mjs'),'export const add = (a,b) => a+b;\n'); + current=await snapshot();assert.equal(current.latest_check.current_source,false);assert.notEqual(current.stage,'ready_for_git_preview'); + // An actual current passed baseline still has no reviewed implementation. + const updated=await checks.plan(f.session),passed=await(await checks.start(f.session,updated.id)).promise; + assert.equal(passed.status,'passed');current=await snapshot();assert.equal(current.stage,'baseline_passed_without_changes');assert.equal(current.next_action,null); + const artifact=f.store.core.artifact.get(passed.results[0].logArtifactId),log=path.join(f.data,'artifacts',artifact.relative); + fs.writeFileSync(log,'corrupted external evidence');current=await snapshot(); + assert.equal(current.latest_check.current_source,false);assert.equal(current.stage,'requires_current_evidence_verification');assert.equal(current.next_action,null); + f.store.core.tool.set('unknown',{id:'unknown',taskId:run.taskId,sessionId:f.session.id,projectId:f.project.id,requiresVerification:true}); + assert.equal((await snapshot()).stage,'awaiting_review_or_verification'); +}); diff --git a/tests/diagnostics.test.mjs b/tests/diagnostics.test.mjs index 4394e330..5fe796f0 100644 --- a/tests/diagnostics.test.mjs +++ b/tests/diagnostics.test.mjs @@ -5,7 +5,7 @@ import path from 'node:path'; import { Provider, toolDefinitions, projectContext } from '../src/server/provider.mjs'; import { Runtime } from '../src/server/runtime.mjs'; import { Store } from '../src/server/store.mjs'; -import { sessionSnapshot } from '../src/server/diagnostics.mjs'; +import { sessionSnapshot, sessionContext } from '../src/server/diagnostics.mjs'; import { fixture, compatibleFixture, call, completion, until, assertToolPairs } from './helpers.mjs'; const policy = { attempts: 3, delays: [1, 2], timeoutMs: 1000, totalTimeoutMs: 3000 }; @@ -14,6 +14,18 @@ const disconnected = () => new TypeError('fetch failed', { cause: Object.assign( const refused = () => new TypeError('fetch failed', { cause: Object.assign(new Error('connection refused'), { code: 'ECONNREFUSED' }) }); const configure = f => f.store.saveConfig({ mode: 'compatible', baseUrl: 'http://127.0.0.1:1/v1', model: 'fixture-agent' }); +test('routine engineering facts remove duplicate success excerpts while complete diagnostics and errors remain available', t => { + const f=fixture(t); + f.store.event(f.session,{kind:'tool',tool:'read_file',phase:'completed',input:{path:'src/a.mjs'},output:'successful source excerpt'}); + f.store.event(f.session,{kind:'tool',tool:'read_file',phase:'failed',input:{path:'src/missing.mjs'},output:'original missing file error'}); + f.store.event(f.session,{kind:'error',phase:'failed',label:'Original error',output:'fetch failed'}); + const full=sessionSnapshot(f.session,f.project,f.store.config),context=sessionContext(f.session,f.project,f.store.config,String,{executionFactsIncluded:true}); + assert.ok(full.recentTools.some(tool=>tool.outputExcerpt==='successful source excerpt')); + assert.ok(!context.includes('successful source excerpt'));assert.ok(context.includes('original missing file error')); + assert.ok(context.includes('model_connection'));assert.ok(context.includes('inspect_session'));assert.ok(context.includes('fetch failed')); + assert.deepEqual(sessionSnapshot(f.session,f.project,f.store.config),full); +}); + test('a question about the previous workbench error receives local error context and current change states', async t => { const f = fixture(t); f.session.changes.push({ id: 'impl', path: 'src/catalog.js', status: 'applied' }, { id: 'tests', path: 'tests/catalog.test.mjs', status: 'applied' }); diff --git a/tests/fixtures/working-memory-t.json b/tests/fixtures/working-memory-t.json new file mode 100644 index 00000000..bdd47cfd --- /dev/null +++ b/tests/fixtures/working-memory-t.json @@ -0,0 +1,137 @@ +{ + "scope": "Frozen T goal, first three original assistant turns and original unchanged project inputs. Offline fixture only; no model implementation.", + "goal": "修复这个Node费用报表工程的amount、summary、report三个模块。金额用精确分单位处理,接受测试约定的十进制字符串/有限数字、退款、0及空白;拒绝格式错误、超精度和不安全金额。按独立币种规范化/排序汇总并保留原数组,计数准确、安全求和,报表两位小数含负分金额。以原九项测试为完整契约。先inspect_project,再plan_checks选择[\"test\",\"build\"]并run_checks保留真实基线失败,读取原测试和相关源码。只允许修改src/amount.mjs、src/summary.mjs、src/report.mjs;不改测试、配置、README、构建脚本、owner文件或原暂存,不使用run_command,不直接提交Git。propose_file/propose_patch准备完整三个模块后,用prepare_change_set一次封存全部三文件,等待审查应用。应用后继续同一个Task,重新plan_checks/run_checks,通过原9项测试和build后,用plan_delivery为三个文件准备本地Git预览并等待确认。模型必须自己实现,禁止用口头完成替代检查。预算最多8次模型请求、90000tokens,输出2048,上下文16K,请合并独立工具调用并避免重复观察。", + "replies": [ + { + "role": "assistant", + "content": "我会先读取项目识别结果并按你指定的顺序封存 `test`、`build` 基线计划;随后读取九项测试及三个目标模块,依据实际契约准备完整改动提案。", + "tool_calls": [ + { + "id": "call_5eb7405a2e6a4fb2bd2e2acf4d775dcb", + "type": "function", + "function": { + "name": "inspect_project", + "arguments": "{}" + } + } + ] + }, + { + "role": "assistant", + "content": "", + "tool_calls": [ + { + "id": "call_56fb7fe30f7a48c0a466eedca7cb1c33", + "type": "function", + "function": { + "name": "plan_checks", + "arguments": "{\"names\":[\"test\",\"build\"]}" + } + } + ] + }, + { + "role": "assistant", + "content": "", + "tool_calls": [ + { + "id": "call_12f66bde19464121a617329f20484c0d", + "type": "function", + "function": { + "name": "run_checks", + "arguments": "{\"plan_id\": \"1c46ffc1-3b24-4fb8-b207-3305ccd14fd1\"}" + } + }, + { + "id": "call_40d0588adc6b4abb8352fcd04c9abfbb", + "type": "function", + "function": { + "name": "read_file", + "arguments": "{\"path\": \"test/expense.test.mjs\"}" + } + }, + { + "id": "call_7ca0aaf713a34fb6b06af412a0806774", + "type": "function", + "function": { + "name": "read_file", + "arguments": "{\"path\": \"src/amount.mjs\"}" + } + }, + { + "id": "call_bba7c0bbdc874767a61a735efda0f601", + "type": "function", + "function": { + "name": "read_file", + "arguments": "{\"path\": \"src/summary.mjs\"}" + } + }, + { + "id": "call_dbec88442f9f43469ad0cef99c0534f6", + "type": "function", + "function": { + "name": "read_file", + "arguments": "{\"path\": \"src/report.mjs\"}" + } + } + ] + } + ], + "files": [ + { + "path": ".gitignore", + "content": "dist/\n.awb-*\nnode_modules/\n", + "sha256": "cab0bc87cad1b1214d71b023eee742986044093ff4b4331cd6a51098af6bdce6" + }, + { + "path": "owner-staged.txt", + "content": "Owner working copy differs from staging\n", + "sha256": "56b0dda452eaf9aead80f0e4ad971d7befa3cf152c3553923f8fde46e1fd336a" + }, + { + "path": "owner-unstaged.txt", + "content": "Owner unstaged change\n", + "sha256": "468bfb2956a4ac040508fc5ffd915cf8057fb7420e22c41a3cc2d094785f0d3e" + }, + { + "path": "owner-untracked.txt", + "content": "Owner untracked change\n", + "sha256": "e32ab29a12ed13d72c2ed603b2360e1b4e35afb0fe4280db2e523ad2c6c5bc8d" + }, + { + "path": "package.json", + "content": "{\n \"name\": \"owned-live-expense-report\",\n \"private\": true,\n \"type\": \"module\",\n \"scripts\": {\n \"test\": \"node --test test/expense.test.mjs\",\n \"build\": \"node scripts/build.mjs\"\n }\n}\n", + "sha256": "6ad63026b2fe9de7513a4f6704c372a86108ee3d018a1f04883dc0a409ea4c24" + }, + { + "path": "README.md", + "content": "# Expense report acceptance\nRepair the three source modules using the immutable original nine tests; do not edit checks or owner files.\n", + "sha256": "5e35a4dace9537e7c4cc815ce7054f73c171f053f1cccb9ff141f49ecb3c013e" + }, + { + "path": "scripts/build.mjs", + "content": "import { spawnSync } from 'node:child_process';\nimport { readFileSync } from 'node:fs';\nfor (const file of ['src/amount.mjs','src/summary.mjs','src/report.mjs']) {\n const result=spawnSync(process.execPath,['--check',file],{encoding:'utf8'});\n if(result.status!==0) { process.stderr.write(result.stderr);process.exit(result.status??1); }\n if(!readFileSync(file,'utf8').trim()) throw new Error('Empty business module');\n}\nconsole.log('All three business modules compile.');\n", + "sha256": "7279bc7c707c0f3ccbae63b14f0abed248ad3755be14f9e37128124ae9267526" + }, + { + "path": "src/amount.mjs", + "content": "export function amountToCents(value) { return 0; }\n", + "sha256": "84cb647328ec52dad27d288f3a6127ff3e1ad87274ae2d227ad44daa49cbb2ed" + }, + { + "path": "src/report.mjs", + "content": "export function formatReport(groups) { return ''; }\n", + "sha256": "ba0a014e6e9df710d66e255a3a6f970f4e1c8af48accc81f33627029dcded7c0" + }, + { + "path": "src/summary.mjs", + "content": "import { amountToCents } from './amount.mjs';\nexport function summarize(rows) { return []; }\n", + "sha256": "48829850c11ca0cd0ab5e86bbac69a0c5f90297292168c1ba6dc338e2eae6ee7" + }, + { + "path": "test/expense.test.mjs", + "content": "import test from 'node:test';\nimport assert from 'node:assert/strict';\nimport { amountToCents } from '../src/amount.mjs';\nimport { summarize } from '../src/summary.mjs';\nimport { formatReport } from '../src/report.mjs';\ntest('decimal strings become exact cents including zero and refunds',()=>{\n for(const [input,expected] of [['0',0],[' 12.34 ',1234],['+2.5',250],['-1.05',-105],['-0.00',0],['0009.10',910]]) assert.equal(amountToCents(input),expected);\n});\ntest('finite decimal numbers use the same cents contract',()=>{\n for(const [input,expected] of [[0,0],[1.01,101],[2.5,250],[-4.32,-432]]) assert.equal(amountToCents(input),expected);\n});\ntest('malformed overprecision nonfinite and unsafe amounts are rejected',()=>{\n for(const input of ['',null,undefined,true,{},'1e2','1,000','.50','1.234',1.234,NaN,Infinity,'900719925474099.99']) assert.throws(()=>amountToCents(input),TypeError,String(input));\n});\ntest('independent currencies are sorted and summed without floating point loss',()=>{\n assert.deepEqual(summarize([{currency:'usd',amount:'0.10'},{currency:' CNY ',amount:3},{currency:'USD',amount:'0.20'}]),[\n {currency:'CNY',cents:300,count:1},{currency:'USD',cents:30,count:2}]);\n});\ntest('refunds cancel totals while counting every original record',()=>{\n assert.deepEqual(summarize([{currency:'eur',amount:'1.20'},{currency:'EUR',amount:'-1.20'}]),[{currency:'EUR',cents:0,count:2}]);\n});\ntest('summarizing retains caller rows and handles an empty list',()=>{\n const rows=Object.freeze([Object.freeze({currency:'usd',amount:'2.00'})]);\n assert.deepEqual(summarize(rows),[{currency:'USD',cents:200,count:1}]);assert.deepEqual(summarize([]),[]);\n});\ntest('invalid rows currency and unsafe aggregate totals are rejected',()=>{\n for(const rows of [null,{},[null],[{currency:'US',amount:'1'}],[{currency:'U1D',amount:'1'}],[{currency:'USD',amount:'1.234'}],\n [{currency:'USD',amount:'90071992547409.91'},{currency:'USD',amount:'0.01'}]]) assert.throws(()=>summarize(rows),TypeError);\n});\ntest('reports use two decimals and render negative subunit amounts',()=>{\n assert.equal(formatReport([{currency:'CNY',cents:300,count:2},{currency:'USD',cents:-105,count:1}]),'CNY 3.00 (2)\\nUSD -1.05 (1)');\n assert.equal(formatReport([{currency:'EUR',cents:-5,count:1}]),'EUR -0.05 (1)');assert.equal(formatReport([]),'');\n});\ntest('complete expense flow preserves exact decimal sums',()=>{\n assert.equal(formatReport(summarize([{currency:'usd',amount:'0.29'},{currency:'USD',amount:'-0.30'},{currency:'CNY',amount:'10.50'}])),\n 'CNY 10.50 (1)\\nUSD -0.01 (2)');\n});\n", + "sha256": "0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839" + } + ] +} diff --git a/tests/task-context.test.mjs b/tests/task-context.test.mjs index bb7eec2f..9a5e582b 100644 --- a/tests/task-context.test.mjs +++ b/tests/task-context.test.mjs @@ -51,8 +51,12 @@ test('a real two-reply failure replay reaches request three at 16K with complete try { return JSON.parse(m.content.split('\n').at(-1)); } catch { return {}; } }).find(value => value.latest_tools); assert.ok(latest); assert.equal(latest.data.entries.length, 6); + const working=third.messages.filter(m=>m.role==='system').map(m=>{try{return JSON.parse(m.content.split('\n').at(-1));}catch{return{};}}).find(value=>value.working_set); for (const file of sources) { - assert.equal(latest.data.entries.find(entry => entry.result.path === file).result.content_excerpt, before[file]); + const direct=third.messages.filter(m=>m.role==='tool').map(m=>JSON.parse(m.content)).find(result=>result.path===file&&typeof result.content==='string'); + const sent=working?.data.entries.find(entry=>entry.observation.path===file)?.content + ??direct?.content??latest.data.entries.find(entry => entry.result.path === file)?.result.content_excerpt; + assert.equal(sent,before[file],'The actual bounded request must retain every original source byte, regardless of versioned view.'); assert.equal(fs.readFileSync(path.join(f.projectRoot, file), 'utf8'), before[file]); } for (const step of JSON.parse(input.replies[1].tool_calls.at(-1).function.arguments).steps) { diff --git a/tests/working-set.test.mjs b/tests/working-set.test.mjs index 3dc7a200..45994a05 100644 --- a/tests/working-set.test.mjs +++ b/tests/working-set.test.mjs @@ -4,7 +4,7 @@ import fs from 'node:fs'; import path from 'node:path'; import { createHash, randomUUID } from 'node:crypto'; import { RequestPlanner, historyGroups, verifyPlanEvidence } from '../src/core/context/request-plan.mjs'; -import { workingCandidates, workingMessage } from '../src/core/context/working-set.mjs'; +import { workingCandidates, workingMessage, workingDocument, workingEntry, verifyWorkingDocument } from '../src/core/context/working-set.mjs'; import { filePage } from '../src/core/context/read-budget.mjs'; import { requestMetrics } from '../src/shared/contracts/model-request.mjs'; import { Runtime } from '../src/server/runtime.mjs'; @@ -46,6 +46,61 @@ const read = (file, content) => ({ tool: 'read_file', args: { path: file }, result: { path: file, content, sha256: sha(content), start_line: 1, end_line: 2, total_lines: 2, truncated: false } }); const huge = () => ({ tool: 'query_code', args: { query: 'source' }, result: { results: 'Large mixed metadata '.repeat(16000) } }); +const fragment = (text, offset, end, extra = {}) => ({ tool: 'read_file', args: { path: 'test/requirements.mjs', offset }, + result: { path: 'test/requirements.mjs', sha256: sha(text), content: text.slice(offset, end), start_line: 1, end_line: 1, + range_start_line: 1, range_end_line: 1, offset, next_offset: end, total_characters: text.length, ...extra } }); + +test('all actually returned same-version fragments reach the bounded request, including overlap and Unicode, with independent original provenance', t => { + const f = setup(t, { contextLimit: 16000, maxOutputTokens: 2048 }), text = '头🙂"\\' + 'requirement;'.repeat(240) + '尾'; + for (const [a, b] of [[0, 473], [473, 2089], [0, 472], [2089, 2557], [2557, text.length]]) group(f, [fragment(text, a, b), huge()]); + const original = structuredClone(f.session.providerMessages), sent = f.prepare(), set = setFrom(sent.messages); + const entry = set.entries.find(entry => entry.observation.path === 'test/requirements.mjs'); + assert.equal(entry.content, text); assert.equal(entry.truncated, false); assert.equal(entry.fragments.count, 5); + assert.deepEqual(entry.sent_range, [0, text.length]); assertToolPairs(sent.messages); + assert.deepEqual(f.session.providerMessages, original); verifyPlanEvidence(f.store, f.session, sent.record); + const doc = JSON.parse(f.store.artifactStore.read(f.store.owned('artifact', sent.record.workingSetArtifactId, f.session.id))); + const altered = structuredClone(doc); altered.entries.find(e => e.fragments).fragments.pop(); + assert.throws(() => verifyWorkingDocument(f.store, f.session, sent.record, altered, historyGroups(f.session.providerMessages)), /工作依据|片段/); + f.session.changes.push({ path: 'test/requirements.mjs', status: 'applied', appliedAt: '2099-01-01', sha256: sha('replacement') }); + assert.equal(workingCandidates(f.store, f.session, f.run, historyGroups(f.session.providerMessages), 3).filter(e => e.observation.kind === 'file').length, 0); + verifyPlanEvidence(f.store, f.session, sent.record); // Current changes cannot rewrite a historical wire request. +}); + +test('unread gaps and different range origins remain separate; partial sending names the precise missing already-observed range', t => { + const f = setup(t), text = '0123456789🙂'; + group(f, [fragment(text, 0, 4), fragment(text, 6, 10), fragment(text, 0, 4, { range_start_line: 2, range_end_line: 2, start_line: 2, end_line: 2 })]); + const candidates = workingCandidates(f.store, f.session, f.run, historyGroups(f.session.providerMessages), 3); + assert.equal(candidates.length, 3); assert.ok(candidates.every(c => !c.observation.content.includes('45'))); + const entry = workingEntry(candidates.find(c => c.observation.offset === 6), 2); + const message = workingMessage({ id: 'original', sha256: sha('original') }, workingDocument(f.session, f.run, [entry], 3), 4); + const view = JSON.parse(message.content.split('\n').at(-1)).data.entries[0]; + assert.deepEqual(view.sent_range, [6, 8]); assert.deepEqual(view.unsent_observed_range, [8, 10]); + assert.ok(view.source.result_artifact_id); +}); + +test('same-SHA conflicting overlaps and invalid coordinates fail closed, while a new SHA never inherits old fragments', t => { + const f = setup(t), text = '0123456789'; + group(f, [fragment(text, 0, 6), fragment(text, 4, 10, { content: 'XX6789' })]); + assert.throws(() => workingCandidates(f.store, f.session, f.run, historyGroups(f.session.providerMessages), 3), /重叠内容冲突/); + group(f, [fragment('abcdefghij', 0, 4)]); + const fresh = workingCandidates(f.store, f.session, f.run, historyGroups(f.session.providerMessages), 3); + assert.equal(fresh.length, 1); assert.equal(fresh[0].observation.content, 'abcd'); + group(f, [fragment('abcdefghij', 4, 10, { next_offset: 11 })]); + assert.throws(() => workingCandidates(f.store, f.session, f.run, historyGroups(f.session.providerMessages), 3), /坐标/); +}); + +test('versioned old views keep the original single-page semantics and verification', t => { + const f = setup(t), text = '0123456789'; group(f, [fragment(text, 0, 4), fragment(text, 4, 10)]); + const groups = historyGroups(f.session.providerMessages); + for (const version of [1, 2]) { + const old = workingCandidates(f.store, f.session, f.run, groups, version); + assert.equal(old.length, 1); assert.equal(old[0].observation.content, '456789'); + const document = workingDocument(f.session, f.run, old.map(c => workingEntry(c, c.observation.content.length)), version); + verifyWorkingDocument(f.store, f.session, { taskId: f.run.taskId, workingSetEntries: 1 }, document, groups); + assert.doesNotThrow(() => workingMessage({ id: 'old', sha256: sha('old') }, document, version)); + } +}); + test('small code and actual failed command stay visible when their original multi-tool group cannot fit', t => { const f = setup(t), code = 'export const add = (a, b) => a + b;\n'; const calls = group(f, [read('src/add.mjs', code), huge(), { tool: 'run_command', args: { command: 'node check.mjs', reason: 'Fixture evidence.' },