test: seal live delivery T and reproduce working memory gaps

This commit is contained in:
Agent Workbench Dev
2026-11-04 07:21:32 +08:00
parent 28d21e75f4
commit 0644407b2c
219 changed files with 1654977 additions and 9 deletions
+6
View File
@@ -235,3 +235,9 @@ docs/reading-s-git-index.txt binary
docs/reading-s-release-identity.json -text
docs/live-delivery-t-contract/** -text -whitespace
docs/live-delivery-t-evidence/** -text -whitespace
docs/live-delivery-t-evidence/**/*.log binary
docs/live-delivery-t-evidence/**/*.txt binary
docs/live-delivery-t-offline.txt binary
docs/live-delivery-t-git-index.txt binary
+2
View File
@@ -45,3 +45,5 @@
!/docs/live-delivery-r-evidence/**/*.log
!/docs/reading-s-evidence/**/*.log
!/docs/live-delivery-t-evidence/**/*.log
+4 -2
View File
@@ -1,5 +1,7 @@
# Agent Workbench项目执行规范
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、不推送。
R已完成Q后的新有界真实样本:唯一所属诊断DNS/auto/IPv4/IPv6 TLS通过(1579ms,0HTTP/模型/凭据);新预检1请求/4492报告tokens/0工具/strict matched。新Node6请求/72571报告tokens/0未知、全JSON matched,12工具/1原检查审批,原9测试0通过9失败/基线build通过,0提案/修改/交付;第7次本地输入12352可容纳,但预留29623>剩余17429而token_limit暂停,非新context_limit/网络失败,不续跑。原61项目77导出/3610工件/209尝试和原行(项目位置自有前插2逆算)保持,当前63项目79会话6262记录13279事件及outbox/3660工件,新增7尝试全自有。预算/高性能池恢复,目标5→6→7/凭据1、全局/legacy65→69,9229关闭,正式仍1.24.6/source54dbe3d6/原PID36552/Provider。61自有工件记录全取回,178份/75944723字节证据离线通过,见docs/QA-LIVE-DELIVERY-R.md。下一优先docs/READING-RELIABILITY-S-PLAN.md:离线复现文件续读定位、约400字符分页吞吐及预留暂停解释;不移除预算保护或篡改上游27164输入报告。先修复/独立验收,再另立新Node;React/Python/Purge收益和1.25仍按前置计划。不委派、不提取/复制/重存Key、不重启原Provider、不推送。
@@ -66,7 +68,7 @@ D固定可信来源生产策略已完成:实现9106655/最终验收d05a741,6
## 范围与目标
当前接续优先级:R新预检通过,Node六次有原响应但在修改前token_limit暂停,真实交付仍未通过。下一先按docs/READING-RELIABILITY-S-PLAN.md修复文件续读定位/分页吞吐及预算暂停解释,离线复现和独立发行验收后再另立新有界Node。之后才React/Python与原版PurgeAB/BA;不续跑旧失败或扩大16K/原预算。N确认的GPT分组误配置不再归因于Claude线路故障。docs/PLAN-1.25.md及新iPhone/其它供应商方案保留;O/Q约678秒更新中的重复目录核验单独研究,保留完整性/防篡改与故障回退门槛。
当前接续优先级:T新预检通过,新Node八次有原响应但在修改前step_limit暂停,真实交付仍未通过。S读取与预算解释已交付,不重做。下一按docs/WORKING-MEMORY-U-PLAN.md用原T记录离线修复已读页候选丢失、当前源码和真实检查事实的持续保留;保留16K/2048/1600、原预算及历史发送视图。U产品独立验收和交付后才另冻新预检/Node,不续跑T/R/P/O,不提高预算或暗供实现。之后才React/Python与原版PurgeAB/BA。N确认的GPT分组误配置不再归因于Claude线路故障。docs/PLAN-1.25.md及新iPhone/其它供应商方案保留;S更新869425ms的重复目录核验单独研究,保留完整性/防篡改与故障回退门槛。
本仓库专注AI编程与能力研究工作台。其他项目不纳入本项目计划或代码。用户确定的研究对象为Codex、Claude Code、Cursor、DeepSeek Harness、WorkBuddy及DSH-purge;目标是将有证据的机制独立开发成自有Harness内置能力。
@@ -124,7 +126,7 @@ D固定可信来源生产策略已完成:实现9106655/最终验收d05a741,6
## 当前本地服务与Windows
- 正式服务入口http://127.0.0.1:4318,当前1.24.7,沿用原PID36552与Provider;不可变程序身份以docs/reading-s-release-identity.json为准,S正式保留状态与网页/原生回看见docs/QA-READING-RELIABILITY-S.md,最近真实模型仍是R未交付原样本。S核对原全表/导出/工件/模型中心精确保持,普通源码/规划/Git工作不重启服务、不读取或复制Key。下一按docs/LIVE-DELIVERY-T-PLAN.md另冻结新样本,旧F的Escape失败保持历史含义。
- 正式服务入口http://127.0.0.1:4318,当前1.24.7,沿用原PID36552与Provider;不可变程序身份以docs/reading-s-release-identity.json为准,S正式保留状态与网页/原生回看见docs/QA-READING-RELIABILITY-S.md。最近T新Node未交付,原8请求和原状态恢复见docs/QA-LIVE-DELIVERY-T.md;当前65项目81会话。普通源码/规划/Git工作不重启服务、不读取或复制Key。下一先docs/WORKING-MEMORY-U-PLAN.md离线修复,不重放T;旧F的Escape失败保持历史含义。
- 浏览器/fixture验证使用独立端口与数据目录;用户项目与研究对象的登录/会话配置不用于测试凭据。
- Windows执行环境以实测shell为准。现有工具使用PowerShell 5.1和UTF-8;不用&&/||拼接命令,使用换行和$LASTEXITCODE核对结果。
- 桌面与移动共用执行宿主。手机127.0.0.1指手机,远程接入通过未来经验证的配对网关。
+6
View File
@@ -1,5 +1,11 @@
# Agent Workbench 更新记录
## T 实测记录 · 正式仍为1.24.7
- 新连接诊断和单次真实模型预检通过;新Node在原八请求预算内未完成修改与交付,原测试失败、停止原因和全部用量保留。
- 离线复核定位已读文件片段未持续带入后续请求、当前检查结果未持续保留;具体修复作为下一U切片,尚未实现。
- 原项目/会话/工件及预算/高性能池按声明核对恢复,证据已封存。没有产品源码变更、重复发行或Purge收益结论;详见docs/QA-LIVE-DELIVERY-T.md。
## 1.24.7 · 文件续读与预算解释(已本地交付)
- 文件续读入口携带原行范围、偏移和可选 SHA-256 核对;读取版本变化会拒绝拼接,已返回页工件与未读原文件后文有明确区别。
+4
View File
@@ -1,5 +1,9 @@
# 后续执行计划
T新实测已结束:预检通过,新Node8请求/76062报告tokens/0未知,原九测试全失败/build通过,0提案/修改/交付,step_limit。已读2584字符但后续实际请求未持续携带,原16tool行离线重现最长/最新候选丢页和当前检查事实缺失。203份证据离线通过,正式仍1.24.7/原PID36552/Provider,原63项目79导出3660工件216尝试及声明原行/配置恢复保持,当前65项目81会话。见[T验收](QA-LIVE-DELIVERY-T.md)及[回顾](RETROSPECTIVE-LIVE-DELIVERY-T.md)。
下一优先[U工作记忆修复](WORKING-MEMORY-U-PLAN.md):开发/离线验收真实模型预算0,先复现同SHA片段丢失和当前检查未携带,修复聚合/容量优先级/真实事实视图与历史版本,再独立验收发行;之后另冻新预检/Node。T/R/P/O不续跑,不扩大16K/原预算或提供实现答案。Node后才React/Python和独立原版PurgeAB/BA。1.25和更新869425ms重复核验性能仍单列。下方S及更早“下一/当前”均按历史时点理解。
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、不推送。
S已完成原计划。下一优先[T新真实样本](LIVE-DELIVERY-T-PLAN.md),先单次预检、同预算新Node,再依前置条件扩React/Python及原版PurgeAB/BA。下方R及更早段落按其历史时点理解。
+57
View File
@@ -0,0 +1,57 @@
# T:S 交付后的真实 Node 验收
2026-11-04,按调用前提交 28d21e75 冻结的契约完成一个新样本。连接诊断和单次身份预检通过;Node 在第八次请求后 step_limit 暂停,没有源码提案、修改或 Git 交付。原九测试仍全部失败、基线 build 通过。正式仍为 1.24.7/source5dcd6d7c,未重新打包或修改产品。
## 固定条件和结果
| 阶段 | 原限制 | 实际结果 |
| --- | --- | --- |
| 所属 DNS/TCP/TLS | 1 个 job、12 秒、0 HTTP/模型/凭据访问 | 462ms,DNS/auto/IPv4/IPv6 TLS 均通过,证书校验开启 |
| 新身份预检 | 1 请求/尝试、0 工具、256 输出、16000 tokens | 1 请求/112 报告 tokens,nonce 正确,原 JSON 报告型号严格匹配 |
| 新 Node 工程 | 8 请求/90000 tokens/600000ms,16K/2048/1600,原三源码/九测试 | 8 请求/76062 报告 tokens/0 未知,16 工具/1 次原检查审批;0 提案/修改/交付,step_limit |
固定已启用 jojocode/5b4daed9,gpt-6.1-sol、Chat 非流式 JSON、https://jojocode.com/v1。预检使用公开连接修订7/凭据1,工程临时严格身份策略为修订8,结束恢复原 record/[]/空串语义到修订9,凭据修订仍1。每次 ordinal=1、poolId=null,原响应均完整 matched;这只核对请求/报告标识,不认证底层权重。没有重试、切池、别名补造、补预算或续跑旧任务。
诊断 job:486ed76c-9dca-4016-9b58-7ea4962c2c2b。预检 session:fef9c86c-86c5-4e66-a27a-4b29067c0426。Node session:5a1b39be-8096-46e6-bc43-156ca308f6f9,Task:94a78e50-df05-4176-b033-32de563a347c,Run:714f56ac-55a2-4cd3-acbe-df2cf09f5329。全部新增均为隔离自有工程,原 R/P/O 失败未续跑。
## 已读内容与实际请求
测试文件2584字符实际返回 0→473→2089、重读0→472、2089→2557→2584。第六轮已读完;单次纯文件页为1616字符,原SHA和续读位置被模型实际采用。读取范围账本是读取事实,不能据此声称每次后续请求都含有全文。
逐原请求解析 paired 文件结果、working_set 文件内容和 latest 文件摘录,得到:
| 实际请求 | 测试字符进入结构化文件视图 | 原检查 job ID 是否仍在整个原请求中 | 模型下一操作 |
| --- | ---: | --- | --- |
| 4 | 400 | 是 | 续读测试文件 |
| 5 | 1616 | 是 | 重读头部并续读尾部 |
| 6 | 1060 | 否 | 恢复两个工件、查任务计划、读取最后27字符 |
| 7 | 27 | 否 | 再次 inspect_project |
| 8 | 421 | 否 | 再次 plan_checks |
上述统计不把运行诊断中的 outputExcerpt、部分转义的工件包装当成完整源码;所有计入片段逐字符匹配原文件和原SHA。原八个请求没有一个在这些结构化文件视图中同时带齐测试全文。第六轮后原检查 UUID 在整个请求字节中也已消失,不能只归因于某种视图命名。
使用原16份所属 tool 原行、原 providerMessages、原工件,调用 source5dcd6d7c 的 workingCandidates 作零模型/零宿主写入的离线重放:同路径/版本只保留最长页和非包含的最新页。第六轮后可选测试页只有[473,2089]和[2557,2584],在分配预算前已排除[0,473]及[2089,2557]。原失败检查候选仍存在,却未进入原第7/8次实际请求。候选选择和实际容量分配是两个需要处理的环节。
这些证据定位到系统工作记忆的保留缺口;模型自身选择、上游模型行为对未交付的影响尚不能单独量化。S 的固定回放改善仍有效,T 不证明真实自主交付或 Purge 收益。不能用提高预算、删检查、提供实现答案或延长旧任务替代修复。
## 原状态和监督边界
监督只批准模型原计划的 npm run test/build。测试、配置、README、构建脚本、owner 文件、原暂存与工作副本、三源码均未改变。模型未准备变更集,完整审查应用和 Git 门禁本次没有触发。原九测试0通过9失败,build通过属于未修复源码的基线。
63个原公开项目、79份原会话导出、3660份原工件字节、216条原尝试及原会话/记录/事件/outbox逐行保持。两个自有项目前插使原 projects.position 顺移2,逆算后全原行SHA一致;不把这个声明过的排序变化写成原行字节未变。
新增2项目/2会话、115记录、205事件和outbox、9尝试、60个工件文件均归属本轮。当前65项目/81会话/6377记录/13484事件及outbox/3720工件。74份自有工件记录已通过原API逐SHA/bytes取回;记录可复用同一字节,所以工件记录数与新文件数分别核对。
原预算、高性能默认池和成员、其他连接及旧09b停用保持;目标7→8→9/凭据1,全局及legacy展示69→73,身份缺省新增字段为{}。原PID36552/Provider、runtimeRoot/runtimeIdentity保持,最后只读回查全原行和公开模型中心仍与恢复结果相同,9229关闭。本轮没有提取、复制、解密或重存Key;没有推送远端。
## 验收器失败和封存
首诊断驱动在已完成后的原历史比较失败:API视图有 stale/currentConnectionRevision,原metadata没有这两个派生字段。补验首版又把包含预期诊断更新的整份persistent摘要直接判等。原驱动、原错误、补验首版脚本与错误摘要保留;独立只读核对分别验证原行(仅允许所属诊断行追加)、工件、公开文件及原历史,最后通过,没有重跑诊断或改产品。Windows只读rg通配路径失败另记于progress。
[证据清单](live-delivery-t-evidence/manifest.json)共203份文件/77773746字节,SHA-256:840623121cb5579564f0bbd4f0ef5ae924fd7432d5b7d0e32cef9f28cd436bb3。包含调用前11份冻结驱动、原请求/响应/用量、全部所属工件、原失败与恢复、原行归属、9份绑定正式source的分析输入及离线重放;驱动按不可执行文本保存。
[离线核验器](../scripts/verify-live-delivery-t.mjs)已通过,见[收据](live-delivery-t-offline.txt)。核对冻结Git原字节、全部清单文件、真实原报告、原目标/测试、工具配对、请求覆盖和候选重放、全部自有工件、原行/导出/配置恢复;运行不联网、不调用模型或接触凭据。提交前加 --index 核对Git索引原字节。
[Git索引核对](live-delivery-t-git-index.txt)已通过:含清单204份/77814997字节逐SHA与原字节一致;日志忽略例外和原字节属性仅限T证据范围。本地保存冻结契约、最终证据和文档,没有推送远端。
T未改产品源码,因此没有重做S的构建、安装或UI检查,也不引用旧测试数充作本轮新增验证。下一按[U工作记忆修复计划](WORKING-MEMORY-U-PLAN.md)先离线修复与独立发行,再另冻结新的真实样本;React/Python、原版Purge AB/BA和1.25保持前置关系。[阶段回顾](RETROSPECTIVE-LIVE-DELIVERY-T.md)记录采用理由和下一门槛。
+15
View File
@@ -0,0 +1,15 @@
# T 回顾:读完以后,当前请求还剩什么
新诊断、无工具预检和有界Node已按原契约执行。身份及网络样本通过,原数据和配置恢复通过;Node未交付。八请求全部有原响应和报告用量,停止原因是步骤上限,没有网络错误、未知消费或新上下文超限。不能因此判定自主交付能力已经过关。
S解决了原范围续读和纯读取吞吐的一部分问题:这次模型实际使用原SHA/偏移续读,测试2584字符在第六轮读完。然而文件读取是跨请求发生的;当前选择器对一个文件只留最长页和最新页,页头和另一段尾页在进入预算分配前已经丢出候选。此时即使文件整体很小、读取账本完整,也无法把所有已读片段同时交给模型。
原第7/8请求的结构化文件视图只剩测试27/421字符,原失败检查job ID在第6–8请求字节中均消失。模型随后再次inspect_project/plan_checks。系统应优先保存可核验的当前工作依据和真实阶段状态;反复提示“不要重复”不能弥补内容不在请求中。原记录重放证明候选丢页和检查未携带这两件事,尚不能证明模型重复观察的唯一心理原因。
下一修复需要在同一SHA、可核对坐标和原工件来源内合并已读片段,明确哪些部分在当前请求中;当前检查/计划/文件状态需要有界且持续的事实视图。必须保留完整目标、所有约束、工具配对、16K/2048/1600和真实消费保护。不能拼接不同版本或假补未读内容,不能为了保留源码就丢失错误、审批和未知执行事实。
本轮验收器两次失误均在只读比较:API派生字段与存储原件不是同一表示;预期变更的metadata不能用全量相同来断言。应先声明表示和允许差异,再精确核对其余字段。首错误、脚本与原快照保留,没有重放诊断、模型或安装来取得好结果。
T沿用已交付的1.24.7,不因为一次实测而重打包或声称新版本。调用前契约28d21e75与最终证据分开保存,本轮合计9请求/76174报告tokens,0未知、0修改和交付。原版Purge未做对照,不能将新读取现象或单次身份通过写成收益。
后续按[U计划](WORKING-MEMORY-U-PLAN.md)先用本次原件建立隔离复现、修复工作记忆并独立验收。原T不续跑;只有新实现交付后,才另冻结预检/Node预算。Node过关再扩React/Python,Purge用独立AB/BA。更新重复核验性能和1.25其余能力继续单列。
+2
View File
@@ -1,5 +1,7 @@
# Agent Workbench 验收记录
T真实样本与离线复核完成,未交付:唯一诊断462ms/DNS/三TLS通过,新预检1请求/112报告tokens/0工具/strict matched。新Node8请求/76062报告tokens/0未知、16工具/1原检查审批,原九测试0通过9失败、build通过,0提案/修改/交付,step_limit。原测试2584字符第6轮已读完,但后续实际请求携带不全;原16tool行离线重放定位最长/最新候选在预算前丢页及原检查事实未携带。203份/77773746字节证据离线通过,[报告](QA-LIVE-DELIVERY-T.md)/[回顾](RETROSPECTIVE-LIVE-DELIVERY-T.md)/[U计划](WORKING-MEMORY-U-PLAN.md)已记录。原63项目79导出3660工件216尝试及原行按2自有项目前插声明保持,预算/高性能池恢复,目标7→8→9/凭据1、全局69→73、9229关闭;当前65项目81会话6377记录13484事件及outbox/3720工件,74自有工件原SHA核对通过。正式仍1.24.7/source5dcd6d7c/原PID36552/Provider,本轮没有产品改动、新发行、UI/安装重验或Purge收益结论;下一U先零真实模型离线修复,T不续跑。
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、不推送。
R真实实测与回顾已封存:唯一所属DNS/auto/IPv4/IPv6 TLS诊断通过,0HTTP/模型/凭据;新预检1请求/4492报告tokens/0工具/strict matched。新Node6请求/72571报告tokens/0未知、全JSON matched,12工具/1原检查审批,原九测试全部失败/基线build通过,0提案/修改/交付;第7次预留29623>剩余17429在发送前token_limit暂停,本地输入12352仍符合原上下文预算。原61项目77导出/3610工件/209尝试与原行(原项目位置按2个自有前插逆算)保持,预算/高性能池恢复,目标5→6→7/凭据1、全局65→69,9229关闭,当前63项目79会话6262记录13279事件及outbox/3660工件。178份/75944723字节证据及含清单179份/75980516字节Git索引核对通过;[本轮结果](QA-LIVE-DELIVERY-R.md)、[回顾](RETROSPECTIVE-LIVE-DELIVERY-R.md)与[下一S计划](READING-RELIABILITY-S-PLAN.md)已记录。正式仍1.24.6/source54dbe3d6/原PID36552/Provider,本轮没有产品改动、新发行或UI回看结论,React/Python/Purge未测。
+26
View File
@@ -0,0 +1,26 @@
# U:已读片段与当前执行事实的持续保留
这是T结束后的下一开发切片,尚未实现或交付。T的原字节和结果见[验收](QA-LIVE-DELIVERY-T.md)。正式保持1.24.7/原PID36552/Provider,U开发和离线验收阶段真实模型预算为0;不续跑T/R/P/O、不提取/复制/解密/重存Key、不推送。拟修复范围围绕当前Node交付阻塞,不扩展无关能力。
## 目标和实现范围
1. 用T原目标/三源码/九测试、原工具响应和原16K/2048/1600重现实际工作集。除完整工具历史,还核对“实际读取覆盖”“当前请求携带覆盖”和“已不在候选中的已读片段”;比较候选生成与预算选择,保存首失败。离线响应回放不称真实模型交付。
2. 重做同版本文件片段的候选表示。来源必须是Task所属原工具结果,绑定原路径、SHA、范围原点/偏移/内容SHA及每片段的调用/工件。只合并真实返回且重叠一致的片段,不读未授权源文件补缺口;保留空洞和明确的未读续读位置。同SHA却冲突、版本变化、不同范围原点、跨Task、未知结果均分别处理。分段合并不能改写历史原工件。
3. 在实际容量内保存完整小源码/需求文件与当前失败检查的事实。优先消除模型请求里的重复诊断摘录/重复定位开销;详细诊断和原错误仍完整可取,询问错误时仍能准确归属。当前已识别工程fingerprint、有效检查计划/job/数量/日志指针及已应用/待审状态不能仅依赖最近几条工具。数据派生自真实账本,不把“未plan_task”当作未开始、不补造步骤。
4. 全部发送视图和聚合来源有新版本及独立核验;S和更旧工件继续按原格式解释。容量不足时准确说明当前缺失片段并提供原来源恢复入口,不能只写“已读完”或把头/尾摘要当全文。保留完整目标/约束、工具配对、下一页预算、预留/报告用量、审批、停止、未知结果门禁与显式续接。
## 可验收标准
- T原记录确定性复现中,候选在第六轮后覆盖全部已返回2584字符,头部和[2089,2557]不得再被最长/最新二选规则丢弃。
- 在原16K容量和原工具集下,实际发送请求应能同时容纳原测试全文、三个小模块和有效原九测试失败/build通过的绑定事实;先测量可行性,再修复优先级与重复开销,不能扩大预算或精简用户目标来通过。
- 页重叠/空洞、Unicode、转义、不同SHA/范围、读取版本变化、跨Task/Run、未知/失效检查、源改变、混合工具、工件恢复与预算不足都有真实边界检查;原配对和历史视图核对仍通过。避免仅断言实现内部字段的镜像测试。
- 实际请求工件和验证器要证明这些内容确实被发送;仅候选包含、保留额度或UI显示不能替代原字节。原九测试在回放中仍可失败,禁止通过监督实现源码制造交付成功。
- 有产品代码修改后才冻结新候选并做相关回归、独立源码重建、便携/安装与保留原状态升级。只在涉及用户流程时使用product-ui-ux并验证实际界面;不因纯后端修复重做无关UI。正式全原行/导出/工件/公开配置与PID/Provider按新基线核对,不放宽安装完整性和回退保护。
## 后续顺序
U独立交付后,另立单次身份预检和新Node工程契约,仍为原三源码/九测试、16K/2048/1600、最多8请求/90000tokens/600000ms。模型独立实现,监督只审查/批准原检查、完整变更集和Git;旧T失败封存不续跑。成功需要原九测试和build及当前源码证明、仅三个允许文件的已确认本地Git提交。
Node通过后再做React/Python;原版Purge AB/BA须单列同工程/模型/预算、固定版本/profile和原提示/工具输入,保留失败及全部已报告/未知消费,分别评价交付/请求/时间/成本。未做对照不能宣称收益。
1.25的任务要求和交付复核、其它能力,以及869425ms更新中的重复目录完整核验性能仍在独立计划中。性能先定位重复调用和安全缓存边界,保留字节/目录/指针、活动保护、故障回退和原Provider/PID。
@@ -0,0 +1,62 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { createHash } from 'node:crypto';
import { DatabaseSync } from 'node:sqlite';
import { snapshotPersistentData } from '../src/core/desktop/install-manager.mjs';
export const hash = bytes => createHash('sha256').update(bytes).digest('hex');
export const canonical = value => Array.isArray(value) ? value.map(canonical) : value && typeof value === 'object' ? Object.fromEntries(Object.keys(value).sort().map(key => [key, canonical(value[key])])) : value;
export const digest = value => hash(JSON.stringify(canonical(value)));
export function databaseSnapshot(dataRoot) {
const database = new DatabaseSync(path.join(dataRoot, 'workbench.sqlite'), { readOnly: true }); database.exec('BEGIN');
try {
assert.equal(database.prepare('PRAGMA quick_check').get().quick_check, 'ok');
const tables = {};
for (const { name, sql } of database.prepare("SELECT name,sql FROM sqlite_schema WHERE type='table' ORDER BY name").all()) {
assert.match(name, /^[a-z_]+$/);
const rows = database.prepare('SELECT * FROM "' + name + '" ORDER BY rowid').all().filter(row => !(name === 'metadata' && row.key === 'runtimeOwner'));
tables[name] = { count: rows.length, schemaSha256: hash(sql), sha256: digest(rows), rows: rows.map((row, index) => ({ id: row.id ?? row.key ?? row.seq ?? index, ...(row.kind ? { kind: row.kind } : {}), sha256: digest(row) })) };
}
const sessionIds = database.prepare('SELECT id FROM sessions ORDER BY id').all().map(row => row.id);
const owner = database.prepare("SELECT value FROM metadata WHERE key='runtimeOwner'").get();
return { tables, sessionIds, ownerSha256: owner ? digest(owner) : null, scope: 'Every original table schema and row field hashed, excluding only runtimeOwner lifecycle metadata. No row payload or credential is returned.' };
} finally { database.exec('ROLLBACK'); database.close(); }
}
export async function publicSnapshot(url, dataRoot) {
const healthResponse = await fetch(url + '/api/health', { headers: { Connection: 'close' }, signal: AbortSignal.timeout(20000) }); assert.equal(healthResponse.status, 200);
const health = await healthResponse.json(), bootResponse = await fetch(url + '/api/bootstrap', { headers: { Connection: 'close' }, signal: AbortSignal.timeout(20000) }); assert.equal(bootResponse.status, 200);
const bootstrap = await bootResponse.json(); const token = bootstrap.token;
const api = async route => { const response = await fetch(url + '/api' + route, { headers: { 'X-Workbench-Token': token, Connection: 'close' }, signal: AbortSignal.timeout(20000) }); assert.ok(response.ok, route + ': HTTP ' + response.status); return response.json(); };
const database = databaseSnapshot(dataRoot), exports = [];
for (const id of database.sessionIds) {
const report = await api('/sessions/' + id + '/export');
exports.push({ id, project: digest(report.project), session: digest(report.session), execution: digest(report.execution) });
}
const center = await api('/model-center');
// This is the documented public model-center view; Provider's private map and
// API key are never accessed. Only this public object is retained for schema-aware comparison.
const modelCenter = structuredClone(center);
return { observedAt: new Date().toISOString(), version: health.version, pid: health.pid, runtimeRoot: bootstrap.runtimeRoot,
configSha256: digest(bootstrap.config), projectsSha256: digest(bootstrap.projects), sessionsSha256: digest(bootstrap.sessions), modelCenterSha256: digest(modelCenter), modelCenter,
projects: bootstrap.projects.length, visibleSessions: bootstrap.sessions.length, hasKey: !!bootstrap.config.hasKey,
active: bootstrap.sessions.filter(value => ['running', 'awaiting_approval', 'stopping'].includes(value.status)).map(value => ({ id: value.id, status: value.status })),
storage: bootstrap.storage, eventCursor: bootstrap.eventCursor, database, exports, persistent: snapshotPersistentData(dataRoot),
scope: 'Read-only public state, every original session export digest, original table/row/schema hashes and every original artifact byte hash. No credential extraction, model probe, execution or mutation.' };
}
export function compareOriginalState(before, after, { modelCenterSchemaChange = false } = {}) {
for (const field of ['pid', 'hasKey', 'configSha256', 'projectsSha256', 'sessionsSha256', 'eventCursor']) assert.deepEqual(after[field], before[field], field);
assert.deepEqual(canonical(after.database.tables), canonical(before.database.tables), 'All original table schemas and every persistent row');
assert.deepEqual(after.database.sessionIds, before.database.sessionIds); assert.deepEqual(after.exports, before.exports);
assert.deepEqual(after.persistent, before.persistent, 'Every original artifact byte, persistent row and public disk config');
if (modelCenterSchemaChange) {
const original = structuredClone(before.modelCenter), next = structuredClone(after.modelCenter);
// 1.15 changes only the public explanatory text about optional DPAPI storage.
// Existing IDs, routes, revisions, credentials-present bits and all original attempts remain exact.
assert.match(next.storage.restart, /临时凭据.*已明确本机加密保存/);
next.storage.restart = original.storage.restart;
assert.deepEqual(next, original, 'Original public model center, except versioned storage explanation');
return { modelCenterChange: { path: '/storage/restart', original: before.modelCenter.storage.restart, actual: after.modelCenter.storage.restart }, originalRows: 'exact', originalExports: 'exact', originalArtifactBytes: 'exact' };
}
assert.equal(after.modelCenterSha256, before.modelCenterSha256);
return { originalRows: 'exact', originalExports: 'exact', originalArtifactBytes: 'exact', originalModelCenter: 'exact' };
}
@@ -0,0 +1,42 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { createHash } from 'node:crypto';
import { execFileSync } from 'node:child_process';
const target = path.resolve('docs/live-delivery-t-contract'); assert.equal(fs.existsSync(target), false);
const sha = bytes => createHash('sha256').update(bytes).digest('hex');
const sourceFiles = ['prepare-live-delivery-t.mjs', 'freeze-live-delivery-t.mjs', 'live-delivery-t-initial.mjs', 'live-delivery-t-common.mjs',
'live-delivery-t-payload.mjs', 'live-delivery-t-inspector.mjs', 'live-delivery-t-preflight.mjs', 'live-delivery-t-preflight-audit.mjs',
'live-delivery-t-node.mjs', 'live-delivery-t-network.mjs', 'desktop-f-state.mjs'];
const initialBytes = fs.readFileSync('.qa/live-delivery-t/current.json'), initial = JSON.parse(initialBytes);
const release = JSON.parse(fs.readFileSync('docs/reading-s-release-identity.json'));
assert.equal(initial.host.identity.runtimeRoot.endsWith('Agent-Workbench-1.24.7-win-x64-20261103164618190'), true);
assert.equal(initial.host.identity.runtimeIdentity, '212aba55ceb5eb08bb7985dd346bfb3967f5c7a36b2bc848b7e149adb50edf85');
const files = [];
for (const name of sourceFiles) {
const bytes = fs.readFileSync(path.join('.qa', name)), relative = 'drivers/' + name + '.txt';
fs.mkdirSync(path.join(target, 'drivers'), { recursive: true });
fs.writeFileSync(path.join(target, relative), bytes, { flag: 'wx' }); files.push({ path: relative, bytes: bytes.length, sha256: sha(bytes) });
}
const manifest = { schemaVersion: 1, kind: 'bounded-live-delivery-t-contract', frozenAt: new Date().toISOString(),
sourceBaseCommit: initial.sourceCommit, branch: execFileSync('git', ['branch', '--show-current'], { encoding: 'utf8', windowsHide: true }).trim(),
planSha256: sha(fs.readFileSync('docs/LIVE-DELIVERY-T-PLAN.md')), originalBaselineSha256: sha(initialBytes),
releaseVersion: release.version, releaseSourceCommit: release.sourceCommit,
releaseIdentitySha256: sha(fs.readFileSync('docs/reading-s-release-identity.json')),
host: { pid: initial.host.identity.pid, runtimeRoot: initial.host.identity.runtimeRoot, runtimeIdentity: initial.host.identity.runtimeIdentity },
originalProjects: initial.baseline.projects, originalSessions: initial.baseline.exports.length,
originalArtifacts: initial.baseline.persistent.artifacts.length,
originalAttemptsRow: initial.baseline.database.tables.metadata.rows.find(row => row.id === 'modelAttempts'),
originalDiagnosticsRow: initial.baseline.database.tables.metadata.rows.find(row => row.id === 'modelNetworkDiagnostics'),
dependencySources: ['src/core/git-process.mjs', 'src/core/desktop/install-manager.mjs', 'benchmarks/live-delivery-v1/node/src/amount.mjs',
'benchmarks/live-delivery-v1/node/src/summary.mjs', 'benchmarks/live-delivery-v1/node/src/report.mjs', 'benchmarks/live-delivery-v1/node/test/expense.test.mjs',
'benchmarks/live-delivery-v1/node/package.json', 'benchmarks/live-delivery-v1/node/scripts/build.mjs']
.map(name => ({ path: name, sha256: sha(fs.readFileSync(name)) })),
previousDriverHashes: ['initial', 'common', 'payload', 'inspector', 'preflight', 'preflight-audit', 'node', 'network']
.map(name => ({ path: '.qa/live-delivery-r-' + name + '.mjs', sha256: sha(fs.readFileSync('.qa/live-delivery-r-' + name + '.mjs')) })),
maxNetworkJobs: 1, maxPreflightRequests: 1, maxNodeRequests: 8, maxNodeTokens: 90000, maxNodeDurationMs: 600000,
contextLimit: 16000, maxOutputTokens: 2048, safetyReserveTokens: 1600,
modelRequestsAtFreeze: 0, noKeyValuesReadOrSaved: true, files: files.sort((a, b) => a.path.localeCompare(b.path)) };
fs.writeFileSync(path.join(target, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n', { flag: 'wx' });
console.log(JSON.stringify({ frozen: true, drivers: files.length, projects: manifest.originalProjects, sessions: manifest.originalSessions,
artifacts: manifest.originalArtifacts, manifestSha256: sha(fs.readFileSync(path.join(target, 'manifest.json'))), modelRequests: 0 }));
@@ -0,0 +1,53 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { createHash } from 'node:crypto';
import { DatabaseSync } from 'node:sqlite';
import { Agent, fetch } from 'undici';
export const root = path.resolve('.qa/live-delivery-t');
export const original = JSON.parse(fs.readFileSync(path.join(root, 'current.json')));
export const origin = 'http://127.0.0.1:4318';
export const dataRoot = original.host.identity.dataRoot;
export const connectionId = '5b4daed9-b2f7-4de0-b949-573eba70c7b3';
export const sha = value => createHash('sha256').update(value).digest('hex');
export const save = (relative, value) => {
const file = path.join(root, relative); fs.mkdirSync(path.dirname(file), { recursive: true });
fs.writeFileSync(file, typeof value === 'string' || Buffer.isBuffer(value) ? value : JSON.stringify(value, null, 2) + '\n', { flag: 'wx' });
};
export function meta(name) {
assert.ok(['config', 'modelRegistry', 'modelAttempts', 'modelNetworkDiagnostics'].includes(name));
const db = new DatabaseSync(path.join(dataRoot, 'workbench.sqlite'), { readOnly: true });
try { return JSON.parse(db.prepare('SELECT value FROM metadata WHERE key=?').get(name).value); }
finally { db.close(); }
}
export async function client() {
const dispatcher = new Agent({ connect: { autoSelectFamily: true, timeout: 5000 } });
let token;
const api = async (route, input, timeout = 30000) => {
const response = await fetch(origin + '/api' + route, { dispatcher,
method: input === undefined ? 'GET' : 'POST', redirect: 'error', signal: AbortSignal.timeout(timeout),
headers: { ...(token ? { 'X-Workbench-Token': token } : {}), 'Content-Type': 'application/json', Connection: 'close' },
...(input === undefined ? {} : { body: JSON.stringify(input) }) });
const value = await response.json();
if (!response.ok) throw Object.assign(new Error(route + ': ' + (value.error ?? response.status)), { status: response.status });
return value;
};
const boot = await api('/bootstrap'); token = boot.token;
return { api, boot, close: () => dispatcher.close() };
}
export async function captureAttempts(api, attempts, relative) {
const captures = [];
for (const attempt of attempts) for (const kind of ['request', 'response']) {
const id = attempt[kind + 'ArtifactId']; if (!id) continue;
let content = '', offset = 0, page;
do {
page = await api('/artifacts/' + id + '?session=' + attempt.sessionId + '&offset=' + offset + '&limit=16000');
assert.ok(page.content.length || !page.truncated); content += page.content; offset += page.content.length;
} while (page.truncated);
assert.equal(sha(content), page.sha256);
assert.equal(page.sha256, attempt[kind + 'Sha256']);
const name = `${relative}/${attempt.id}-${kind}.${kind === 'request' ? 'json' : attempt.streaming ? 'sse' : 'txt'}`;
save(name, content); captures.push({ attemptId: attempt.id, kind, artifactId: id, path: name, sha256: sha(content), bytes: Buffer.byteLength(content) });
}
return captures;
}
@@ -0,0 +1,21 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { execFileSync } from 'node:child_process';
import { publicSnapshot } from './desktop-f-state.mjs';
const root = path.resolve('.qa/live-delivery-t'); assert.equal(fs.existsSync(root), false);
const origin = 'http://127.0.0.1:4318', boot = await (await fetch(origin + '/api/bootstrap', { headers: { Connection: 'close' } })).json();
const api = async route => (await fetch(origin + '/api' + route, { headers: { 'X-Workbench-Token': boot.token, Connection: 'close' } })).json();
const host = await api('/host/status'), center = await api('/model-center'), connection = center.connections.find(c => c.id === '5b4daed9-b2f7-4de0-b949-573eba70c7b3');
assert.equal(boot.version, '1.24.7'); assert.equal(host.identity.pid, 36552); assert.equal(host.activity.active, false);
assert.equal(connection.enabled, true); assert.equal(connection.hasKey, true); assert.equal(connection.credentialRevision, 1); assert.equal(connection.revision, 7);
assert.equal(connection.model, 'gpt-6.1-sol'); assert.equal(connection.protocol, 'chat-completions'); assert.equal(connection.streaming, false);
assert.equal(connection.contextLimit, 16000); assert.equal(connection.maxOutputTokens, 2048);
assert.equal(center.connections.find(c => c.id === '09b0293b-faad-45c3-832d-7c8b615813aa').enabled, false);
const baseline = await publicSnapshot(origin, host.identity.dataRoot); assert.deepEqual(baseline.active, []);
assert.deepEqual(center.selected, { type: 'pool', id: '68e30376-b799-445b-a858-db2dba9920a0' });
fs.mkdirSync(root);
fs.writeFileSync(path.join(root, 'current.json'), JSON.stringify({ host, config: boot.config, projects: boot.projects, center, baseline,
sourceCommit: execFileSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf8' }).trim(), observedAt: new Date().toISOString() }, null, 2), { flag: 'wx' });
console.log(JSON.stringify({ success: true, version: boot.version, pid: host.identity.pid, projects: baseline.projects, sessions: baseline.exports.length,
connectionId: connection.id, contextLimit: connection.contextLimit, modelRequests: 0 }));
@@ -0,0 +1,58 @@
import assert from 'node:assert/strict';
import net from 'node:net';
import { setTimeout as delay } from 'node:timers/promises';
import { boundedGptPreflight } from './live-delivery-t-payload.mjs';
export async function inspectorClosed() {
return new Promise((resolve, reject) => {
const socket = net.createConnection({ host: '127.0.0.1', port: 9229 }); socket.setTimeout(1500);
socket.once('connect', () => { socket.destroy(); reject(Error('Inspector already open.')); });
socket.once('error', e => { socket.destroy(); e.code === 'ECONNREFUSED' ? resolve(true) : reject(e); });
socket.once('timeout', () => { socket.destroy(); reject(Error('Inspector state unknown.')); });
});
}
class Protocol {
constructor(socket) {
this.socket = socket; this.nextId = 1; this.pending = new Map();
socket.addEventListener('message', event => {
const m = JSON.parse(String(event.data)); if (!m.id) return;
const p = this.pending.get(m.id); if (!p) return; this.pending.delete(m.id); clearTimeout(p.timer);
m.error ? p.reject(Error(m.error.message)) : p.resolve(m.result);
});
socket.addEventListener('close', () => { for (const p of this.pending.values()) { clearTimeout(p.timer); p.reject(Error('Inspector closed; outcome unknown.')); } this.pending.clear(); });
}
send(method, params, timeout = 10000) {
return new Promise((resolve, reject) => {
const id = this.nextId++, timer = setTimeout(() => { this.pending.delete(id); reject(Error('Inspector timeout; do not replay.')); }, timeout);
this.pending.set(id, { resolve, reject, timer }); this.socket.send(JSON.stringify({ id, method, params }));
});
}
}
export async function invokeGptProbe(input) {
await inspectorClosed(); let socket, protocol, enabled = false;
try {
process._debugProcess(input.pid); enabled = true;
let targets;
for (let i = 0; i < 40 && !targets; i++) {
await delay(100);
try { targets = await (await fetch('http://127.0.0.1:9229/json/list', { signal: AbortSignal.timeout(700) })).json(); } catch {}
}
assert.equal(targets?.length, 1);
assert.ok(targets[0].webSocketDebuggerUrl.startsWith('ws://127.0.0.1:9229/'));
socket = new WebSocket(targets[0].webSocketDebuggerUrl);
await new Promise((resolve, reject) => { socket.addEventListener('open', resolve, { once: true }); socket.addEventListener('error', reject, { once: true }); });
protocol = new Protocol(socket);
const identity = await protocol.send('Runtime.evaluate', { expression: 'process.pid', returnByValue: true });
assert.equal(identity.result.value, input.pid);
const expression = '(' + boundedGptPreflight.toString() + ')(' + JSON.stringify(input) + ')';
const result = await protocol.send('Runtime.evaluate', { expression, awaitPromise: true, returnByValue: true }, 345000);
if (result.exceptionDetails) throw Error(result.exceptionDetails.exception?.description ?? result.exceptionDetails.text);
return { result: result.result.value, expression };
} finally {
if (protocol && enabled) {
await protocol.send('Runtime.evaluate', { expression: "setTimeout(() => process.getBuiltinModule('inspector').close(), 25); 'closing'", returnByValue: true });
await delay(200);
}
socket?.close();
await inspectorClosed();
}
}
@@ -0,0 +1,64 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { setTimeout as delay } from 'node:timers/promises';
import { publicSnapshot, canonical } from './desktop-f-state.mjs';
import { root, origin, dataRoot, original, connectionId, save, meta, client } from './live-delivery-t-common.mjs';
assert.equal(fs.existsSync(path.join(root, 'network')), false, 'One diagnostic only; never overwrite or replay.');
const { api, boot, close } = await client();
let jobId;
try {
const host = await api('/host/status');
assert.equal(host.identity.pid, 36552); assert.equal(boot.version, '1.24.7'); assert.equal(host.activity.active, false);
const before = await publicSnapshot(origin, dataRoot); save('network/before.json', before);
assert.deepEqual(canonical(before.database.tables), canonical(original.baseline.database.tables));
assert.deepEqual(before.exports, original.baseline.exports); assert.deepEqual(before.persistent, original.baseline.persistent);
const history = await api('/model-center/network-diagnostics'); save('network/history-before.json', history);
assert.equal(history.active, 0); assert.equal(history.jobs.length, 1);
const connection = before.modelCenter.connections.find(row => row.id === connectionId);
assert.equal(connection.revision, 7); assert.equal(connection.credentialRevision, 1);
save('network/contract.json', { connectionId, revision: connection.revision, target: connection.baseUrl,
maxJobs: 1, budgetMs: 12000, credentialAccess: false, httpRequests: 0, modelRequests: 0,
directEndpointOnly: true, modelApiRouteVerified: false, defaultOrTransportChanges: false });
const started = await api('/model-center/network-diagnostics', { id: connectionId, revision: connection.revision });
save('network/start.json', started); jobId = started.job.id;
const deadline = Date.now() + 20000;
let current;
do {
current = await api('/model-center/network-diagnostics');
if (!current.active) break;
assert.ok(Date.now() < deadline, 'Diagnostic exceeded its bounded deadline.'); await delay(200);
} while (true);
const job = current.jobs.find(row => row.id === jobId);
assert.equal(current.jobs.length, history.jobs.length + 1); assert.equal(current.active, 0); assert.ok(job.finishedAt);
assert.equal(job.connectionId, connectionId); assert.equal(job.connectionRevision, 7);
assert.equal(job.httpRequests, 0); assert.equal(job.modelRequests, 0); assert.equal(job.credentialAccess, false);
assert.equal(job.route.kind, 'direct-endpoint-only'); assert.equal(job.route.modelApiRouteVerified, false);
save('network/history-after.json', current); save('network/job.json', job);
const after = await publicSnapshot(origin, dataRoot); save('network/after.json', after);
for (const field of ['pid', 'version', 'hasKey', 'configSha256', 'projectsSha256', 'sessionsSha256', 'eventCursor', 'modelCenterSha256']) assert.deepEqual(after[field], before[field], field);
assert.deepEqual(after.exports, before.exports); assert.deepEqual(after.persistent.artifacts, before.persistent.artifacts);
assert.deepEqual(after.persistent.files, before.persistent.files);
for (const table of Object.keys(before.database.tables)) {
assert.equal(after.database.tables[table].schemaSha256, before.database.tables[table].schemaSha256);
const nextRows = after.database.tables[table].rows.filter(row => table !== 'metadata' || row.id !== 'modelNetworkDiagnostics');
const previousRows = before.database.tables[table].rows.filter(row => table !== 'metadata' || row.id !== 'modelNetworkDiagnostics');
assert.deepEqual(nextRows, previousRows, table + ': only diagnostic history may change');
}
assert.equal(after.database.tables.metadata.count, before.database.tables.metadata.count);
assert.deepEqual(meta('modelNetworkDiagnostics').filter(row => row.id !== jobId), history.jobs);
assert.equal(meta('modelNetworkDiagnostics').filter(row => row.id === jobId).length, 1);
const result = { passed: true, jobId, diagnosticStatus: job.status, elapsedMs: job.elapsedMs,
dns: job.stages.dns, trials: job.trials.map(row => ({ mode: row.mode, family: row.family, status: row.status, code: row.code })),
route: job.route, originalStateExactExceptNewDiagnosticHistory: true, credentialAccess: false, httpRequests: 0, modelRequests: 0 };
save('network/restoration.json', result); console.log(JSON.stringify(result));
} catch (error) {
save('network/driver-error.json', { name: error.name, message: error.message, stack: error.stack, jobId, automaticReplay: false });
throw error;
} finally {
if (jobId) {
const state = await api('/model-center/network-diagnostics');
if (state.active && ['pending', 'running'].includes(state.jobs.find(row => row.id === jobId)?.status)) save('network/stop.json', await api('/model-center/network-diagnostics/' + jobId + '/stop', {}));
}
await close();
}
@@ -0,0 +1,236 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { execFileSync } from 'node:child_process';
import { setTimeout as delay } from 'node:timers/promises';
import { gitEnvironment } from '../src/core/git-process.mjs';
import { publicSnapshot, canonical } from './desktop-f-state.mjs';
import { root, origin, dataRoot, connectionId, save, meta, client, sha, captureAttempts } from './live-delivery-t-common.mjs';
assert.equal(JSON.parse(fs.readFileSync(path.join(root, 'preflight/result.json'))).passed, true);
assert.equal(fs.existsSync(path.join(root, 'node')), false, 'Never replay or overwrite a live sample.');
const { api, boot, close } = await client();
const allowed = ['src/amount.mjs', 'src/summary.mjs', 'src/report.mjs'];
const budgetFields = ['contextLimit', 'maxSteps', 'maxOutputTokens', 'maxRunTokens', 'maxTaskTokens', 'maxRunDurationMs'];
const connectionFields = ['id', 'name', 'brand', 'model', 'baseUrl', 'enabled', 'requiresKey', 'streaming', 'protocol',
'capabilityDeclarations', 'contextLimit', 'maxOutputTokens', 'concurrency', 'nativeParameters', 'outputTokenField',
'modelIdentityPolicy', 'modelIdentityAliases', 'modelIdentityAliasSource'];
const connectionInput = value => Object.fromEntries(connectionFields.filter(key => Object.hasOwn(value, key)).map(key => [key, value[key]]));
const originalIdentity = value => ({ modelIdentityPolicy: value.modelIdentityPolicy ?? 'record',
modelIdentityAliases: value.modelIdentityAliases ?? [], modelIdentityAliasSource: value.modelIdentityAliasSource ?? '' });
let before, centerBefore, publicMetadata, originalAttempts, connection, configured, project, session, state, taskId, route, budgetWritten = false, selectionWritten = false;
let result, delivery, succeeded = false, failure;
const approvals = [], applications = [], continuations = [], observations = [], start = Date.now();
const sourceRoot = path.join(root, 'node/expense-project');
const git = args => execFileSync('git', ['--no-pager', '--no-optional-locks', '-C', sourceRoot, ...args], { encoding: 'utf8', windowsHide: true, env: gitEnvironment() });
let protectedBytes, stagedBefore;
const protect = () => {
for (const [name, bytes] of Object.entries(protectedBytes)) assert.deepEqual(fs.readFileSync(path.join(sourceRoot, name)), bytes, name);
assert.equal(git(['show', ':owner-staged.txt']), stagedBefore, 'Preserve original index and working-copy states.');
};
const waitFor = async (predicate, timeout = 30000) => {
const deadline = Date.now() + timeout;
while (!await predicate()) { assert.ok(Date.now() < deadline, 'Local operation deadline exceeded; verify outcome, never replay.'); await delay(350); }
};
const review = async (kind, value) => {
const relative = `node/reviews/${kind}-${applications.length + 1}`;
const fingerprint = value.fingerprint ?? sha(JSON.stringify(value));
save(relative + '/input.json', { ...value, fingerprint });
console.log(JSON.stringify({ reviewRequired: true, kind, path: relative + '/input.json', fingerprint }));
const decisionPath = path.join(root, relative, 'decision.json');
await waitFor(async () => fs.existsSync(decisionPath), Math.max(1, 600000 - (Date.now() - start)));
const decision = JSON.parse(fs.readFileSync(decisionPath));
assert.equal(decision.approve, true, 'Supervisor declined the original model proposal.');
assert.ok(typeof decision.reason === 'string' && decision.reason.length > 20, 'Record substantive review.');
assert.equal(decision.fingerprint, fingerprint);
return decision;
};
const remainingRun = async () => {
const requests = state?.execution.task.usage.requests ?? 0;
assert.ok(requests < 8, 'The sealed eight-request budget is exhausted.');
const budgets = { contextLimit: 16000, maxOutputTokens: 2048, maxSteps: 8 - requests,
maxRunTokens: 90000, maxTaskTokens: 90000, maxRunDurationMs: 600000 };
await api('/model-center/runtime-budgets', budgets); budgetWritten = true;
continuations.push({ beforeRequests: requests, remainingSteps: budgets.maxSteps, at: new Date().toISOString() });
};
try {
assert.equal(boot.version, '1.24.7');
const host = await api('/host/status'); assert.equal(host.identity.pid, 36552); assert.equal(host.activity.active, false);
before = await publicSnapshot(origin, dataRoot); save('node/before.json', before);
centerBefore = await api('/model-center'); connection = centerBefore.connections.find(value => value.id === connectionId);
assert.equal(connection.enabled, true); assert.equal(connection.hasKey, true); assert.equal(connection.revision, 7);
assert.equal(connection.model, 'gpt-6.1-sol'); assert.equal(connection.protocol, 'chat-completions'); assert.equal(connection.contextLimit, 16000);
assert.deepEqual(originalIdentity(connection), { modelIdentityPolicy: 'record', modelIdentityAliases: [], modelIdentityAliasSource: '' });
publicMetadata = { config: meta('config'), registry: meta('modelRegistry') };
save('node/original-public-metadata.json', publicMetadata);
originalAttempts = meta('modelAttempts'); save('node/original-attempts.json', originalAttempts);
save('node/contract.json', { kind: 'new-real-Node-engineering', version: boot.version, connectionId, connection,
maxRequests: 8, maxTokens: 90000, contextLimit: 16000, maxOutputTokens: 2048, maxDurationMs: 600000,
allowed, checks: ['test', 'build'], expectedTests: 9, commands: 'Only model-planned npm test/build, no arbitrary run_command',
review: 'Model seals all three files, supervisor reviews and applies; model plans Git, supervisor confirms.',
continuation: 'Only review-action continuation of the same task with remaining steps, no extra implementation prompts.',
originalImplementationSupplied: false, automaticRetry: false, poolSwitching: false,
originalSelected: centerBefore.selected, originalBudgets: Object.fromEntries(budgetFields.map(key => [key, boot.config[key]])),
restore: 'Original budget values and selection restored. Original absent identity fields become explicit record/[]/empty-string defaults; raw pre-state retained and only this declared normalization accepted. Revision counters remain monotonic.' });
fs.cpSync('benchmarks/live-delivery-v1/node', sourceRoot, { recursive: true, errorOnExist: true });
fs.writeFileSync(path.join(sourceRoot, 'README.md'), '# Expense report acceptance\nRepair the three source modules using the immutable original nine tests; do not edit checks or owner files.\n', { flag: 'wx' });
fs.writeFileSync(path.join(sourceRoot, '.gitignore'), 'dist/\n.awb-*\nnode_modules/\n', { flag: 'wx' });
for (const name of ['owner-staged.txt', 'owner-unstaged.txt']) fs.writeFileSync(path.join(sourceRoot, name), 'Owner original baseline\n', { flag: 'wx' });
git(['init', '--initial-branch=main']); git(['config', 'core.autocrlf', 'false']);
git(['config', 'user.name', 'Workbench QA']); git(['config', 'user.email', 'qa@workbench.invalid']);
git(['add', '--', '.']); git(['commit', '--no-gpg-sign', '-m', 'Seal expense engineering baseline and original checks']);
fs.writeFileSync(path.join(sourceRoot, 'owner-staged.txt'), 'Owner staged change\n'); git(['add', '--', 'owner-staged.txt']);
stagedBefore = git(['show', ':owner-staged.txt']);
fs.writeFileSync(path.join(sourceRoot, 'owner-staged.txt'), 'Owner working copy differs from staging\n');
fs.writeFileSync(path.join(sourceRoot, 'owner-unstaged.txt'), 'Owner unstaged change\n');
fs.writeFileSync(path.join(sourceRoot, 'owner-untracked.txt'), 'Owner untracked change\n', { flag: 'wx' });
const protectedNames = ['README.md', '.gitignore', 'package.json', 'test/expense.test.mjs', 'scripts/build.mjs', 'owner-staged.txt', 'owner-unstaged.txt', 'owner-untracked.txt'];
protectedBytes = Object.fromEntries(protectedNames.map(name => [name, fs.readFileSync(path.join(sourceRoot, name))]));
const sourceFiles = [...protectedNames, ...allowed];
for (const name of sourceFiles) save('node/source-before/' + name, fs.readFileSync(path.join(sourceRoot, name)));
save('node/source-identity.json', { head: git(['rev-parse', 'HEAD']).trim(), status: git(['status', '--porcelain=v1']), stagedBefore,
files: Object.fromEntries(sourceFiles.map(name => [name, sha(fs.readFileSync(path.join(sourceRoot, name)))])) });
project = await api('/projects', { root: sourceRoot }); session = await api('/sessions', { projectId: project.id }); route = '/sessions/' + session.id;
save('node/owned.json', { project, session });
configured = await api('/model-center/connections', { ...connectionInput(connection), revision: connection.revision,
modelIdentityPolicy: 'require-match', modelIdentityAliases: [], modelIdentityAliasSource: '' });
assert.equal(configured.credentialRevision, connection.credentialRevision); assert.equal(configured.hasKey, true);
save('node/connection-frozen.json', configured);
await remainingRun(); await api('/model-center/select', { type: 'connection', id: connectionId }); selectionWritten = true;
const 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,请合并独立工具调用并避免重复观察。';
save('node/goal.txt', goal); protect();
await api(route + '/messages', { content: goal });
while (Date.now() - start < 600000) {
state = await api(route); taskId ??= state.execution.task.id; assert.equal(state.execution.task.id, taskId); protect();
const usage = state.execution.task.usage; assert.ok(usage.requests <= 8); assert.ok(usage.totalTokens <= 90000);
const progress = { status: state.status, requests: usage.requests, tokens: usage.totalTokens, lastTool: state.events.filter(event => event.kind === 'tool').at(-1)?.tool,
checks: state.execution.checks.map(job => job.status), elapsedSeconds: Math.round((Date.now() - start) / 1000) };
if (JSON.stringify({ ...progress, elapsedSeconds: 0 }) !== JSON.stringify({ ...observations.at(-1), elapsedSeconds: 0 })) { observations.push(progress); console.log(JSON.stringify(progress)); }
for (const change of state.changes.filter(change => ['pending', 'conflict'].includes(change.status))) assert.ok(allowed.includes(change.path), 'Out-of-scope proposal: ' + change.path);
for (const approval of state.approvals.filter(item => item.status === 'pending')) {
const plan = state.execution.plans.find(value => value.id === approval.checkPlanId);
const allow = !!plan && plan.taskId === taskId && plan.checks.length === 2 && plan.checks.every(check => ['test', 'build'].includes(check.name) && !check.lifecycle?.length)
&& approval.cwd === sourceRoot && approval.command === plan.checks.map(check => check.command).join('\n');
approvals.push({ approvalId: approval.id, planId: plan?.id, command: approval.command, allow });
await api(route + '/approvals/' + approval.id, { allow }); assert.equal(allow, true, 'Only the sealed original checks are authorized.');
}
if (['running', 'awaiting_approval', 'stopping'].includes(state.status)) { await delay(650); continue; }
if (state.status === 'failed') throw new Error(state.failure?.message ?? 'Actual-model task failed');
const plan = state.execution.deliveryPlans?.findLast(value => value.status === 'planned' && value.taskId === taskId);
if (plan) {
assert.deepEqual(plan.paths.slice().sort(), allowed.slice().sort()); const requests = usage.requests;
assert.ok(state.events.some(event => event.tool === 'plan_delivery' && event.phase === 'completed'));
const passing = state.execution.checks.filter(job => job.status === 'passed').at(-1);
assert.equal(passing?.results.find(value => value.name === 'test')?.tests?.passed, 9);
await review('git', { plan, fingerprint: plan.fingerprint, checks: state.execution.checks, source: state.changes,
status: git(['status', '--porcelain=v1']), stagedBefore, stagedAfter: git(['show', ':owner-staged.txt']) });
await api(route + '/delivery-jobs', { planId: plan.id });
await waitFor(async () => { state = await api(route); delivery = state.execution.deliveries.at(-1); return !!delivery?.reportArtifactId; });
assert.equal(delivery.status, 'completed'); assert.equal(state.execution.task.usage.requests, requests); break;
}
const pending = state.changes.filter(change => change.status === 'pending');
const batch = state.execution.changeSets?.findLast(value => value.taskId === taskId && value.status === 'prepared');
if (pending.length) {
assert.ok(state.execution.checks.some(job => job.status === 'failed' && job.results.some(value => value.tests?.failed > 0)), 'Model must preserve the original failing tests.');
assert.equal(batch?.source, 'agent', 'Model must seal its own complete change set.');
assert.deepEqual(batch.files.map(file => file.changeId).sort(), pending.map(change => change.id).sort());
if (!applications.length) assert.deepEqual(batch.files.map(file => file.path).sort(), allowed.slice().sort());
assert.ok(applications.length < 3);
await review('changes', { fingerprint: batch.fingerprint, batch, changes: pending, checks: state.execution.checks });
await api(route + '/change-sets/' + batch.id + '/apply', { fingerprint: batch.fingerprint });
await waitFor(async () => (await api(route + '/change-sets/' + batch.id)).status === 'completed');
for (const change of pending) assert.equal(sha(fs.readFileSync(path.join(sourceRoot, change.path))), change.sha256);
applications.push({ id: batch.id, fingerprint: batch.fingerprint, paths: batch.files.map(file => file.path), source: batch.source }); protect();
await remainingRun(); await api(route + '/continue-reviewed', {}); continue;
}
throw new Error('Model stopped before verified Git delivery: ' + state.status + '/' + state.execution.run.stopReason);
}
assert.ok(delivery, 'The sealed engineering deadline ended without complete delivery.');
const passing = state.execution.checks.filter(job => job.status === 'passed').at(-1); assert.ok(passing);
const tests = passing.results.find(value => value.name === 'test')?.tests; assert.equal(tests?.total, 9); assert.equal(tests.passed, 9); assert.equal(tests.failed, 0);
assert.deepEqual(git(['diff-tree', '--no-commit-id', '--name-only', '-r', 'HEAD']).trim().split(/\r?\n/).sort(), allowed.slice().sort()); protect();
succeeded = true;
result = { success: true, commit: delivery.commit, tests, delivery, checkJobId: passing.id };
} catch (error) {
failure = { name: error.name, message: error.message, stack: error.stack, at: new Date().toISOString(), automaticReplay: false };
result = { success: false, failure }; process.exitCode = 1;
} finally {
if (route) {
state = await api(route);
if (['running', 'stopping', 'awaiting_approval'].includes(state.status)) { await api(route + '/stop', {}); state = await api(route); }
taskId ??= state.execution.task?.id;
save('node/session.json', state); save('node/export.json', await api(route + '/export'));
const attempts = meta('modelAttempts').filter(value => value.sessionId === session.id); save('node/attempts.json', attempts);
const captures = await captureAttempts(api, attempts, 'node/captures');
const identitiesValid = attempts.every(value => value.connectionId === connectionId && value.poolId === null && value.ordinal === 1
&& value.status === 'completed' && value.modelIdentity?.status === 'matched' && value.modelIdentity.complete === true && value.modelIdentity.policy === 'require-match');
result = { ...result, version: boot.version, sessionId: session.id, projectId: project.id, taskId, sourceRoot,
connectionId, requestedModel: 'gpt-6.1-sol', usage: state.execution.task?.usage, state: state.status, stopReason: state.execution.run?.stopReason,
attempts: attempts.length, identitiesValid, captures, approvals, applications, continuations, observations,
modelImplementationSuppliedBySupervisor: false, modelWeightsAuthenticated: false, originalPurgeBenefitTested: false,
elapsedSeconds: Math.round((Date.now() - start) / 1000) };
if (succeeded) assert.equal(identitiesValid, true);
save('node/model-outcome.json', result);
for (const name of allowed) save('node/source-after/' + name, fs.readFileSync(path.join(sourceRoot, name)));
save('node/git-final.json', { head: git(['rev-parse', 'HEAD']).trim(), status: git(['status', '--porcelain=v1']), stagedBefore, stagedAfter: git(['show', ':owner-staged.txt']), diff: git(['diff', 'HEAD', '--', ...allowed]) });
}
const host = await api('/host/status'); assert.equal(host.activity.active, false, 'Do not overwrite another active task.');
if (configured) {
const center = await api('/model-center'), current = center.connections.find(value => value.id === connectionId);
assert.equal(current.revision, configured.revision, 'Do not overwrite an external connection edit.');
const restored = await api('/model-center/connections', { ...connectionInput(connection), ...originalIdentity(connection), revision: current.revision });
assert.equal(restored.credentialRevision, connection.credentialRevision); save('node/connection-restored.json', restored);
assert.deepEqual(originalIdentity(restored), originalIdentity(connection));
}
if (budgetWritten) await api('/model-center/runtime-budgets', Object.fromEntries(budgetFields.map(key => [key, boot.config[key]])));
if (selectionWritten) await api('/model-center/select', centerBefore.selected);
const after = await publicSnapshot(origin, dataRoot); save('node/after.json', after);
if (before) {
for (const item of before.exports) assert.deepEqual(after.exports.find(value => value.id === item.id), item, 'Original export: ' + item.id);
for (const table of ['sessions', 'records', 'events', 'outbox']) {
const rows = new Map(after.database.tables[table].rows.map(row => [row.id, row]));
for (const row of before.database.tables[table].rows) assert.deepEqual(rows.get(row.id), row, 'Original ' + table + '/' + row.id);
}
const artifactMap = new Map(after.persistent.artifacts.map(value => [value.path, value]));
for (const item of before.persistent.artifacts) assert.deepEqual(artifactMap.get(item.path), item, 'Original artifact: ' + item.path);
const finalBoot = await api('/bootstrap'), normalized = { ...finalBoot.config, configRevision: boot.config.configRevision };
assert.deepEqual(canonical(normalized), canonical(boot.config));
assert.deepEqual(finalBoot.projects.filter(value => value.id !== project?.id), boot.projects, 'Every original public project, excluding only the new owned sample.');
assert.deepEqual(after.modelCenter.selected, centerBefore.selected); assert.deepEqual(after.modelCenter.pools, centerBefore.pools);
for (const item of centerBefore.connections.filter(value => ![connectionId, 'legacy-default'].includes(value.id))) assert.deepEqual(after.modelCenter.connections.find(value => value.id === item.id), item);
const finalMetadata = { config: meta('config'), registry: meta('modelRegistry') };
save('node/final-public-metadata.json', finalMetadata);
const configNormalized = { ...finalMetadata.config, configRevision: publicMetadata.config.configRevision };
assert.deepEqual(canonical(configNormalized), canonical(publicMetadata.config), 'Raw public disk config except its monotonic revision.');
const registryNormalized = structuredClone(finalMetadata.registry);
assert.ok(registryNormalized.revision > publicMetadata.registry.revision);
registryNormalized.revision = publicMetadata.registry.revision;
const originalConnection = publicMetadata.registry.connections.find(value => value.id === connectionId);
const finalConnection = registryNormalized.connections.find(value => value.id === connectionId);
assert.equal(finalConnection.revision, originalConnection.revision + 2);
finalConnection.revision = originalConnection.revision; finalConnection.updatedAt = originalConnection.updatedAt;
const registryBefore = structuredClone(publicMetadata.registry);
const normalizedBeforeConnection = registryBefore.connections.find(value => value.id === connectionId);
const normalization = Object.fromEntries(Object.entries(originalIdentity(normalizedBeforeConnection)).filter(([key]) => !Object.hasOwn(normalizedBeforeConnection, key)));
Object.assign(normalizedBeforeConnection, normalization);
save('node/declared-identity-default-normalization.json', { connectionId, added: normalization,
originalRawStatePreserved: true, originalSemanticsRestored: true, reason: 'The public partial-update API retains missing fields; restore explicit original default semantics rather than silently retaining require-match.' });
for (const value of [registryBefore, registryNormalized]) value.connections.sort((a, b) => a.id.localeCompare(b.id));
assert.deepEqual(canonical(registryNormalized), canonical(registryBefore), 'Registry except declared revision/timestamp/order and explicit original identity defaults.');
const finalAttempts = meta('modelAttempts');
for (const item of originalAttempts) assert.deepEqual(finalAttempts.find(value => value.id === item.id), item, 'Original complete model attempt: ' + item.id);
const metadataRows = new Map(after.database.tables.metadata.rows.map(row => [row.id, row]));
for (const row of before.database.tables.metadata.rows.filter(row => !['config', 'modelRegistry', 'modelAttempts'].includes(row.id))) assert.deepEqual(metadataRows.get(row.id), row);
save('node/restoration.json', { passed: true, originalExports: before.exports.length, originalArtifactFiles: before.persistent.artifacts.length,
originalRowsExact: ['sessions', 'records', 'events', 'outbox'], budgetsAndSelectionRestored: true, poolsUnchanged: true,
originalPublicProjectsExact: true, originalAttemptsExact: originalAttempts.length, rawConfigExceptRevisionExact: true,
registryExceptDeclaredRevisionTimestampOrderAndIdentityDefaultsExact: true, identityDefaultNormalization: normalization, otherMetadataRowsExact: true,
originalCredentialRevision: connection?.credentialRevision, finalCredentialRevision: after.modelCenter.connections.find(value => value.id === connectionId)?.credentialRevision,
changedOnlyMonotonicRevisionsObservedHealthAndDeclaredIdentityDefaults: true, pid: after.pid, version: after.version, noKeyExtractedOrResaved: true });
}
save('node/result.json', result ?? { success: false, failure, noModelDispatch: true }); await close();
}
console.log(JSON.stringify({ success: result.success, attempts: result.attempts, usage: result.usage, state: result.state,
stopReason: result.stopReason, commit: result.commit, tests: result.tests, error: result.failure?.message }));
@@ -0,0 +1,85 @@
// One-shot QA adapter. Runs inside the existing host; never reads a credential.
export async function boundedGptPreflight(input) {
const ensure = (value, message) => { if (!value) throw new Error(message); };
ensure(process.pid === input.pid, 'Unexpected host PID.');
const servers = process._getActiveHandles().filter(h => h?.listening && h.address?.()?.address === '127.0.0.1' && h.address?.()?.port === input.port);
ensure(servers.length === 1, 'Expected one owned loopback server.');
const context = servers[0].workbenchHostAuthority?.context;
ensure(context?.provider && context?.store && context?.runtime, 'Original context missing.');
const { store, provider, runtime } = context;
ensure(runtime.appDirectory === input.runtimeRoot, 'Loaded runtime changed.');
ensure(![...store.sessions.values()].some(s => ['running', 'stopping', 'awaiting_approval'].includes(s.status)), 'Host is busy.');
const session = store.session(input.sessionId), project = store.project(session.projectId);
ensure(session.projectId === input.projectId && session.messages.length === 0 && !session.runId, 'Probe session must be new and owned.');
const hub = provider.modelHub(store);
const connection = hub.view().connections.find(c => c.id === input.connectionId);
ensure(connection?.hasKey && connection.credentialRevision === input.credentialRevision, 'Original saved credential revision changed.');
ensure(connection.enabled && connection.protocol === 'chat-completions' && (connection.modelIdentityPolicy ?? 'record') === 'record', 'Probe protocol/auth/identity mismatch.');
ensure(connection.baseUrl === input.baseUrl && connection.model === input.model && connection.revision === input.connectionRevision, 'Connection changed.');
const config = hub.prepare({ ...store.config, mode: 'compatible', maxSteps: 1, maxOutputTokens: 256,
contextLimit: 16000, maxRunTokens: 16000, maxTaskTokens: 16000, maxRunDurationMs: 320000,
modelResponseTimeoutMs: 300000, modelStreamIdleTimeoutMs: 120000 }, { type: 'connection', id: input.connectionId });
config.modelRouting.members = config.modelRouting.members.map(member => ({ ...member, modelIdentityPolicy: 'require-match', modelIdentityAliases: [], modelIdentityAliasSource: '' }));
ensure(config.modelRouting.members.length === 1 && config.modelRouting.maxAttempts === 1 && config.maxOutputTokens === 256, 'One-request hard limits missing.');
globalThis.__gptTProbeOnce ??= new Set();
ensure(!globalThis.__gptTProbeOnce.has(input.sessionId), 'This sample cannot be replayed.');
globalThis.__gptTProbeOnce.add(input.sessionId);
session.title = input.title;
const run = store.beginRun(session, input.prompt, false, config, { forceNewTask: true });
store.message(session, 'user', input.prompt);
session.providerMessages.push({ role: 'user', content: input.prompt });
const step = store.beginStep(session, run), planner = runtime.requestPlanner();
let plan, response, diagnostic = null, requestEvent, receipts = 0, wireStarts = 0;
const wireIds = new Set();
const signal = AbortSignal.timeout(320000);
let stopReason = 'identity_probe_complete';
try {
plan = planner.prepare(session, run, config, { system: 'This is a connection identity preflight. Reply to the user exactly. No tools are available. Do not perform any project work.', tools: [], stepId: step.id });
const variants = plan.body.kind === 'model-route-plan' ? plan.body.variants.map(v => v.body) : [plan.body];
ensure(variants.length === 1 && variants.every(b => !(b.tools?.length) && b.max_tokens === 256 && b.model === input.model), 'Wire request violates no-tool contract.');
ensure(plan.record.tokenReservation.reservedTokens <= 16000, 'Reservation exceeds sealed budget.');
const progress = event => {
if (event.consumption) {
receipts += Number(store.recordConsumption(session, run, { ...event.consumption, requestId: plan.record.id }, plan.record.tokenReservation.reservedTokens));
return;
}
if (event.phase === 'running' && event.wireAttemptId) { wireIds.add(event.wireAttemptId); wireStarts = wireIds.size; ensure(wireStarts === 1, 'No retries permitted.'); }
requestEvent ??= store.event(session, { kind: 'model', source: 'model_connection', label: 'T · GPT单次身份预检(无工具)', phase: 'running', runId: run.id, contextPlanId: plan.record.id, startedAt: new Date().toISOString() });
if (event.modelAttemptId) requestEvent.modelAttemptId = event.modelAttemptId;
if (event.connectionId) requestEvent.connectionId = event.connectionId;
if (event.model) requestEvent.actualModel = event.model;
if (event.modelIdentity) requestEvent.modelIdentity = event.modelIdentity;
if (event.requestUrl) requestEvent.requestUrl = event.requestUrl;
if (event.diagnostic) requestEvent.diagnostic = event.diagnostic;
if (event.stream) requestEvent.stream = event.stream;
if (event.phase) requestEvent.phase = event.phase;
plan.record.requestAttempts = wireStarts; step.modelAttempts = wireStarts;
store.save(session);
};
response = await provider.complete(config, plan.messages, project, signal, progress, plan.record, [], { attempts: 1, maxBudgetAttempts: 1 });
ensure(!response.message.tool_calls?.length, 'Unsolicited tools are never executed.');
ensure(receipts === 1, 'Expected one original consumption receipt.');
planner.finish(session, plan.record, { response, attempts: wireStarts });
session.providerMessages.push(response.message); store.message(session, 'assistant', response.message.content);
const total = (run.usage?.reportedTokens ?? run.usage?.totalTokens ?? 0);
session.status = total > 16000 ? 'paused' : 'completed';
if (total > 16000) stopReason = 'task_token_limit';
} catch (cause) {
diagnostic = cause.diagnostic ?? { source: 'workbench', origin: 'local', stage: 'identity_preflight', kind: signal.aborted ? 'cancelled' : 'runtime', title: '身份预检需要核对', message: provider.redact(cause.message), occurredAt: new Date().toISOString() };
session.status = diagnostic.kind === 'model_identity' || signal.aborted ? 'paused' : 'failed';
stopReason = diagnostic.kind;
session.lastFailure = { ...diagnostic, runId: run.id };
const message = store.message(session, 'system', diagnostic.message);
session.failure = { ...session.lastFailure, messageId: message.id };
if (plan) planner.finish(session, plan.record, { error: new Error(diagnostic.message), attempts: wireStarts });
} finally {
if (requestEvent) { requestEvent.phase = diagnostic ? 'failed' : 'completed'; requestEvent.finishedAt = new Date().toISOString(); if (diagnostic) requestEvent.diagnostic = diagnostic; }
store.finishStep(session, step, diagnostic ? 'failed' : 'completed');
store.finishRun(session, run, stopReason);
}
const attempts = hub.attempts.filter(a => a.sessionId === session.id);
ensure(attempts.length <= 1 && wireStarts <= 1, 'Single-request limit exceeded.');
return { sessionId: session.id, projectId: project.id, taskId: run.taskId, runId: run.id, status: session.status,
stopReason, attempts: attempts.length, receipts, wireStarts, actualTools: run.toolCalls, usage: run.usage,
contextPlanId: plan?.record.id ?? null, diagnostic, message: response?.message ?? null };
}
@@ -0,0 +1,40 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { root, save, original, client, meta, connectionId } from './live-delivery-t-common.mjs';
import { inspectorClosed } from './live-delivery-t-inspector.mjs';
const read = name => JSON.parse(fs.readFileSync(path.join(root, name)));
const before = read('preflight/before.json'), after = read('preflight/after.json');
const owned = read('preflight/owned.json'), outcome = read('preflight/result.json');
assert.equal(outcome.passed, true);
assert.equal(after.pid, before.pid); assert.equal(after.pid, 36552); assert.equal(after.version, '1.24.7');
assert.equal(after.configSha256, before.configSha256); assert.deepEqual(after.active, []);
for (const item of before.exports) assert.deepEqual(after.exports.find(value => value.id === item.id), item);
const tables = ['sessions', 'records', 'events', 'outbox'];
for (const table of tables) {
assert.equal(after.database.tables[table].schemaSha256, before.database.tables[table].schemaSha256);
const rows = new Map(after.database.tables[table].rows.map(row => [row.id, row]));
for (const row of before.database.tables[table].rows) assert.deepEqual(rows.get(row.id), row, table + '/' + row.id);
}
const rows = new Map(after.database.tables.metadata.rows.map(row => [row.id, row]));
for (const row of before.database.tables.metadata.rows.filter(row => row.id !== 'modelAttempts')) assert.deepEqual(rows.get(row.id), row, row.id);
const artifacts = new Map(after.persistent.artifacts.map(row => [row.path, row]));
for (const row of before.persistent.artifacts) assert.deepEqual(artifacts.get(row.path), row);
assert.deepEqual(after.modelCenter.selected, before.modelCenter.selected); assert.deepEqual(after.modelCenter.pools, before.modelCenter.pools);
for (const item of before.modelCenter.connections) {
const next = after.modelCenter.connections.find(row => row.id === item.id);
if (item.id === connectionId) { const health = next.health; assert.ok(health); assert.deepEqual({ ...next, health: item.health }, item); }
else assert.deepEqual(next, item);
}
for (const item of read('preflight/original-attempts.json')) assert.deepEqual(meta('modelAttempts').find(row => row.id === item.id), item);
const { boot, close } = await client();
try {
assert.deepEqual(boot.config, original.config);
assert.deepEqual(boot.projects.filter(row => row.id !== owned.project.id), original.projects);
const closed = await inspectorClosed();
const result = { passed: true, pid: after.pid, version: after.version, originalExports: before.exports.length,
originalArtifacts: before.persistent.artifacts.length, originalRowsExact: tables, otherMetadataExceptAppendedAttemptsExact: true,
originalPublicProjectsExact: true, originalConfigRegistryAndPoolExact: true, observedConnectionHealthChange: true,
inspectorClosed: closed, noKeyReadOrResaved: true, ownedProjectId: owned.project.id, ownedSessionId: owned.session.id };
save('preflight/restoration.json', result); console.log(JSON.stringify(result));
} finally { await close(); }
@@ -0,0 +1,68 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { randomUUID } from 'node:crypto';
import { publicSnapshot, hash } from './desktop-f-state.mjs';
import { invokeGptProbe, inspectorClosed } from './live-delivery-t-inspector.mjs';
import { root, origin, dataRoot, connectionId, save, meta, client, captureAttempts } from './live-delivery-t-common.mjs';
assert.equal(fs.existsSync(path.join(root, 'preflight')), false, 'Never replay or overwrite a real sample.');
const { api, boot, close } = await client();
let fatal;
try {
await inspectorClosed();
assert.equal(boot.version, '1.24.7');
const host = await api('/host/status'); assert.equal(host.identity.pid, 36552); assert.equal(host.activity.active, false);
const before = await publicSnapshot(origin, dataRoot); save('preflight/before.json', before);
assert.deepEqual(before.active, []);
const connection = before.modelCenter.connections.find(value => value.id === connectionId);
assert.equal(connection.enabled, true); assert.equal(connection.hasKey, true); assert.equal(connection.credentialRevision, 1);
assert.equal(connection.protocol, 'chat-completions'); assert.equal(connection.model, 'gpt-6.1-sol'); assert.equal(connection.revision, 7);
assert.equal(connection.contextLimit, 16000); assert.equal(connection.modelIdentityPolicy ?? 'record', 'record');
const originalAttempts = meta('modelAttempts'); save('preflight/original-attempts.json', originalAttempts);
const nonce = randomUUID(), prompt = `这是独立GPT连接身份预检,不是工程任务。只回复 OK ${nonce},不要调用工具、读写文件或执行命令。`;
save('preflight/contract.json', { kind: 'single-real-GPT-identity-preflight', connectionId, connection,
version: boot.version, runtimeRoot: boot.runtimeRoot, maxRequests: 1, maxAttempts: 1, maxOutputTokens: 256,
maxTokens: 16000, contextLimit: 16000, toolDefinitions: 0, toolExecution: 0,
poolSwitching: false, automaticReplay: false, modelIdentityPolicy: 'require-match in this experiment snapshot only',
noGlobalConfigurationWrite: true, noCredentialExtractionOrResave: true, prompt, nonce,
originalBaselineSha256: hash(fs.readFileSync(path.join(root, 'preflight/before.json'))) });
const projectRoot = path.join(root, 'preflight/identity-only'); fs.mkdirSync(projectRoot);
fs.writeFileSync(path.join(projectRoot, 'README.md'), '# T GPT identity preflight\nNo engineering or command execution.\n', { flag: 'wx' });
const project = await api('/projects', { root: projectRoot });
const session = await api('/sessions', { projectId: project.id }); save('preflight/owned.json', { project, session });
const input = { pid: host.identity.pid, port: 4318, runtimeRoot: boot.runtimeRoot, sessionId: session.id, projectId: project.id,
connectionId, connectionRevision: connection.revision, credentialRevision: connection.credentialRevision,
baseUrl: connection.baseUrl, model: connection.model, title: 'T · jojocode GPT连接单次预检', prompt };
save('preflight/input.json', input);
console.log(JSON.stringify({ stage: 'single-GPT-preflight', connectionId, model: connection.model, requestUrl: connection.baseUrl + '/chat/completions', maxRequests: 1, toolDefinitions: 0 }));
const invoked = await invokeGptProbe(input); save('preflight/expression.js', invoked.expression); save('preflight/host-result.json', invoked.result);
const previous = new Set(originalAttempts.map(value => value.id));
const attempts = meta('modelAttempts').filter(value => !previous.has(value.id)); save('preflight/attempts.json', attempts);
assert.ok(attempts.length <= 1); for (const attempt of attempts) { assert.equal(attempt.sessionId, session.id); assert.equal(attempt.connectionId, connectionId); assert.equal(attempt.poolId, null); }
const state = await api('/sessions/' + session.id); save('preflight/session.json', state);
save('preflight/export.json', await api('/sessions/' + session.id + '/export'));
const captures = await captureAttempts(api, attempts, 'preflight/captures');
const attempt = attempts[0];
const passed = attempts.length === 1 && attempt.status === 'completed' && attempt.modelIdentity?.status === 'matched'
&& attempt.modelIdentity.complete === true && attempt.modelIdentity.policy === 'require-match' && attempt.responseRedacted === false
&& attempt.usageStatus === 'reported' && attempt.usage.total_tokens <= 16000 && captures.length === 2
&& invoked.result.actualTools === 0 && state.status === 'completed' && invoked.result.message?.content?.includes(nonce);
const result = { passed, engineeringTestAllowed: passed, testedAt: new Date().toISOString(), version: boot.version,
connectionId, sessionId: session.id, projectId: project.id, taskId: invoked.result.taskId,
requestedModel: connection.model, reportedModels: attempt?.modelIdentity?.reportedModels ?? [], identity: attempt?.modelIdentity,
requestUrl: attempt?.requestUrl, requests: attempts.length, usage: attempt?.usage ?? null, usageStatus: attempt?.usageStatus ?? 'not_dispatched',
actualTools: invoked.result.actualTools, stopReason: invoked.result.stopReason, captures,
noRetryOrPoolSwitch: attempts.every(value => value.ordinal === 1 && value.poolId === null),
modelWeightsAuthenticated: false, engineeringDeliveryTested: false, purgeBenefitTested: false,
defaultSelectionChanged: false, connectionConfigChanged: false, credentialValuesReadOrSaved: false };
save('preflight/result.json', result); console.log(JSON.stringify({ passed, requests: result.requests, usage: result.usage, reportedModels: result.reportedModels, stopReason: result.stopReason }));
} catch (error) {
fatal = { name: error.name, message: error.message, stack: error.stack, recordedAt: new Date().toISOString(), automaticReplay: false };
save('preflight/driver-error.json', fatal); process.exitCode = 1;
} finally {
save('preflight/after.json', await publicSnapshot(origin, dataRoot));
save('preflight/inspector-final.json', { closed: await inspectorClosed() });
await close();
}
if (fatal) console.error(fatal.message);
@@ -0,0 +1,20 @@
import fs from 'node:fs';
import assert from 'node:assert/strict';
const once = (text, before, after) => { assert.equal(text.split(before).length, 2, before); return text.replace(before, after); };
const names = ['initial', 'common', 'payload', 'inspector', 'preflight', 'preflight-audit', 'node', 'network'];
for (const name of names) {
let value = fs.readFileSync('.qa/live-delivery-r-' + name + '.mjs', 'utf8')
.replaceAll('live-delivery-r', 'live-delivery-t').replaceAll('__gptRProbeOnce', '__gptTProbeOnce')
.replaceAll('1.24.6', '1.24.7').replaceAll('R GPT', 'T GPT').replaceAll('R · ', 'T · ');
if (['initial', 'preflight', 'node'].includes(name)) value = once(value, 'assert.equal(connection.revision, 5);', 'assert.equal(connection.revision, 7);');
if (name === 'network') {
value = once(value, 'assert.equal(history.active, 0); assert.equal(history.jobs.length, 0);', 'assert.equal(history.active, 0); assert.equal(history.jobs.length, 1);');
value = once(value, 'assert.equal(connection.revision, 5);', 'assert.equal(connection.revision, 7);');
value = once(value, 'assert.equal(current.jobs.length, 1);', 'assert.equal(current.jobs.length, history.jobs.length + 1);');
value = once(value, 'assert.equal(job.connectionId, connectionId); assert.equal(job.connectionRevision, 5);', 'assert.equal(job.connectionId, connectionId); assert.equal(job.connectionRevision, 7);');
value = once(value, 'assert.equal(after.database.tables.metadata.count - before.database.tables.metadata.count, 1);', 'assert.equal(after.database.tables.metadata.count, before.database.tables.metadata.count);');
value = once(value, "assert.deepEqual(meta('modelNetworkDiagnostics').map(row => row.id), [jobId]);", "assert.deepEqual(meta('modelNetworkDiagnostics').filter(row => row.id !== jobId), history.jobs);\n assert.equal(meta('modelNetworkDiagnostics').filter(row => row.id === jobId).length, 1);");
}
fs.writeFileSync('.qa/live-delivery-t-' + name + '.mjs', value, { flag: 'wx' });
}
console.log(JSON.stringify({ prepared: names, modelRequests: 0, previousDriversUnchanged: true }));
@@ -0,0 +1,163 @@
{
"schemaVersion": 1,
"kind": "bounded-live-delivery-t-contract",
"frozenAt": "2026-11-03T22:52:49.043Z",
"sourceBaseCommit": "8f41611b1b9e6f9d147c4b5cc43fc77a56c0d6c3",
"branch": "feat/live-delivery-t",
"planSha256": "0fe47c5bbfb325e9440ed308172f4a9ae0a86d0780c3d14e52210a6639be8994",
"originalBaselineSha256": "e5bd004667ca5c6b79561ab09293d141e8a15d6e4c6ceeee48ffb8a7ebfbc997",
"releaseVersion": "1.24.7",
"releaseSourceCommit": "5dcd6d7c3f4f465071ae1156bb1e0bf5a28f48e2",
"releaseIdentitySha256": "97a324b24632f5ec4ecec8df7e6c10977b36ce686ae6315fed671aa127cdc4f8",
"host": {
"pid": 36552,
"runtimeRoot": "C:\\Users\\wangy\\AppData\\Local\\Programs\\AgentWorkbench\\versions\\Agent-Workbench-1.24.7-win-x64-20261103164618190",
"runtimeIdentity": "212aba55ceb5eb08bb7985dd346bfb3967f5c7a36b2bc848b7e149adb50edf85"
},
"originalProjects": 63,
"originalSessions": 79,
"originalArtifacts": 3660,
"originalAttemptsRow": {
"id": "modelAttempts",
"sha256": "ee203ac7fa905ea149ace130f74b2df39a4786754806c87954a50b23b43ee3aa"
},
"originalDiagnosticsRow": {
"id": "modelNetworkDiagnostics",
"sha256": "772bfe75a6564ad6da07b2499dfc18f66282e376d092cbcd590c5b25e86a4585"
},
"dependencySources": [
{
"path": "src/core/git-process.mjs",
"sha256": "80547ec8928610ac4df5a05c5aef12d1aab0dca9e7b1def2773fc745f5adf5f5"
},
{
"path": "src/core/desktop/install-manager.mjs",
"sha256": "91c216537666f690122071a5b53b7c8b3beba4ea549acd1534edca24390d9635"
},
{
"path": "benchmarks/live-delivery-v1/node/src/amount.mjs",
"sha256": "84cb647328ec52dad27d288f3a6127ff3e1ad87274ae2d227ad44daa49cbb2ed"
},
{
"path": "benchmarks/live-delivery-v1/node/src/summary.mjs",
"sha256": "48829850c11ca0cd0ab5e86bbac69a0c5f90297292168c1ba6dc338e2eae6ee7"
},
{
"path": "benchmarks/live-delivery-v1/node/src/report.mjs",
"sha256": "ba0a014e6e9df710d66e255a3a6f970f4e1c8af48accc81f33627029dcded7c0"
},
{
"path": "benchmarks/live-delivery-v1/node/test/expense.test.mjs",
"sha256": "0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839"
},
{
"path": "benchmarks/live-delivery-v1/node/package.json",
"sha256": "6ad63026b2fe9de7513a4f6704c372a86108ee3d018a1f04883dc0a409ea4c24"
},
{
"path": "benchmarks/live-delivery-v1/node/scripts/build.mjs",
"sha256": "7279bc7c707c0f3ccbae63b14f0abed248ad3755be14f9e37128124ae9267526"
}
],
"previousDriverHashes": [
{
"path": ".qa/live-delivery-r-initial.mjs",
"sha256": "c77932a3284de2cf43a85a95b95756867da74dfc5f16f36e642c968a39916a74"
},
{
"path": ".qa/live-delivery-r-common.mjs",
"sha256": "c8ccf89f552ac69668e964a47c56be5e38276e9f239c3729c93de58220e9ed39"
},
{
"path": ".qa/live-delivery-r-payload.mjs",
"sha256": "fb2b5a6818cb229512823002aa090b95641cc404a6423190e1cb7194c34ecbd9"
},
{
"path": ".qa/live-delivery-r-inspector.mjs",
"sha256": "3306efc0651cae2a887ab944a6faed83332b2103a0aa3bf7cc56683c0c5abfe0"
},
{
"path": ".qa/live-delivery-r-preflight.mjs",
"sha256": "ed1192b71fbc1af6554cb76117fa1330b5d05345a5db1b784c6a551b1c6bf8f8"
},
{
"path": ".qa/live-delivery-r-preflight-audit.mjs",
"sha256": "938f92e7a2f5af357a54680ecd4a14f0e1c8798c1fc6f1b0a8f4561166e47f7e"
},
{
"path": ".qa/live-delivery-r-node.mjs",
"sha256": "014d153e0253182ace91105d19d1b2c78786aaa6de3f9630d97d242da84c1e86"
},
{
"path": ".qa/live-delivery-r-network.mjs",
"sha256": "518c38942629eed0ac671bbe9541e968ef6b8713a59acb62a91d979dfb8232a7"
}
],
"maxNetworkJobs": 1,
"maxPreflightRequests": 1,
"maxNodeRequests": 8,
"maxNodeTokens": 90000,
"maxNodeDurationMs": 600000,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"safetyReserveTokens": 1600,
"modelRequestsAtFreeze": 0,
"noKeyValuesReadOrSaved": true,
"files": [
{
"path": "drivers/desktop-f-state.mjs.txt",
"bytes": 5932,
"sha256": "6cf41ebd2ce55fe6fe3175948e9b964fac99975aca3132420a83b1d122e08b0b"
},
{
"path": "drivers/freeze-live-delivery-t.mjs.txt",
"bytes": 4057,
"sha256": "1ef57878f185c7ea0ae00434d616a385d7b55e084c06bfab811dcd5c55b36034"
},
{
"path": "drivers/live-delivery-t-common.mjs.txt",
"bytes": 3084,
"sha256": "f9690cb76eae4970494aee53d6ccaa2997dcaead1705f3bbd393ca844a1a31e5"
},
{
"path": "drivers/live-delivery-t-initial.mjs.txt",
"bytes": 2150,
"sha256": "70984fcb8f9bb4a839e5acaa44d8fd7712bf7173cb0e8974ea361e89be62b929"
},
{
"path": "drivers/live-delivery-t-inspector.mjs.txt",
"bytes": 3329,
"sha256": "69150611edc2829406ce98cd6968fbb24ca97d282d22ce8e500d8d92fb3ee580"
},
{
"path": "drivers/live-delivery-t-network.mjs.txt",
"bytes": 4926,
"sha256": "7ba233460aca2f58f9072ee8be57a2ab2aa5dbf7a0550af6c35864779d96d5c6"
},
{
"path": "drivers/live-delivery-t-node.mjs.txt",
"bytes": 23935,
"sha256": "2313c704c68e3d95b090ec8d73184a9978b19eb87a772efe92f1154b04deeede"
},
{
"path": "drivers/live-delivery-t-payload.mjs.txt",
"bytes": 7367,
"sha256": "170dd3becc13c6e8b9b2293035a4e142fac43a4cb5572dee85fd7644c674fb04"
},
{
"path": "drivers/live-delivery-t-preflight-audit.mjs.txt",
"bytes": 3090,
"sha256": "6f3bab7a6347578050f9c894702994d495cd1b2d169e0734477618d0af97b61e"
},
{
"path": "drivers/live-delivery-t-preflight.mjs.txt",
"bytes": 6152,
"sha256": "fa9c26f591e392015a936c80df329ab7a1a9a8dedc96f76eb1bb172cf36f4eb9"
},
{
"path": "drivers/prepare-live-delivery-t.mjs.txt",
"bytes": 2119,
"sha256": "d48d6a1df913c75d86102d8e39ec10726db11dcef82455f1687c1bc366f0ceaa"
}
]
}
@@ -0,0 +1,36 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { root, save, sha } from './live-delivery-t-common.mjs';
const read = relative => JSON.parse(fs.readFileSync(path.join(root, relative)));
const node = read('node/result.json'), session = read('node/session.json'), attempts = read('node/attempts.json');
const requests = attempts.map((attempt, index) => {
const request = node.captures.find(row => row.attemptId === attempt.id && row.kind === 'request');
const response = node.captures.find(row => row.attemptId === attempt.id && row.kind === 'response');
const originalRequest = fs.readFileSync(path.join(root, request.path));
const originalResponse = fs.readFileSync(path.join(root, response.path));
assert.equal(sha(originalRequest), attempt.requestSha256); assert.equal(sha(originalResponse), attempt.responseSha256);
const body = JSON.parse(originalRequest), raw = JSON.parse(originalResponse);
assert.deepEqual(raw.usage, attempt.usage);
return { ordinalInSample: index + 1, attemptId: attempt.id, requestId: attempt.requestId,
requestBytes: originalRequest.length, responseBytes: originalResponse.length, tools: body.tools?.length ?? 0,
messages: body.messages.map(row => ({ role: row.role, contentBytes: Buffer.byteLength(row.content ?? ''),
toolCallId: row.tool_call_id, toolNames: row.tool_calls?.map(call => call.function.name) })),
usage: raw.usage, identity: attempt.modelIdentity, responseMessage: raw.choices[0].message,
finishReason: raw.choices[0].finish_reason };
});
const result = { nodeSucceeded: node.success, stopReason: node.stopReason, requests,
contextPlans: session.execution.contextPlans.map(plan => ({ id: plan.id, status: plan.status, budget: plan.budget,
tokenReservation: plan.tokenReservation, requestAttempts: plan.requestAttempts, diagnostic: plan.diagnostic, usage: plan.usage })),
events: session.events.filter(row => row.kind === 'tool' || row.diagnostic || /budget|limit/.test(row.kind))
.map(row => ({ id: row.id, kind: row.kind, tool: row.tool, phase: row.phase, label: row.label, message: row.message, diagnostic: row.diagnostic })),
task: session.execution.task, run: session.execution.run,
checks: session.execution.checks, plans: session.execution.plans, taskPlans: session.execution.taskPlans,
changes: session.changes, approvals: node.approvals, applications: node.applications,
sourceAndGitUnchanged: read('node/git-final.json').diff === '',
scope: 'Offline original raw request/response, stored context plans, budget receipts and tool events. No model requests or host mutations.' };
save('analysis/original-review.json', result);
console.log(JSON.stringify({ requests: requests.map(row => ({ n: row.ordinalInSample, requestBytes: row.requestBytes,
usage: row.usage, finishReason: row.finishReason, response: row.responseMessage })),
contextPlans: result.contextPlans, run: result.run, checks: result.checks.map(job => ({ id: job.id, status: job.status, results: job.results })),
taskPlans: result.taskPlans, changes: result.changes, events: result.events }, null, 2));
@@ -0,0 +1,43 @@
// Offline replay of selection over original owned records; no model, host or project writes.
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { DatabaseSync } from 'node:sqlite';
import { workingCandidates } from '../src/core/context/working-set.mjs';
import { historyGroups } from '../src/core/context/request-plan.mjs';
import { digest } from './desktop-f-state.mjs';
import { root, dataRoot, save, sha } from './live-delivery-t-common.mjs';
const read = name => JSON.parse(fs.readFileSync(path.join(root,name)));
const session = read('node/export.json').session, state = read('node/session.json'), proof = read('final/ownership-proof.json');
const artifactIndex = read('analysis/artifact-index.json').artifacts, artifactMap = new Map(artifactIndex.map(row => [row.id,row]));
const db = new DatabaseSync(path.join(dataRoot,'workbench.sqlite'),{readOnly:true});
let rows;
try { rows = db.prepare("SELECT * FROM records WHERE session_id=? AND kind='tool' ORDER BY rowid").all(session.id); }
finally { db.close(); }
assert.equal(rows.length,16);
for (const row of rows) assert.equal(digest(row),proof.additions.records.find(item=>item.id===row.id)?.sha256);
save('analysis/owned-tool-rows.json',rows);
const tools = rows.map(row=>JSON.parse(row.payload));
const store = { core: { tool:new Map(tools.map(row=>[row.id,row])), check_job:new Map(state.execution.checks.map(row=>[row.id,row])) },
owned(kind,id,sessionId) { assert.equal(kind,'artifact'); const a=artifactMap.get(id); assert.ok(a); assert.equal(a.sessionId,sessionId); return a; },
artifactStore: { read(a) { const bytes=fs.readFileSync(path.join(root,a.capturedPath)); assert.equal(sha(bytes),a.sha256); return bytes.toString('utf8'); } } };
const groups=historyGroups(session.providerMessages);
assert.equal(groups.length,9);
const result=[];
for(const lastCompletedResponse of [4,5,6,7,8]) {
const selectedGroups=groups.filter(group=>group.index<=lastCompletedResponse);
const candidates=workingCandidates(store,session,state.execution.run,selectedGroups,2);
const test=candidates.filter(row=>row.observation.path==='test/expense.test.mjs');
const ranges=test.map(row=>[row.observation.offset,row.observation.offset+row.observation.content.length]).sort((a,b)=>a[0]-b[0]);
const missing=[];let next=0;for(const [a,b]of ranges){if(a>next)missing.push([next,a]);next=Math.max(next,b);}if(next<2584)missing.push([next,2584]);
result.push({lastCompletedResponse,candidates:candidates.map(row=>({source:row.source,observation:row.observation})),
testCandidateRanges:ranges,missingTestRangesBeforeBudgetSelection:missing,
checkCandidatePresent:candidates.some(row=>row.observation.kind==='check-results')});
}
assert.deepEqual(result[2].testCandidateRanges,[[473,2089],[2557,2584]]);
assert.deepEqual(result[2].missingTestRangesBeforeBudgetSelection,[[0,473],[2089,2557]]);
assert.equal(result[2].checkCandidatePresent,true);
save('analysis/candidate-replay.json',{passed:true,sourceCommit:'5dcd6d7c3f4f465071ae1156bb1e0bf5a28f48e2',ownedToolRows:rows.length,result,
totalExternalModelRequests:0,hostMutations:0,
conclusion:'For each path/revision the current selector retains only the widest page and a noncontained latest page. The test head and penultimate page are excluded before budget allocation. A current failed check candidate exists but is absent in actual requests7/8; selection capacity is separate from raw result availability. No implementation or unique model-causation claim.'});
console.log(JSON.stringify({passed:true,ownedRows:rows.length,result:result.map(row=>({afterResponse:row.lastCompletedResponse,testCandidateRanges:row.testCandidateRanges,missingBeforeBudget:row.missingTestRangesBeforeBudgetSelection,checkCandidatePresent:row.checkCandidatePresent})),externalModelRequests:0}));
@@ -0,0 +1,31 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { DatabaseSync } from 'node:sqlite';
import { root, dataRoot, save, client, sha } from './live-delivery-t-common.mjs';
const read = name => JSON.parse(fs.readFileSync(path.join(root, name)));
const owners = ['preflight', 'node'].map(name => read(name + '/owned.json'));
const db = new DatabaseSync(path.join(dataRoot, 'workbench.sqlite'), { readOnly: true });
let artifacts;
try {
artifacts = owners.flatMap(owner => db.prepare("SELECT payload FROM records WHERE kind='artifact' AND session_id=?").all(owner.session.id).map(row => JSON.parse(row.payload)));
} finally { db.close(); }
assert.ok(artifacts.length > 0);
const { api, close } = await client(), index = [];
try {
for (const artifact of artifacts) {
const owner = owners.find(row => row.session.id === artifact.sessionId);
assert.ok(owner); assert.equal(artifact.projectId, owner.project.id);
let content = '', offset = 0, page;
do {
page = await api('/artifacts/' + artifact.id + '?session=' + artifact.sessionId + '&offset=' + offset + '&limit=16000');
assert.ok(page.content.length || !page.truncated); content += page.content; offset += page.content.length;
} while (page.truncated);
const bytes = Buffer.from(content, 'utf8'); assert.equal(sha(bytes), artifact.sha256); assert.equal(bytes.length, artifact.bytes);
const relative = 'analysis/artifacts/' + artifact.sessionId + '/' + artifact.id + '.txt'; save(relative, bytes);
index.push({ ...artifact, capturedPath: relative });
}
save('analysis/artifact-index.json', { artifacts: index, scope: 'Every owned artifact record, fetched read-only through the original API and checked against its original SHA and bytes; no old/user artifact contents exported.' });
console.log(JSON.stringify({ capturedOwnedArtifactRecords: index.length, uniqueByteHashes: new Set(index.map(row => row.sha256)).size,
bytes: index.reduce((sum,row) => sum + row.bytes, 0), modelRequests: 0, allHashesExact: true }));
} finally { await close(); }
@@ -0,0 +1,93 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { execFileSync } from 'node:child_process';
import { root, readFileSync, save, sha } from './live-delivery-t-proof-support.mjs';
const read = name => JSON.parse(readFileSync(name));
const session = read('node/session.json'), outcome = read('node/result.json'), review = read('analysis/original-review.json');
const artifacts = read('analysis/artifact-index.json').artifacts, byId = new Map(artifacts.map(row => [row.id, row]));
const paths = ['test/expense.test.mjs', 'src/amount.mjs', 'src/summary.mjs', 'src/report.mjs'];
const sources = Object.fromEntries(paths.map(name => [name, readFileSync('node/source-before/' + name).toString('utf8')]));
const sourceResults = [];
for (const artifact of artifacts.filter(row => row.kind === 'tool-result')) {
const result = JSON.parse(readFileSync(artifact.capturedPath));
if (paths.includes(result.path) && typeof result.content === 'string') {
assert.equal(result.sha256, sha(sources[result.path]));
assert.equal(result.range_start_line, 1);
assert.equal(result.content, sources[result.path].slice(result.offset, result.next_offset));
sourceResults.push({ artifactId: artifact.id, artifactSha256: artifact.sha256, ...result });
}
}
const union = ranges => ranges.slice().sort((a,b) => a[0]-b[0]).reduce((result, [a,b]) => {
const last = result.at(-1); if (last && a <= last[1]) last[1] = Math.max(last[1], b); else result.push([a,b]); return result;
}, []);
const covered = ranges => ranges.reduce((sum, [a,b]) => sum+b-a, 0);
const perRequest = [];
const job = session.execution.checks[0], checkPlan = session.execution.plans.find(row => row.id === job.planId) ?? session.execution.plans[0];
for (let n = 0; n < review.requests.length; n++) {
const capture = outcome.captures.filter(row => row.kind === 'request')[n], bytes = readFileSync(capture.path), body = JSON.parse(bytes);
assert.equal(sha(bytes), capture.sha256);
const segments = [];
const add = (result, content, contentOffset, sourceKind, artifactId) => {
if (!paths.includes(result?.path) || typeof content !== 'string') return;
assert.equal(result.sha256, sha(sources[result.path]));
const start = result.offset + contentOffset, end = start + content.length;
assert.equal(content, sources[result.path].slice(start,end));
if (artifactId) {
assert.ok(byId.has(artifactId)); const raw = sourceResults.find(row => row.artifactId === artifactId);
assert.ok(raw && raw.path === result.path && start >= raw.offset && end <= raw.next_offset);
}
segments.push({ path: result.path, sourceKind, artifactId, start, end, characters: content.length, contentSha256: sha(content) });
};
for (const message of body.messages) {
if (message.role === 'tool') {
const result = JSON.parse(message.content); add(result, result.content, 0, 'paired-file-tool-result', null);
}
if (message.role !== 'system') continue;
const jsonStart = message.content.indexOf('\n{');
if (jsonStart < 0) continue;
let data; try { data = JSON.parse(message.content.slice(jsonStart + 1)); } catch { continue; }
if (data.data?.kind === 'task-working-set') for (const entry of data.data.entries) {
add(entry.observation, entry.content, entry.content_offset ?? 0, 'working-set-file-view', entry.source?.result_artifact_id);
}
if (data.data?.kind === 'latest-tool-feedback') for (const entry of data.data.entries) {
if (entry.tool === 'read_file') add(entry.result, entry.result?.content_excerpt, 0, 'latest-file-excerpt', entry.result_artifact_id);
}
}
const files = paths.map(name => {
const ranges = union(segments.filter(row => row.path === name).map(row => [row.start,row.end]));
return { path: name, ranges, characters: covered(ranges), totalCharacters: sources[name].length, fullSourcePresentInStructuredFileViews: covered(ranges) === sources[name].length };
});
const wire = bytes.toString('utf8');
perRequest.push({ request: n+1, attemptId: review.requests[n].attemptId, requestSha256: sha(bytes), files, segments,
originalCheckJobIdMentionedAnywhere: wire.includes(job.id), originalCheckPlanIdMentionedAnywhere: wire.includes(checkPlan.id),
assistantTools: review.requests[n].responseMessage.tool_calls.map(call => ({ name: call.function.name, arguments: JSON.parse(call.function.arguments) })) });
}
const filePages = sourceResults.filter(row => row.path === paths[0]);
assert.deepEqual(filePages.map(row => [row.offset,row.next_offset]), [[0,473],[473,2089],[0,472],[2089,2557],[2557,2584]]);
const returnedRanges = union(filePages.map(row => [row.offset,row.next_offset])); assert.deepEqual(returnedRanges, [[0,2584]]);
assert.equal(outcome.stopReason, 'step_limit'); assert.equal(outcome.usage.requests,8); assert.equal(outcome.usage.totalTokens,76062);
assert.ok(perRequest.every(row => !row.files[0].fullSourcePresentInStructuredFileViews));
assert.equal(perRequest[6].originalCheckJobIdMentionedAnywhere,false); assert.equal(perRequest[7].originalCheckJobIdMentionedAnywhere,false);
for (const plan of session.execution.contextPlans) {
assert.equal(plan.budget.contextLimit,16000); assert.equal(plan.budget.outputReservation,2048); assert.equal(plan.budget.safetyTokens,1600);
assert.ok(plan.estimatedInputTokens <= plan.budget.inputBudget);
assert.ok(plan.tokenReservation.reservedTokens <= Math.min(plan.budget.runRemainingTokens,plan.budget.taskRemainingTokens));
}
const sourceFiles = ['src/core/context/read-budget.mjs','src/core/context/request-plan.mjs','src/core/context/working-set.mjs',
'src/core/context/tool-feedback.mjs','src/server/provider.mjs','src/server/runtime.mjs','src/server/diagnostics.mjs',
'src/shared/contracts/model-request.mjs','src/shared/contracts/model-reservation.mjs'];
const sourceCommit = '5dcd6d7c3f4f465071ae1156bb1e0bf5a28f48e2', sourceInputs = [];
for (const name of sourceFiles) {
const bytes = fs.readFileSync(name), committed = execFileSync('git',['show',sourceCommit+':'+name],{maxBuffer:2*1024*1024,windowsHide:true});
assert.deepEqual(bytes,committed); const capturedPath = 'analysis/source-inputs/'+name+'.txt'; save(capturedPath,bytes);
sourceInputs.push({path:name,capturedPath,sha256:sha(bytes),bytes:bytes.length});
}
save('analysis/context-proof.json', { sourceCommit, sourceInputs, perRequest, sourceResults,
returnedTestRanges: returnedRanges, returnedTestCharacters: covered(returnedRanges), totalTestCharacters: sources[paths[0]].length,
originalCheckJobId: job.id, originalCheckPlanId: checkPlan.id, stopReason: outcome.stopReason,
requests: outcome.usage.requests, reportedTokens: outcome.usage.totalTokens, unknownRequests: outcome.usage.unknownRequests,
contextPlans: session.execution.contextPlans.map(plan => ({id:plan.id,budget:plan.budget,estimatedInputTokens:plan.estimatedInputTokens,tokenReservation:plan.tokenReservation,requestAttempts:plan.requestAttempts})),
scope: 'Exact original typed file views in requests: paired file results, working-set content, latest file excerpts. Runtime outputExcerpt and partially escaped artifact wrappers are unstructured excerpts, not counted as complete source. Missing check UUID anywhere is checked on original wire bytes. This proves retention gaps, not a unique cause of model choices or future success.',
conclusion: 'All 2584 test characters returned by request6, yet no subsequent actual request contains the whole file in typed file views. Original check UUID absent in requests7/8; model repeats inspect_project/plan_checks. No code proposals or delivery, guards retained; next work must reproduce retention with these original bytes without more live calls.' });
console.log(JSON.stringify({passed:true,returnedTestCharacters:2584,sourceInputs:sourceInputs.length,requests:perRequest.map(row=>({n:row.request,testCharactersInStructuredViews:row.files[0].characters,checkJobIdPresent:row.originalCheckJobIdMentionedAnywhere,tools:row.assistantTools.map(call=>call.name)})),modelRequests:0}));
@@ -0,0 +1,105 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { DatabaseSync } from 'node:sqlite';
import { execFileSync } from 'node:child_process';
import { publicSnapshot, databaseSnapshot, canonical, digest } from './desktop-f-state.mjs';
import { root, origin, dataRoot, original, connectionId, save, meta, client, sha } from './live-delivery-t-common.mjs';
import { inspectorClosed } from './live-delivery-t-inspector.mjs';
const read = name => JSON.parse(fs.readFileSync(path.join(root, name)));
const preflight = read('preflight/result.json'), nodeExists = fs.existsSync(path.join(root, 'node/result.json'));
const node = nodeExists ? read('node/result.json') : null;
const previous = read(nodeExists ? 'node/after.json' : 'preflight/after.json'), before = original.baseline;
const { api, boot, close } = await client();
try {
const host = await api('/host/status'); assert.equal(host.identity.pid, 36552); assert.equal(host.activity.active, false);
const existing = fs.existsSync(path.join(root, 'final/snapshot.json'));
const after = existing ? read('final/snapshot.json') : await publicSnapshot(origin, dataRoot);
if (!existing) save('final/snapshot.json', after);
assert.deepEqual(canonical(databaseSnapshot(dataRoot).tables), canonical(after.database.tables), 'Frozen final snapshot is still current.');
for (const field of ['pid', 'version', 'runtimeRoot', 'configSha256', 'projectsSha256', 'sessionsSha256', 'eventCursor']) assert.deepEqual(after[field], previous[field], field);
assert.deepEqual(canonical(after.database.tables), canonical(previous.database.tables));
assert.deepEqual(after.exports, previous.exports); assert.deepEqual(after.persistent, previous.persistent);
for (const item of before.exports) assert.deepEqual(after.exports.find(value => value.id === item.id), item);
for (const [table, originalTable] of Object.entries(before.database.tables)) assert.equal(after.database.tables[table].schemaSha256, originalTable.schemaSha256, table + ' schema');
for (const table of ['sessions', 'records', 'events', 'outbox']) {
const rows = new Map(after.database.tables[table].rows.map(row => [row.id, row]));
for (const item of before.database.tables[table].rows) assert.deepEqual(rows.get(item.id), item, table + '/' + item.id);
}
const beforeRows = new Map(before.database.tables.metadata.rows.map(row => [row.id, row]));
const finalRows = new Map(after.database.tables.metadata.rows.map(row => [row.id, row]));
for (const [id, row] of beforeRows) if (!['config', 'modelRegistry', 'modelAttempts', 'modelNetworkDiagnostics'].includes(id)) assert.deepEqual(finalRows.get(id), row);
const network = read('network/after.json');
assert.deepEqual(finalRows.get('modelNetworkDiagnostics'), network.database.tables.metadata.rows.find(row => row.id === 'modelNetworkDiagnostics'));
assert.deepEqual([...finalRows.keys()].filter(id => !beforeRows.has(id)), []);
assert.equal(meta('modelNetworkDiagnostics').length, 2);
const artifacts = new Map(after.persistent.artifacts.map(row => [row.path, row]));
for (const row of before.persistent.artifacts) assert.deepEqual(artifacts.get(row.path), row);
const initialCenter = original.center, center = after.modelCenter;
assert.deepEqual(center.selected, initialCenter.selected); assert.deepEqual(center.pools, initialCenter.pools);
const expectedConnection = initialCenter.connections.find(row => row.id === connectionId), actualConnection = center.connections.find(row => row.id === connectionId);
assert.equal(actualConnection.revision, expectedConnection.revision + (nodeExists ? 2 : 0));
assert.equal(actualConnection.credentialRevision, 1);
assert.deepEqual({ ...actualConnection, revision: expectedConnection.revision, updatedAt: expectedConnection.updatedAt,
health: expectedConnection.health, status: expectedConnection.status }, expectedConnection);
for (const item of initialCenter.connections.filter(row => row.id !== connectionId)) {
const next = center.connections.find(row => row.id === item.id);
if (item.id === 'legacy-default') {
assert.equal(item.revision, original.config.configRevision); assert.equal(next.revision, boot.config.configRevision);
assert.deepEqual({ ...next, revision: item.revision }, item);
} else assert.deepEqual(next, item);
}
assert.deepEqual({ ...boot.config, configRevision: original.config.configRevision }, original.config);
const owns = [read('preflight/owned.json'), ...(nodeExists ? [read('node/owned.json')] : [])];
const ownedProjects = owns.map(row => row.project.id), ownedSessions = owns.map(row => row.session.id);
assert.deepEqual(boot.projects.filter(row => !ownedProjects.includes(row.id)), original.projects);
assert.deepEqual(after.database.sessionIds.filter(id => !ownedSessions.includes(id)), before.database.sessionIds);
const db = new DatabaseSync(path.join(dataRoot, 'workbench.sqlite'), { readOnly: true });
try {
const projectRows = new Map(db.prepare('SELECT * FROM projects').all().map(row => [row.id, row]));
for (const row of before.database.tables.projects.rows) assert.equal(digest({ ...projectRows.get(row.id), position: projectRows.get(row.id).position - ownedProjects.length }), row.sha256, 'Original raw project except declared insertion offset: ' + row.id);
for (const table of ['sessions', 'records', 'events']) {
const ids = new Set(before.database.tables[table].rows.map(row => row.id));
const rows = db.prepare('SELECT * FROM ' + table).all().filter(row => !ids.has(row.id));
assert.ok(rows.every(row => ownedProjects.includes(row.project_id) && (table === 'sessions' ? ownedSessions.includes(row.id) : ownedSessions.includes(row.session_id))), 'Every new ' + table + ' row belongs only to this experiment.');
}
const sequence = db.prepare("SELECT seq FROM sqlite_sequence WHERE name='events'").get().seq;
assert.equal(sequence, db.prepare('SELECT MAX(seq) AS seq FROM events').get().seq);
const oldOutbox = new Set(before.database.tables.outbox.rows.map(row => row.id));
for (const row of db.prepare('SELECT o.*,e.session_id FROM outbox o JOIN events e ON e.seq=o.seq').all()) if (!oldOutbox.has(row.seq)) assert.ok(ownedSessions.includes(row.session_id));
} finally { db.close(); }
const attempts = meta('modelAttempts'), oldAttempts = read('preflight/original-attempts.json');
for (const item of oldAttempts) assert.deepEqual(attempts.find(row => row.id === item.id), item);
const added = attempts.filter(row => !oldAttempts.some(old => old.id === row.id));
const expectedAttempts = [...read('preflight/attempts.json'), ...(nodeExists ? read('node/attempts.json') : [])];
assert.deepEqual(added, expectedAttempts); assert.ok(added.every(row => ownedSessions.includes(row.sessionId)));
const reportedTokens = added.reduce((sum, row) => sum + (row.usage?.total_tokens ?? 0), 0);
const unknownRequests = added.filter(row => row.usageStatus === 'unknown').length;
assert.equal(reportedTokens, (preflight.usage?.total_tokens ?? 0) + (node?.usage?.reportedTokens ?? node?.usage?.totalTokens ?? 0));
assert.equal(unknownRequests, node?.usage?.unknownRequests ?? 0);
const sourceChanged = execFileSync('git', ['diff', '28d21e75', '--name-only', '--', 'src', 'package.json', 'package-lock.json'], { encoding: 'utf8', windowsHide: true }).trim();
assert.equal(sourceChanged, '');
const contract = JSON.parse(fs.readFileSync('docs/live-delivery-t-contract/manifest.json'));
for (const row of contract.files) assert.equal(sha(fs.readFileSync(path.join('docs/live-delivery-t-contract', row.path))), row.sha256);
for (const row of contract.previousDriverHashes) assert.equal(sha(fs.readFileSync(row.path)), row.sha256);
assert.equal(sha(fs.readFileSync(path.join(root, 'current.json'))), contract.originalBaselineSha256);
const result = { passed: true, pid: after.pid, version: after.version, runtimeRoot: after.runtimeRoot,
originalProjects: original.projects.length, originalSessions: before.exports.length, originalArtifacts: before.persistent.artifacts.length,
originalAttempts: oldAttempts.length, finalProjects: after.projects, finalSessions: after.exports.length,
finalArtifacts: after.persistent.artifacts.length, finalCounts: Object.fromEntries(Object.entries(after.database.tables).map(([name, table]) => [name, table.count])),
ownedProjects, ownedSessions, addedAttempts: added.length, originalRowsExportsAndArtifactsExact: true,
originalRawProjectRowsExceptOwnedInsertionOffsetExact: true, ownedProjectInsertionOffset: ownedProjects.length,
allAppendedRowsBelongToOwnedSamples: true, originalPublicProjectsExact: true, originalAttemptsExact: true,
originalBudgetsSelectionAndPoolRestored: true, connectionRevision: [expectedConnection.revision, actualConnection.revision], credentialRevision: 1,
observedHealthAndStatusExcludedFromConfigurationEquality: true,
legacyDisplayRevisionFollowsGlobalConfigurationRevision: [original.config.configRevision, boot.config.configRevision],
diagnosticHistoryOnlyDeclaredAppend: true, diagnosticJobIds: meta('modelNetworkDiagnostics').map(row => row.id),
inspectorClosed: await inspectorClosed(), modelRequests: added.length, reportedTokens, unknownRequests,
estimatedUnknownTokens: node?.usage?.estimatedUnknownTokens ?? 0, nodeDelivered: node?.success ?? false,
preflightPassed: preflight.passed, exactSinceLastRestoration: true, previousDriversUnchanged: true,
purgeBenefitTested: false, keyReadOrResaved: false, productSourceChanged: false };
save('final/result.json', result); console.log(JSON.stringify(result));
} catch (error) {
save('final/audit-error-' + Date.now() + '.json', { name: error.name, message: error.message, stack: error.stack, automaticReplay: false });
throw error;
} finally { await close(); }
@@ -0,0 +1,17 @@
import assert from 'node:assert/strict';
import fs from 'node:fs';
import path from 'node:path';
import { databaseSnapshot, canonical } from './desktop-f-state.mjs';
import { root, original, dataRoot, save, client } from './live-delivery-t-common.mjs';
import { inspectorClosed } from './live-delivery-t-inspector.mjs';
const final=JSON.parse(fs.readFileSync(path.join(root,'final/snapshot.json')));
assert.deepEqual(canonical(databaseSnapshot(dataRoot).tables),canonical(final.database.tables));
const {api,boot,close}=await client();
try {
const host=await api('/host/status'),center=await api('/model-center');
assert.equal(host.identity.pid,36552);assert.equal(host.activity.active,false);assert.equal(boot.version,'1.24.7');
for(const key of ['pid','runtimeRoot','runtimeIdentity','dataRoot'])assert.deepEqual(host.identity[key],original.host.identity[key]);
assert.deepEqual(center,final.modelCenter);assert.equal(await inspectorClosed(),true);
save('final/host-readback.json',{host,version:boot.version,originalIdentityExact:true,modelCenterExactSinceRestoration:true,inspectorClosed:true});
console.log(JSON.stringify({passed:true,pid:host.identity.pid,version:boot.version,originalIdentityExact:true,allStoredRowsStillExact:true,inspectorClosed:true,modelRequests:0}));
}finally{await close();}
@@ -0,0 +1,44 @@
// Read-only follow-up of the one already completed diagnostic. Never starts a job.
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { publicSnapshot, canonical, digest } from './desktop-f-state.mjs';
import { root, origin, dataRoot, save, meta, client } from './live-delivery-t-common.mjs';
const read = name => JSON.parse(fs.readFileSync(path.join(root, name)));
const before = read('network/before.json'), after = read('network/after.json'), previous = read('network/history-before.json');
const history = read('network/history-after.json'), job = read('network/job.json'), error = read('network/driver-error.json');
assert.equal(error.jobId, job.id); assert.equal(error.automaticReplay, false);
assert.equal(job.status, 'passed'); assert.equal(job.httpRequests, 0); assert.equal(job.modelRequests, 0); assert.equal(job.credentialAccess, false);
assert.equal(job.stale, false); assert.equal(job.currentConnectionRevision, 7);
assert.equal(job.connectionRevision, 7); assert.equal(job.trials.length, 3);
assert.ok(job.trials.every(row => row.status === 'passed' && row.certificateAuthorized === true));
assert.equal(history.jobs.length, previous.jobs.length + 1); assert.equal(history.active, 0);
for (const old of previous.jobs) assert.deepEqual(history.jobs.find(row => row.id === old.id), old);
const stored = meta('modelNetworkDiagnostics');
const stripDerived = row => { const { stale, currentConnectionRevision, ...raw } = row; return raw; };
assert.deepEqual(stored.filter(row => row.id !== job.id), previous.jobs.map(stripDerived));
assert.deepEqual(stored.find(row => row.id === job.id), stripDerived(job));
for (const field of ['pid', 'version', 'runtimeRoot', 'hasKey', 'configSha256', 'projectsSha256', 'sessionsSha256', 'eventCursor', 'modelCenterSha256']) assert.deepEqual(after[field], before[field]);
assert.deepEqual(after.exports, before.exports);
assert.deepEqual(after.persistent.artifacts, before.persistent.artifacts);
assert.deepEqual(after.persistent.files, before.persistent.files);
for (const [table, value] of Object.entries(before.persistent.tables)) if (table !== 'metadata') assert.deepEqual(after.persistent.tables[table], value);
for (const [table, old] of Object.entries(before.database.tables)) {
assert.equal(after.database.tables[table].schemaSha256, old.schemaSha256);
assert.equal(after.database.tables[table].count, old.count);
const rows = value => value.rows.filter(row => table !== 'metadata' || row.id !== 'modelNetworkDiagnostics');
assert.deepEqual(rows(after.database.tables[table]), rows(old));
}
const { api, close } = await client();
try {
const current = await publicSnapshot(origin, dataRoot);
assert.deepEqual(canonical(current.database.tables), canonical(after.database.tables));
assert.deepEqual(current.exports, after.exports); assert.deepEqual(current.persistent, after.persistent);
assert.deepEqual(await api('/model-center/network-diagnostics'), history);
save('network/restoration.json', { passed: true, jobId: job.id, diagnosticStatus: job.status, elapsedMs: job.elapsedMs,
originalStateExactExceptOneAppendedDiagnostic: true, previousDiagnosticRawAndViewExact: true,
representationCorrection: { fields: ['stale', 'currentConnectionRevision'], verifiedSource: 'src/core/models/network-diagnostics.mjs:24',
sourceSha256: digest(fs.readFileSync('src/core/models/network-diagnostics.mjs', 'utf8')), rawStateUnchanged: true },
originalDriverFailureRetained: true, automaticDiagnosticReplay: false, credentialAccess: false, httpRequests: 0, modelRequests: 0 });
console.log(JSON.stringify({ passed: true, jobId: job.id, elapsedMs: job.elapsedMs, diagnosticRequests: 1, modelRequests: 0, originalStatePreserved: true }));
} finally { await close(); }
@@ -0,0 +1,35 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { DatabaseSync } from 'node:sqlite';
import { databaseSnapshot, canonical, digest } from './desktop-f-state.mjs';
import { root, dataRoot, original, save } from './live-delivery-t-common.mjs';
const final = JSON.parse(fs.readFileSync(path.join(root, 'final/result.json')));
const snapshot = JSON.parse(fs.readFileSync(path.join(root, 'final/snapshot.json')));
assert.deepEqual(canonical(databaseSnapshot(dataRoot).tables), canonical(snapshot.database.tables));
const db = new DatabaseSync(path.join(dataRoot, 'workbench.sqlite'), { readOnly: true });
try {
const additions = {};
for (const table of ['sessions', 'records', 'events']) {
const originalIds = new Set(original.baseline.database.tables[table].rows.map(row => row.id));
additions[table] = db.prepare('SELECT * FROM ' + table).all().filter(row => !originalIds.has(row.id)).map(row => ({
id: row.id, ...(row.kind ? { kind: row.kind } : {}), projectId: row.project_id,
sessionId: table === 'sessions' ? row.id : row.session_id, sha256: digest(row) }));
assert.ok(additions[table].every(row => final.ownedProjects.includes(row.projectId) && final.ownedSessions.includes(row.sessionId)));
}
const originalOutbox = new Set(original.baseline.database.tables.outbox.rows.map(row => row.id));
additions.outbox = db.prepare('SELECT o.seq,o.published_at,e.session_id FROM outbox o JOIN events e ON e.seq=o.seq').all()
.filter(row => !originalOutbox.has(row.seq)).map(row => ({ id: row.seq, sessionId: row.session_id, sha256: digest({ seq: row.seq, published_at: row.published_at }) }));
assert.ok(additions.outbox.every(row => final.ownedSessions.includes(row.sessionId)));
const originalProjects = new Map(original.baseline.database.tables.projects.rows.map(row => [row.id, row]));
const projects = db.prepare('SELECT * FROM projects').all().map(row => ({ id: row.id, position: row.position, actualSha256: digest(row),
...(originalProjects.has(row.id) ? { originalSha256: originalProjects.get(row.id).sha256,
normalizedSha256: digest({ ...row, position: row.position - final.ownedProjectInsertionOffset }) } : { owned: true }) }));
assert.ok(projects.filter(row => row.originalSha256).every(row => row.normalizedSha256 === row.originalSha256));
const result = { additions, projects, projectInsertionOffset: final.ownedProjectInsertionOffset,
sequence: db.prepare("SELECT seq FROM sqlite_sequence WHERE name='events'").get().seq,
scope: 'Only IDs, owner fields and full-row hashes of additions; original project payloads are not exported. No key or user content returned.' };
save('final/ownership-proof.json', result);
console.log(JSON.stringify({ passed: true, additions: Object.fromEntries(Object.entries(additions).map(([name, rows]) => [name, rows.length])),
originalProjectsNormalizedExact: projects.filter(row => row.originalSha256).length, ownedProjects: projects.filter(row => row.owned).length }));
} finally { db.close(); }
@@ -0,0 +1,5 @@
import fs from 'node:fs';
import path from 'node:path';
export { root, save, sha } from './live-delivery-t-common.mjs';
import { root } from './live-delivery-t-common.mjs';
export const readFileSync = name => fs.readFileSync(path.join(root,name));
@@ -0,0 +1,30 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { root, save, sha } from './live-delivery-t-common.mjs';
const read = name => JSON.parse(fs.readFileSync(path.join(root, name)));
const index = read('analysis/artifact-index.json').artifacts, analysis = read('analysis/original-review.json'), session = read('node/session.json');
const pages = [];
for (const artifact of index.filter(row => row.kind === 'tool-result')) {
const bytes = fs.readFileSync(path.join(root, artifact.capturedPath)); assert.equal(sha(bytes), artifact.sha256);
const result = JSON.parse(bytes);
if (result.path && typeof result.content === 'string' || result.kind && typeof result.content === 'string') pages.push({ artifactId: artifact.id,
artifactSha256: artifact.sha256, ...result });
}
const run = session.execution.run;
const budgetNotice = session.messages.filter(row => row.role === 'system').map(row => row.content);
const result = { stopReason: run.stopReason, finalUsage: run.usage,
contextBudget: run.error?.contextBudget ?? session.lastFailure?.contextBudget ?? null,
budgetNotice, pages,
sizing: session.execution.contextPlans.map(plan => ({ id: plan.id, mandatoryInputTokens: plan.mandatoryInputTokens,
nextReadFixedInputTokens: plan.nextReadFixedInputTokens, workingRetentionTokens: plan.workingRetentionTokens,
inputBudget: plan.budget.inputBudget, estimatedInputTokens: plan.estimatedInputTokens,
requestBytes: plan.requestBytes, reservation: plan.tokenReservation.reservedTokens,
observedInputRatio: plan.tokenReservation.routes[0].inputRatio })),
upstreamUsage: analysis.requests.map(row => ({ n: row.ordinalInSample, localRequestBytes: row.requestBytes, ...row.usage })),
readCoverage: session.execution.task.readProgress,
observation: 'Read pages advanced; this is not the same-range retry/no-progress guard. Upstream usage is retained as reported, not replaced by local byte estimates. Reading throughput and wrapper selection need bounded offline reproduction before any product fix.' };
save('analysis/reading-review.json', result);
console.log(JSON.stringify({ stopReason: result.stopReason, budgetNotice, pages: pages.map(page => ({ artifactId: page.artifactId,
path: page.path, kind: page.kind, sourceArtifactId: page.artifact_id, offset: page.offset, next: page.next_offset,
total: page.total_characters, returned: page.returned_characters, maximumMessageBytes: page.maximum_message_bytes, budgetLimited: page.budget_limited, content: page.content })), sizing: result.sizing }, null, 2));
@@ -0,0 +1,14 @@
import fs from 'node:fs';
import assert from 'node:assert/strict';
const once = (text, before, after) => { assert.equal(text.split(before).length, 2, before); return text.replace(before, after); };
for (const name of ['final-audit', 'ownership-proof', 'capture-artifacts']) {
let text = fs.readFileSync('.qa/live-delivery-r-' + name + '.mjs', 'utf8').replaceAll('live-delivery-r', 'live-delivery-t').replaceAll('1.24.6', '1.24.7');
if (name === 'final-audit') {
text = once(text, "!['config', 'modelRegistry', 'modelAttempts'].includes(id)", "!['config', 'modelRegistry', 'modelAttempts', 'modelNetworkDiagnostics'].includes(id)");
text = once(text, "assert.deepEqual([...finalRows.keys()].filter(id => !beforeRows.has(id)), ['modelNetworkDiagnostics']);", "assert.deepEqual([...finalRows.keys()].filter(id => !beforeRows.has(id)), []);\n assert.equal(meta('modelNetworkDiagnostics').length, 2);");
text = once(text, "['diff', 'ea82bde3',", "['diff', '28d21e75',");
text = once(text, 'diagnosticHistoryOnlyNewMetadata: true,', 'diagnosticHistoryOnlyDeclaredAppend: true,');
}
fs.writeFileSync('.qa/live-delivery-t-' + name + '.mjs', text, { flag: 'wx' });
}
console.log(JSON.stringify({ prepared: ['final-audit', 'ownership-proof', 'capture-artifacts'], modelRequests: 0 }));
@@ -0,0 +1,44 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { execFileSync } from 'node:child_process';
import { createHash } from 'node:crypto';
const source=path.resolve('.qa/live-delivery-t'),target=path.resolve('docs/live-delivery-t-evidence');
assert.equal(fs.existsSync(target),false,'Never overwrite sealed evidence.');
const read=name=>JSON.parse(fs.readFileSync(path.join(source,name)));
assert.equal(read('preflight/result.json').passed,true);assert.equal(read('node/result.json').success,false);
assert.equal(read('final/result.json').passed,true);assert.equal(read('final/ownership-proof.json').projectInsertionOffset,2);
assert.equal(read('analysis/candidate-replay.json').passed,true);assert.equal(read('final/host-readback.json').originalIdentityExact,true);
const git=args=>execFileSync('git',args,{encoding:'utf8',windowsHide:true}).trim();
assert.equal(git(['diff','28d21e75','--name-only','--','src','package.json','package-lock.json']),'');
fs.mkdirSync(target);const files=[],sha=bytes=>createHash('sha256').update(bytes).digest('hex');
const copy=(name,relative)=>{const bytes=fs.readFileSync(name),destination=path.join(target,relative);
fs.mkdirSync(path.dirname(destination),{recursive:true});fs.writeFileSync(destination,bytes,{flag:'wx'});
files.push({path:relative.replaceAll('\\','/'),bytes:bytes.length,sha256:sha(bytes)});};
const walk=(directory,prefix,relative='')=>{
for(const entry of fs.readdirSync(directory,{withFileTypes:true})){
if(['expense-project','identity-only','.git','node_modules'].includes(entry.name))continue;
assert.equal(entry.isSymbolicLink(),false);const next=path.posix.join(relative,entry.name),name=path.join(directory,entry.name);
if(entry.isDirectory())walk(name,prefix,next);else{assert.equal(entry.isFile(),true);copy(name,prefix+'/'+next);}
}
};
walk(source,'run');walk('docs/live-delivery-t-contract','contract');
for(const name of ['prepare-live-delivery-t-audits.mjs','live-delivery-t-final-audit.mjs','live-delivery-t-network-audit.mjs',
'live-delivery-t-analyze.mjs','live-delivery-t-capture-artifacts.mjs','live-delivery-t-reading-review.mjs',
'live-delivery-t-context-proof.mjs','live-delivery-t-proof-support.mjs','live-delivery-t-candidates-replay.mjs',
'live-delivery-t-ownership-proof.mjs','live-delivery-t-final-readback.mjs','seal-live-delivery-t.mjs'])copy(path.join('.qa',name),'drivers/'+name+'.txt');
for(const name of ['network-audit','final-audit','context-proof','candidates-replay','analyze','reading-review'])
copy('.qa/live-delivery-t-'+name+'.log','receipts/'+name+'.log');
copy('docs/reading-s-release-identity.json','provenance/release-1.24.7.json');
copy('docs/LIVE-DELIVERY-T-PLAN.md','provenance/frozen-plan.md');
copy('scripts/verify-live-delivery-t.mjs','drivers/verify-live-delivery-t.mjs.txt');
const release=JSON.parse(fs.readFileSync('docs/reading-s-release-identity.json'));
const manifest={schemaVersion:1,kind:'owned-live-delivery-t-evidence',createdAt:new Date().toISOString(),version:'1.24.7',
releaseSourceCommit:release.sourceCommit,experimentPlanCommit:git(['rev-parse','28d21e75']),experimentBaseCommit:git(['rev-parse','8f41611b']),
branch:git(['branch','--show-current']),references:{initial:'run/current.json',preflight:'run/preflight/result.json',node:'run/node/result.json',
final:'run/final/result.json',network:'run/network/job.json',ownership:'run/final/ownership-proof.json',context:'run/analysis/context-proof.json',
candidates:'run/analysis/candidate-replay.json',artifacts:'run/analysis/artifact-index.json'},
note:'One bounded diagnostic and one identity preflight passed. New Node ended at8requests/76062reportedTokens with original9tests failing, baseline build passing and no source change or delivery. Original data/defaults preserved under declared owned insertions/revisions/health. Exact file-view gaps and widest/latest candidate omission reproduced offline. No extra live calls, new product release or Purge benefit claim. Drivers are inert text; never replay.',
files:files.sort((a,b)=>a.path.localeCompare(b.path))};
fs.writeFileSync(path.join(target,'manifest.json'),JSON.stringify(manifest,null,2)+'\n',{flag:'wx'});
console.log(JSON.stringify({files:files.length,bytes:files.reduce((sum,row)=>sum+row.bytes,0),manifestSha256:sha(fs.readFileSync(path.join(target,'manifest.json')))}));
@@ -0,0 +1,196 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { createHash } from 'node:crypto';
import { execFileSync } from 'node:child_process';
const root=path.resolve('docs/live-delivery-t-evidence');
const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
const canonical=value=>Array.isArray(value)?value.map(canonical):value&&typeof value==='object'
?Object.fromEntries(Object.keys(value).sort().map(key=>[key,canonical(value[key])])):value;
const digest=value=>sha(JSON.stringify(canonical(value)));
const file=name=>{assert.equal(typeof name,'string');assert.ok(!/[\\\x00\r\n]/.test(name)&&!name.split('/').includes('..'));
const target=path.resolve(root,name);assert.ok(target.startsWith(root+path.sep));return target;};
const bytes=name=>fs.readFileSync(file(name)),read=name=>JSON.parse(bytes(name));
const manifest=read('manifest.json');assert.equal(manifest.kind,'owned-live-delivery-t-evidence');
const names=new Set();let totalBytes=0;
for(const row of manifest.files){assert.ok(!names.has(row.path));names.add(row.path);const value=bytes(row.path);
assert.equal(value.length,row.bytes);assert.equal(sha(value),row.sha256,row.path);totalBytes+=value.length;}
const list=(directory=root)=>fs.readdirSync(directory,{withFileTypes:true}).flatMap(entry=>{assert.equal(entry.isSymbolicLink(),false);
const target=path.join(directory,entry.name);return entry.isDirectory()?list(target):[path.relative(root,target).replaceAll('\\','/')];});
assert.deepEqual(list().sort(),['manifest.json',...names].sort());
const owned=name=>{assert.ok(names.has(name),name);return read(name);};
const initial=owned(manifest.references.initial),preflight=owned(manifest.references.preflight),node=owned(manifest.references.node);
const final=owned(manifest.references.final),network=owned(manifest.references.network),proof=owned(manifest.references.ownership);
const context=owned(manifest.references.context),replay=owned(manifest.references.candidates),artifacts=owned(manifest.references.artifacts).artifacts;
const frozen=owned('contract/manifest.json'),connectionId='5b4daed9-b2f7-4de0-b949-573eba70c7b3';
assert.equal(frozen.modelRequestsAtFreeze,0);assert.equal(frozen.maxNetworkJobs,1);assert.equal(frozen.maxPreflightRequests,1);
assert.equal(frozen.maxNodeRequests,8);assert.equal(frozen.maxNodeTokens,90000);assert.equal(frozen.maxNodeDurationMs,600000);
assert.equal(frozen.contextLimit,16000);assert.equal(frozen.maxOutputTokens,2048);assert.equal(frozen.safetyReserveTokens,1600);
assert.equal(sha(bytes('run/current.json')),frozen.originalBaselineSha256);
assert.equal(sha(bytes('provenance/frozen-plan.md')),frozen.planSha256);
const gitBytes=(commit,relative)=>execFileSync('git',['show',commit+':'+relative],{maxBuffer:2*1024*1024,windowsHide:true});
for(const row of frozen.files){assert.equal(bytes('contract/'+row.path).length,row.bytes);assert.equal(sha(bytes('contract/'+row.path)),row.sha256);
assert.deepEqual(bytes('contract/'+row.path),gitBytes(manifest.experimentPlanCommit,'docs/live-delivery-t-contract/'+row.path));}
assert.deepEqual(bytes('contract/manifest.json'),gitBytes(manifest.experimentPlanCommit,'docs/live-delivery-t-contract/manifest.json'));
for(const row of frozen.dependencySources)assert.equal(sha(gitBytes(manifest.experimentBaseCommit,row.path)),row.sha256);
for(const row of context.sourceInputs){assert.equal(sha(bytes('run/'+row.capturedPath)),row.sha256);assert.equal(bytes('run/'+row.capturedPath).length,row.bytes);
assert.deepEqual(bytes('run/'+row.capturedPath),gitBytes(manifest.releaseSourceCommit,row.path));}
assert.equal(context.sourceInputs.length,9);assert.equal(context.sourceCommit,manifest.releaseSourceCommit);
assert.equal(manifest.releaseSourceCommit,owned('provenance/release-1.24.7.json').sourceCommit);
assert.equal(sha(bytes('provenance/release-1.24.7.json')),frozen.releaseIdentitySha256);
assert.deepEqual(bytes('run/node/goal.txt'),gitBytes('fbedb738','docs/live-delivery-r-evidence/run/node/goal.txt'));
const stripDerived=row=>{const {stale,currentConnectionRevision,...raw}=row;return raw;};
assert.equal(network.connectionId,connectionId);assert.equal(network.connectionRevision,7);assert.equal(network.status,'passed');
assert.equal(network.stages.dns.status,'passed');assert.deepEqual(network.trials.map(row=>row.mode),['auto','ipv4','ipv6']);
assert.ok(network.trials.every(row=>row.status==='passed'&&row.certificateAuthorized===true));
assert.equal(network.httpRequests,0);assert.equal(network.modelRequests,0);assert.equal(network.credentialAccess,false);
assert.equal(network.route.kind,'direct-endpoint-only');assert.equal(network.route.modelApiRouteVerified,false);
assert.equal(owned('run/network/restoration.json').originalStateExactExceptOneAppendedDiagnostic,true);
assert.equal(owned('run/network/driver-error.json').jobId,network.id);
assert.equal(sha(bytes('run/network/audit-first-driver.mjs.txt')),owned('run/network/audit-first-error.json').driverSha256);
const allAttempts=[];let totalRequests=0,reportedTokens=0;
const assertPairs=messages=>{const pending=new Set();for(const message of messages){
if(message.role==='assistant'){assert.equal(pending.size,0);for(const call of message.tool_calls??[]){assert.ok(!pending.has(call.id));pending.add(call.id);}}
else if(message.role==='tool'){assert.ok(pending.has(message.tool_call_id));pending.delete(message.tool_call_id);}
else assert.equal(pending.size,0);
}assert.equal(pending.size,0);};
for(const [folder,outcome,expectedCount]of[['preflight',preflight,1],['node',node,8]]){
const attempts=owned('run/'+folder+'/attempts.json');assert.equal(attempts.length,expectedCount);allAttempts.push(...attempts);
assert.equal(outcome.captures.length,expectedCount*2);
for(const attempt of attempts){
assert.equal(attempt.connectionId,connectionId);assert.equal(attempt.connectionRevision,folder==='preflight'?7:8);
assert.equal(attempt.credentialRevision,1);assert.equal(attempt.poolId,null);assert.equal(attempt.ordinal,1);
assert.equal(attempt.model,'gpt-6.1-sol');assert.equal(attempt.protocol,'chat-completions');assert.equal(attempt.streaming,false);
assert.equal(attempt.requestUrl,'https://jojocode.com/v1/chat/completions');assert.equal(attempt.status,'completed');
assert.equal(attempt.modelIdentity.policy,'require-match');assert.equal(attempt.modelIdentity.status,'matched');
assert.equal(attempt.modelIdentity.complete,true);assert.deepEqual(attempt.modelIdentity.reportedModels,['gpt-6.1-sol']);
assert.equal(attempt.usageStatus,'reported');assert.equal(attempt.responseRedacted,false);
const captures=Object.fromEntries(outcome.captures.filter(row=>row.attemptId===attempt.id).map(row=>[row.kind,row]));
const request=bytes('run/'+captures.request.path),response=bytes('run/'+captures.response.path);
assert.equal(sha(request),attempt.requestSha256);assert.equal(sha(request),captures.request.sha256);
assert.equal(sha(response),attempt.responseSha256);assert.equal(sha(response),captures.response.sha256);
assert.equal(attempt.modelIdentity.responseSource.sha256,attempt.responseSha256);assert.equal(request.length,attempt.requestBytes);
const body=JSON.parse(request),raw=JSON.parse(response);assertPairs(body.messages);
assert.equal(body.model,'gpt-6.1-sol');assert.notEqual(body.stream,true);assert.equal(raw.model,'gpt-6.1-sol');assert.deepEqual(raw.usage,attempt.usage);
assert.ok(raw.usage.completion_tokens<=body.max_tokens);reportedTokens+=raw.usage.total_tokens;totalRequests++;
if(folder==='preflight'){
assert.equal(body.tools?.length??0,0);assert.equal(body.max_tokens,256);assert.equal(preflight.actualTools,0);assert.equal(preflight.passed,true);
assert.equal(raw.choices[0].message.tool_calls?.length??0,0);assert.ok(raw.choices[0].message.content.includes(owned('run/preflight/contract.json').nonce));
assert.deepEqual(raw.usage,preflight.usage);assert.equal(raw.usage.total_tokens,112);
}else{assert.equal(body.max_tokens,2048);assert.ok(body.tools.length>0);
assert.deepEqual(body.messages.filter(row=>row.role==='user').map(row=>row.content),[bytes('run/node/goal.txt').toString('utf8')]);}
}assert.equal(owned('run/'+folder+'/restoration.json').passed,true);
}
assert.equal(totalRequests,9);assert.equal(reportedTokens,76174);assert.equal(node.success,false);assert.equal(node.stopReason,'step_limit');
assert.equal(node.usage.requests,8);assert.equal(node.usage.totalTokens,76062);assert.equal(node.usage.unknownRequests,0);assert.equal(node.usage.estimatedUnknownTokens,0);
assert.deepEqual(node.applications,[]);assert.equal(node.modelImplementationSuppliedBySupervisor,false);
const session=owned('run/node/session.json');assert.deepEqual(session.changes,[]);assert.equal(session.execution.run.toolCalls,16);
assert.deepEqual(session.execution.run.budget,{maxSteps:8,maxDurationMs:600000,maxTokens:90000,maxTaskTokens:90000});
assert.equal(session.execution.checks.length,1);const checks=session.execution.checks[0];assert.equal(checks.status,'failed');
assert.deepEqual(checks.results.find(row=>row.name==='test').tests,{total:9,passed:0,failed:9,cancelled:0,skipped:0});
assert.equal(checks.results.find(row=>row.name==='build').status,'passed');assert.equal(node.approvals.length,1);assert.equal(node.approvals[0].allow,true);
assert.equal(node.approvals[0].command,'npm run test\nnpm run build');
assert.equal(session.execution.contextPlans.length,8);
for(const plan of session.execution.contextPlans){
assert.ok(plan.estimatedInputTokens<=plan.budget.inputBudget);
assert.ok(plan.tokenReservation.reservedTokens<=Math.min(plan.budget.runRemainingTokens,plan.budget.taskRemainingTokens));
assert.equal(plan.budget.contextLimit,16000);assert.equal(plan.budget.safetyTokens,1600);assert.equal(plan.budget.outputReservation,2048);assert.equal(plan.requestAttempts,1);
}
const testPath='test/expense.test.mjs',testSource=bytes('run/node/source-before/'+testPath).toString('utf8');assert.equal(testSource.length,2584);
const filePages=context.sourceResults.filter(row=>row.path===testPath);
assert.deepEqual(filePages.map(row=>[row.offset,row.next_offset]),[[0,473],[473,2089],[0,472],[2089,2557],[2557,2584]]);
for(const row of context.sourceResults){const source=bytes('run/node/source-before/'+row.path).toString('utf8');
assert.equal(row.content,source.slice(row.offset,row.next_offset));assert.equal(row.sha256,sha(source));}
assert.deepEqual(context.returnedTestRanges,[[0,2584]]);assert.equal(context.returnedTestCharacters,2584);
const union=ranges=>ranges.slice().sort((a,b)=>a[0]-b[0]).reduce((result,[a,b])=>{const previous=result.at(-1);
if(previous&&a<=previous[1])previous[1]=Math.max(previous[1],b);else result.push([a,b]);return result;},[]);
const actualCoverage=[];
for(let index=0;index<8;index++){
const capture=node.captures.filter(row=>row.kind==='request')[index],body=JSON.parse(bytes('run/'+capture.path)),segments=[];
const add=(value,content,offset=0)=>{if(value?.path!==testPath||typeof content!=='string')return;
assert.equal(value.sha256,sha(testSource));const start=value.offset+offset;assert.equal(content,testSource.slice(start,start+content.length));segments.push([start,start+content.length]);};
for(const message of body.messages){
if(message.role==='tool'){const value=JSON.parse(message.content);add(value,value.content);}
if(message.role!=='system')continue;
const start=message.content.indexOf('\n{');if(start<0)continue;let value;try{value=JSON.parse(message.content.slice(start+1));}catch{continue;}
if(value.data?.kind==='task-working-set')for(const entry of value.data.entries)add(entry.observation,entry.content,entry.content_offset??0);
if(value.data?.kind==='latest-tool-feedback')for(const entry of value.data.entries)if(entry.tool==='read_file')add(entry.result,entry.result?.content_excerpt);
}
const ranges=union(segments),count=ranges.reduce((sum,[a,b])=>sum+b-a,0);actualCoverage.push(count);
const expected=context.perRequest[index];assert.equal(expected.requestSha256,capture.sha256);assert.deepEqual(expected.files[0].ranges,ranges);assert.equal(expected.files[0].characters,count);
assert.equal(expected.originalCheckJobIdMentionedAnywhere,bytes('run/'+capture.path).includes(checks.id));
}
assert.deepEqual(actualCoverage,[0,0,0,400,1616,1060,27,421]);
assert.ok(context.perRequest.every(row=>!row.files[0].fullSourcePresentInStructuredFileViews));
assert.deepEqual(context.perRequest.slice(5).map(row=>row.originalCheckJobIdMentionedAnywhere),[false,false,false]);
assert.equal(replay.passed,true);assert.equal(replay.totalExternalModelRequests,0);assert.equal(replay.hostMutations,0);
assert.deepEqual(replay.result[2].testCandidateRanges,[[473,2089],[2557,2584]]);assert.deepEqual(replay.result[2].missingTestRangesBeforeBudgetSelection,[[0,473],[2089,2557]]);
assert.equal(replay.result[2].checkCandidatePresent,true);
const ownedToolRows=owned('run/analysis/owned-tool-rows.json');assert.equal(ownedToolRows.length,16);
for(const row of ownedToolRows)assert.equal(digest(row),proof.additions.records.find(item=>item.id===row.id)?.sha256);
const artifactMap=new Map(artifacts.map(row=>[row.id,row]));assert.equal(artifacts.length,74);
for(const artifact of artifacts){assert.ok(final.ownedSessions.includes(artifact.sessionId));assert.ok(final.ownedProjects.includes(artifact.projectId));
assert.equal(sha(bytes('run/'+artifact.capturedPath)),artifact.sha256);assert.equal(bytes('run/'+artifact.capturedPath).length,artifact.bytes);}
for(const row of context.sourceResults){const artifact=artifactMap.get(row.artifactId);assert.ok(artifact);assert.equal(artifact.sha256,row.artifactSha256);
const value=owned('run/'+artifact.capturedPath);assert.equal(value.content,row.content);assert.equal(value.offset,row.offset);}
for(const result of checks.results){assert.equal(artifactMap.get(result.logArtifactId)?.kind,'check-log');}
const snapshot=owned('run/final/snapshot.json');
for(const item of initial.baseline.exports)assert.deepEqual(snapshot.exports.find(row=>row.id===item.id),item);
for(const table of ['sessions','records','events','outbox']){
const before=initial.baseline.database.tables[table],after=snapshot.database.tables[table];assert.equal(after.schemaSha256,before.schemaSha256);
const rows=new Map(after.rows.map(row=>[row.id,row]));for(const row of before.rows)assert.deepEqual(rows.get(row.id),row);
assert.equal(proof.additions[table].length,after.count-before.count);
for(const row of proof.additions[table]){assert.ok(final.ownedSessions.includes(row.sessionId));if(row.projectId)assert.ok(final.ownedProjects.includes(row.projectId));assert.equal(rows.get(row.id).sha256,row.sha256);}
}
assert.equal(proof.additions.records.filter(row=>row.kind==='artifact').length,artifacts.length);
for(const artifact of artifacts)assert.ok(proof.additions.records.some(row=>row.kind==='artifact'&&row.id===artifact.id));
const originalProjectRows=new Map(initial.baseline.database.tables.projects.rows.map(row=>[row.id,row]));
const finalProjectRows=new Map(snapshot.database.tables.projects.rows.map(row=>[row.id,row]));
for(const row of proof.projects){assert.equal(row.actualSha256,finalProjectRows.get(row.id).sha256);
if(row.originalSha256){assert.equal(row.originalSha256,originalProjectRows.get(row.id).sha256);assert.equal(row.normalizedSha256,row.originalSha256);}else assert.ok(final.ownedProjects.includes(row.id));}
assert.equal(proof.projects.filter(row=>row.originalSha256).length,63);assert.equal(proof.projects.filter(row=>row.owned).length,2);assert.equal(proof.projectInsertionOffset,2);
const oldArtifactMap=new Map(initial.baseline.persistent.artifacts.map(row=>[row.path,row])),nextArtifactMap=new Map(snapshot.persistent.artifacts.map(row=>[row.path,row]));
for(const [name,row]of oldArtifactMap)assert.deepEqual(nextArtifactMap.get(name),row);
const addedFiles=snapshot.persistent.artifacts.filter(row=>!oldArtifactMap.has(row.path));assert.equal(addedFiles.length,60);
assert.ok(addedFiles.every(row=>artifacts.some(artifact=>artifact.sha256===row.sha256&&artifact.bytes===row.bytes)));
assert.deepEqual(snapshot.modelCenter.selected,initial.center.selected);assert.deepEqual(snapshot.modelCenter.pools,initial.center.pools);
const beforeMeta=owned('run/node/original-public-metadata.json'),afterMeta=owned('run/node/final-public-metadata.json');
const metadataRows=new Map(snapshot.database.tables.metadata.rows.map(row=>[row.id,row]));
const oldAttempts=owned('run/preflight/original-attempts.json');assert.equal(oldAttempts.length,216);
assert.deepEqual(owned('run/node/original-attempts.json'),[...oldAttempts,...owned('run/preflight/attempts.json')]);
assert.equal(metadataRows.get('modelAttempts').sha256,digest({key:'modelAttempts',value:JSON.stringify([...oldAttempts,...allAttempts])}));
for(const [key,value]of[['config',afterMeta.config],['modelRegistry',afterMeta.registry]])assert.equal(metadataRows.get(key).sha256,digest({key,value:JSON.stringify(value)}));
const oldNetwork=owned('run/network/history-before.json').jobs.map(stripDerived).reverse(),nextNetwork=owned('run/network/history-after.json').jobs.map(stripDerived).reverse();
assert.equal(oldNetwork.length,1);assert.deepEqual(nextNetwork,[...oldNetwork,stripDerived(network)]);
assert.equal(initial.baseline.database.tables.metadata.rows.find(row=>row.id==='modelNetworkDiagnostics').sha256,digest({key:'modelNetworkDiagnostics',value:JSON.stringify(oldNetwork)}));
assert.equal(metadataRows.get('modelNetworkDiagnostics').sha256,digest({key:'modelNetworkDiagnostics',value:JSON.stringify(nextNetwork)}));
for(const row of initial.baseline.database.tables.metadata.rows)if(!['config','modelRegistry','modelAttempts','modelNetworkDiagnostics'].includes(row.id))assert.deepEqual(metadataRows.get(row.id),row);
assert.deepEqual([...metadataRows.keys()].filter(key=>!initial.baseline.database.tables.metadata.rows.some(row=>row.id===key)),[]);
assert.deepEqual({...afterMeta.config,configRevision:beforeMeta.config.configRevision},beforeMeta.config);
const registry=structuredClone(afterMeta.registry);registry.revision=beforeMeta.registry.revision;
const connection=registry.connections.find(row=>row.id===connectionId),oldConnection=beforeMeta.registry.connections.find(row=>row.id===connectionId);
assert.equal(connection.revision,oldConnection.revision+2);connection.revision=oldConnection.revision;connection.updatedAt=oldConnection.updatedAt;
const expectedRegistry=structuredClone(beforeMeta.registry);for(const value of[expectedRegistry,registry])value.connections.sort((a,b)=>a.id.localeCompare(b.id));
assert.deepEqual(canonical(registry),canonical(expectedRegistry));assert.deepEqual(owned('run/node/restoration.json').identityDefaultNormalization,{});
for(const name of ['src/amount.mjs','src/summary.mjs','src/report.mjs'])assert.deepEqual(bytes('run/node/source-before/'+name),bytes('run/node/source-after/'+name));
const git=owned('run/node/git-final.json'),baseline=owned('run/node/source-identity.json');
assert.equal(git.head,baseline.head);assert.equal(git.status,baseline.status);assert.equal(git.stagedAfter,baseline.stagedBefore);assert.equal(git.diff,'');
assert.equal(final.passed,true);assert.equal(final.version,'1.24.7');assert.equal(final.pid,36552);assert.equal(final.inspectorClosed,true);
assert.equal(final.originalProjects,63);assert.equal(final.originalSessions,79);assert.equal(final.originalArtifacts,3660);assert.equal(final.originalAttempts,216);
assert.equal(final.finalProjects,65);assert.equal(final.finalSessions,81);assert.equal(final.finalArtifacts,3720);assert.equal(final.addedAttempts,9);
assert.deepEqual(final.connectionRevision,[7,9]);assert.equal(final.credentialRevision,1);assert.deepEqual(final.legacyDisplayRevisionFollowsGlobalConfigurationRevision,[69,73]);
assert.equal(final.originalBudgetsSelectionAndPoolRestored,true);assert.equal(final.reportedTokens,reportedTokens);assert.equal(final.unknownRequests,0);
assert.equal(final.nodeDelivered,false);assert.equal(final.purgeBenefitTested,false);assert.equal(final.productSourceChanged,false);assert.equal(final.keyReadOrResaved,false);
let gitIndex;
if(process.argv.includes('--index')){
const prefix=path.relative(process.cwd(),root).replaceAll('\\','/'),manifestBytes=bytes('manifest.json');
const entries=[...manifest.files,{path:'manifest.json',bytes:manifestBytes.length,sha256:sha(manifestBytes)}];
const output=execFileSync('git',['cat-file','--batch'],{input:entries.map(row=>':'+prefix+'/'+row.path).join('\n')+'\n',maxBuffer:256*1024*1024,windowsHide:true});
let offset=0,indexBytes=0;for(const entry of entries){const end=output.indexOf(10,offset),header=output.subarray(offset,end).toString('utf8'),match=header.match(/^[a-f0-9]{40} blob (\d+)$/);assert.ok(match,header);
const size=Number(match[1]);offset=end+1;const value=output.subarray(offset,offset+size);offset+=size;assert.equal(output[offset++],10);assert.equal(size,entry.bytes,entry.path);assert.equal(sha(value),entry.sha256,entry.path);indexBytes+=size;}
assert.equal(offset,output.length);gitIndex={passed:true,files:entries.length,bytes:indexBytes,exactOriginalBytes:true};
}
console.log(JSON.stringify({success:true,files:manifest.files.length,bytes:totalBytes,manifestSha256:sha(bytes('manifest.json')),
modelRequests:totalRequests,reportedTokens,unknownRequests:0,preflightPassed:true,nodeDelivered:false,originalPurgeBenefitTested:false,
ownedArtifactRecords:artifacts.length,originalDataAndDefaultsVerified:true,actualRequestRetentionAndCandidateReplayVerified:true,productVersion:'1.24.7',
...(gitIndex?{gitIndex}:{}),scope:'Offline original bytes, frozen plan/source, original usage, file coverage, owned records and declared restoration. No network, host mutation, model or credential access.'}));
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,19 @@
# T:读取修复交付后的新真实 Node 样本
本计划接续 S 1.24.7 的本地发行。S 只做隔离回放和可靠性修复,未请求真实模型,也未证明自主交付或 Purge 收益。T 的“新样本”需另行冻结;本文件不能作为旧 Task 自动续跑指令。
## 执行顺序
1. 冻结新的正式版本/候选/source、原 PID/Provider、当前高性能池、目标连接公开修订/凭据修订和全部原表行、导出、工件摘要。当前启用的 jojocode GPT Chat JSON 是预选,执行前重新读取实际状态;不复用过期修订,不提取、复制或重存 Key,不自动启用旧 apikey。
2. 为所属连接按原 Q 范围作一次有界 DNS/TCP/TLS 观察。它不发 HTTP、模型请求或读取 Key;不改变系统代理、IP 族、证书校验或健康评分,不能将握手通过当成 API 稳定性证明。诊断异常按所属结果结束。
3. 另开无工具单次身份预检。固定同一连接/协议/端点/严格型号策略及新请求预算;上游原文、实际 URL、型号和用量均封存。无重试、切池或别名补造;失败到此结束。通过仅证明这个样本的协议与报告身份,不认证底层权重。
4. 新建隔离 Node 费用报表工程和新 Task。原三源码/九测试、原目标及约束字节保持;16K 上下文、2048 输出、1600 安全预留、最多 8 请求/90000 tokens/600000ms,单条已通过预检的连接。原用量预留、身份保护、停止和审批保留。
5. 只由模型完成定位、实现三个模块、完整变更集、修复及交付计划。监督只核对/批准其原计划检查、审查应用完整三文件变更集及确认本地 Git;不提供源码、修复答案或补充提示,不修改九测试、配置、owner 文件和原暂存,不增加预算,不使用 run_command。
6. 分别核对每次实际请求的文件新覆盖、完整消息预算、已保留源码/约束、原上游报告用量及 Tool/Task/Run 所属。发生暂停、网络错误、未知用量或身份拒绝时封存原结果,不自动重放或续跑。
7. 成功需要原九测试和 build 通过、当前源 SHA/检查/变更集及 Git 计划一致,最终仅三个允许源码的已确认本地提交;口头声明、读完文件或基线 build 通过不算交付。结束后恢复本次允许暂改的公开预算/池/身份策略,按精确声明解释修订单调增长,逐原表行/导出/工件和公开模型中心核对,9229 关闭。
## 后续门槛
Node 通过后,再按独立冻结预算扩展 React 页面/交互和 Python 原测试交付。原版 Purge AB/BA 必须另设样本,锁定 Harness/Purge/profile、同工程/模型/预算、提示和工具/源码输入,保存失败及全部已报告/未知用量,分别评价交付、步骤/请求数、时间和成本;不把插件加载、提示增强或单次成功称为收益。
1.25 的任务要求/交付复核、其余能力和更新的重复完整目录核验性能保持独立排期。性能优化先测重复遍历的调用来源及不变身份缓存边界,保留字节/目录/指针、活动窗口/请求保护、故障回退和原 Provider/PID;不得为加速删核验。
@@ -0,0 +1,38 @@
{
"version": "1.24.7",
"sourceCommit": "5dcd6d7c3f4f465071ae1156bb1e0bf5a28f48e2",
"candidate": "Agent-Workbench-1.24.7-win-x64-20261103164618190",
"portableManifestSha256": "03683cabd6b88cabdb3eb4cd159ffbabdf1b37e1576354ec3d6433d4ca773be9",
"sourceManifestSha256": "13699d7e528c3abc6b73693aeb1aa0107fa3bdeeb86964b356e5086d9b47d51e",
"installer": {
"path": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\releases\\Agent-Workbench-1.24.7-win-x64-20261103164618190-Setup.exe",
"bytes": 213284660,
"sha256": "a2ea5ce3e249f5aeecc7bb5a8972746a214a59343d95d5828d6a0707a67dc2c2",
"compiler": {
"version": "6.3.1",
"sha256": "3b22d36fc7e7c421d8caf780008ecdb42b14b3f0371b9bafe3cad64e6648d9cf"
},
"source": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\installer-build-2bda8bad-f0af-4582-8304-200b8e7a1078\\installer.iss",
"version": "1.24.7",
"candidateDirectory": "Agent-Workbench-1.24.7-win-x64-20261103164618190",
"qaFixture": null
},
"archives": {
"portable": {
"path": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\releases\\Agent-Workbench-1.24.7-win-x64-20261103164618190.zip",
"bytes": 242883511,
"sha256": "9f6ec8ae971d9207b34d5a26c2b8e3c09e63b3138793ef25d898ce6e3641b23a"
},
"source": {
"path": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\releases\\Agent-Workbench-1.24.7-source-20261103164618190.zip",
"bytes": 1020471144,
"sha256": "e27ae51497a2a42632486a4b852e98a32c2d0877e9874f85ad1a01b802f49f1e"
},
"evidence": {
"path": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\releases\\Agent-Workbench-1.24.7-evidence-20261103164618190.zip",
"bytes": 779265448,
"sha256": "064f6bd47d6900f63706300ce1594b859ef0a92eebb41f6d656b386ad2981291"
}
},
"realModelRequests": 0
}
File diff suppressed because one or more lines are too long
@@ -0,0 +1 @@
{"passed":true,"ownedRows":16,"result":[{"afterResponse":4,"testCandidateRanges":[[473,2089]],"missingBeforeBudget":[[0,473],[2089,2584]],"checkCandidatePresent":true},{"afterResponse":5,"testCandidateRanges":[[473,2089],[2089,2557]],"missingBeforeBudget":[[0,473],[2557,2584]],"checkCandidatePresent":true},{"afterResponse":6,"testCandidateRanges":[[473,2089],[2557,2584]],"missingBeforeBudget":[[0,473],[2089,2557]],"checkCandidatePresent":true},{"afterResponse":7,"testCandidateRanges":[[473,2089],[2557,2584]],"missingBeforeBudget":[[0,473],[2089,2557]],"checkCandidatePresent":true},{"afterResponse":8,"testCandidateRanges":[[473,2089],[2557,2584]],"missingBeforeBudget":[[0,473],[2089,2557]],"checkCandidatePresent":true}],"externalModelRequests":0}
@@ -0,0 +1 @@
{"passed":true,"returnedTestCharacters":2584,"sourceInputs":9,"requests":[{"n":1,"testCharactersInStructuredViews":0,"checkJobIdPresent":false,"tools":["inspect_project"]},{"n":2,"testCharactersInStructuredViews":0,"checkJobIdPresent":false,"tools":["plan_checks"]},{"n":3,"testCharactersInStructuredViews":0,"checkJobIdPresent":false,"tools":["run_checks","read_file","read_file","read_file","read_file"]},{"n":4,"testCharactersInStructuredViews":400,"checkJobIdPresent":true,"tools":["read_file"]},{"n":5,"testCharactersInStructuredViews":1616,"checkJobIdPresent":true,"tools":["read_file","read_file"]},{"n":6,"testCharactersInStructuredViews":1060,"checkJobIdPresent":false,"tools":["read_artifact","read_artifact","inspect_task_plan","read_file"]},{"n":7,"testCharactersInStructuredViews":27,"checkJobIdPresent":false,"tools":["inspect_project"]},{"n":8,"testCharactersInStructuredViews":421,"checkJobIdPresent":false,"tools":["plan_checks"]}],"modelRequests":0}
@@ -0,0 +1 @@
{"passed":true,"pid":36552,"version":"1.24.7","runtimeRoot":"C:\\Users\\wangy\\AppData\\Local\\Programs\\AgentWorkbench\\versions\\Agent-Workbench-1.24.7-win-x64-20261103164618190","originalProjects":63,"originalSessions":79,"originalArtifacts":3660,"originalAttempts":216,"finalProjects":65,"finalSessions":81,"finalArtifacts":3720,"finalCounts":{"events":13484,"metadata":7,"outbox":13484,"projects":65,"records":6377,"sessions":81,"sqlite_sequence":1},"ownedProjects":["a7c44ef8-d487-426c-8228-8dce9dcc7665","5e353edf-99cb-4fbd-aade-9d2c69caa7e9"],"ownedSessions":["fef9c86c-86c5-4e66-a27a-4b29067c0426","5a1b39be-8096-46e6-bc43-156ca308f6f9"],"addedAttempts":9,"originalRowsExportsAndArtifactsExact":true,"originalRawProjectRowsExceptOwnedInsertionOffsetExact":true,"ownedProjectInsertionOffset":2,"allAppendedRowsBelongToOwnedSamples":true,"originalPublicProjectsExact":true,"originalAttemptsExact":true,"originalBudgetsSelectionAndPoolRestored":true,"connectionRevision":[7,9],"credentialRevision":1,"observedHealthAndStatusExcludedFromConfigurationEquality":true,"legacyDisplayRevisionFollowsGlobalConfigurationRevision":[69,73],"diagnosticHistoryOnlyDeclaredAppend":true,"diagnosticJobIds":["bfa3c359-5235-4f1e-979b-9540828238ae","486ed76c-9dca-4016-9b58-7ea4962c2c2b"],"inspectorClosed":true,"modelRequests":9,"reportedTokens":76174,"unknownRequests":0,"estimatedUnknownTokens":0,"nodeDelivered":false,"preflightPassed":true,"exactSinceLastRestoration":true,"previousDriversUnchanged":true,"purgeBenefitTested":false,"keyReadOrResaved":false,"productSourceChanged":false}
@@ -0,0 +1 @@
{"passed":true,"jobId":"486ed76c-9dca-4016-9b58-7ea4962c2c2b","elapsedMs":462,"diagnosticRequests":1,"modelRequests":0,"originalStatePreserved":true}
@@ -0,0 +1,208 @@
{
"stopReason": "step_limit",
"budgetNotice": [],
"pages": [
{
"artifactId": "f3df07e8-ccdd-49d3-b97c-6442a2149709",
"path": "test/expense.test.mjs",
"offset": 0,
"next": 473,
"total": 2584,
"returned": 473,
"maximumMessageBytes": 1024,
"budgetLimited": true,
"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 "
},
{
"artifactId": "2ca4b27b-8766-4441-8d47-b11ee786eda1",
"path": "src/amount.mjs",
"offset": 0,
"next": 51,
"total": 51,
"returned": 51,
"maximumMessageBytes": 1024,
"budgetLimited": false,
"content": "export function amountToCents(value) { return 0; }\n"
},
{
"artifactId": "de6e8e19-61e9-461c-83a0-11cfbc4a2785",
"path": "src/summary.mjs",
"offset": 0,
"next": 93,
"total": 93,
"returned": 93,
"maximumMessageBytes": 1024,
"budgetLimited": false,
"content": "import { amountToCents } from './amount.mjs';\nexport function summarize(rows) { return []; }\n"
},
{
"artifactId": "7552c7bf-6105-4aa8-8cf4-99bcd6a73eab",
"path": "src/report.mjs",
"offset": 0,
"next": 52,
"total": 52,
"returned": 52,
"maximumMessageBytes": 1024,
"budgetLimited": false,
"content": "export function formatReport(groups) { return ''; }\n"
},
{
"artifactId": "e067ec0a-3880-434d-9d8c-4654b27792f0",
"path": "test/expense.test.mjs",
"offset": 473,
"next": 2089,
"total": 2584,
"returned": 1616,
"maximumMessageBytes": 2202,
"budgetLimited": true,
"content": "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 a"
},
{
"artifactId": "61cd7158-815d-4b81-81cb-0e10eae04154",
"path": "test/expense.test.mjs",
"offset": 0,
"next": 472,
"total": 2584,
"returned": 472,
"maximumMessageBytes": 1024,
"budgetLimited": true,
"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"
},
{
"artifactId": "7d16b568-0b03-4a42-94ab-f165546096a5",
"path": "test/expense.test.mjs",
"offset": 2089,
"next": 2557,
"total": 2584,
"returned": 468,
"maximumMessageBytes": 1025,
"budgetLimited": true,
"content": "ssert.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"
},
{
"artifactId": "6f8f962e-8c70-4098-830e-508a25249bd2",
"kind": "tool-result",
"sourceArtifactId": "e067ec0a-3880-434d-9d8c-4654b27792f0",
"offset": 0,
"next": 500,
"total": 2055,
"returned": 500,
"maximumMessageBytes": 1024,
"budgetLimited": true,
"content": "{\"path\":\"test/expense.test.mjs\",\"start_line\":9,\"end_line\":31,\"total_lines\":38,\"content\":\"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(inp"
},
{
"artifactId": "babb0880-162b-4df8-a6ab-07aba8d7cd61",
"kind": "context-group",
"sourceArtifactId": "f1bf75d1-04d2-40de-a099-8efd552e4063",
"offset": 0,
"next": 362,
"total": 13197,
"returned": 362,
"maximumMessageBytes": 1024,
"budgetLimited": true,
"content": "[{\"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\\\"}\""
},
{
"artifactId": "dc5ae1ee-460d-4cb6-a296-7adfebe7a301",
"path": "test/expense.test.mjs",
"offset": 2557,
"next": 2584,
"total": 2584,
"returned": 27,
"maximumMessageBytes": 1024,
"budgetLimited": false,
"content": " (1)\\nUSD -0.01 (2)');\n});\n"
}
],
"sizing": [
{
"id": "26a57941-93d6-41e8-a94d-fa651d548973",
"mandatoryInputTokens": 8094,
"nextReadFixedInputTokens": 8094,
"workingRetentionTokens": 0,
"inputBudget": 12352,
"estimatedInputTokens": 8094,
"requestBytes": 23129,
"reservation": 10142,
"observedInputRatio": 1
},
{
"id": "e563a13e-55c7-4383-8206-558095402968",
"mandatoryInputTokens": 9119,
"nextReadFixedInputTokens": 8784,
"workingRetentionTokens": 0,
"inputBudget": 12352,
"estimatedInputTokens": 9097,
"requestBytes": 26090,
"reservation": 12387,
"observedInputRatio": 1.1365208796639485
},
{
"id": "925b963a-7530-4a76-a4e0-79f05b9edad9",
"mandatoryInputTokens": 9825,
"nextReadFixedInputTokens": 9229,
"workingRetentionTokens": 0,
"inputBudget": 12352,
"estimatedInputTokens": 10929,
"requestBytes": 31537,
"reservation": 14470,
"observedInputRatio": 1.1365208796639485
},
{
"id": "e649c2d4-473b-439d-b547-e27ac76e78b8",
"mandatoryInputTokens": 11467,
"nextReadFixedInputTokens": 10223,
"workingRetentionTokens": 751,
"inputBudget": 12352,
"estimatedInputTokens": 12218,
"requestBytes": 35430,
"reservation": 15935,
"observedInputRatio": 1.1365208796639485
},
{
"id": "d0afcd6a-edfb-41a8-8f8f-754ebbc4e2f3",
"mandatoryInputTokens": 10749,
"nextReadFixedInputTokens": 10272,
"workingRetentionTokens": 860,
"inputBudget": 12352,
"estimatedInputTokens": 12352,
"requestBytes": 35808,
"reservation": 16087,
"observedInputRatio": 1.1365208796639485
},
{
"id": "d52424c1-8fe4-464c-8e73-434bf77e2663",
"mandatoryInputTokens": 11205,
"nextReadFixedInputTokens": 10352,
"workingRetentionTokens": 860,
"inputBudget": 12352,
"estimatedInputTokens": 12352,
"requestBytes": 35784,
"reservation": 16087,
"observedInputRatio": 1.1365208796639485
},
{
"id": "60c19ef8-ea40-441b-a578-e63c0f1288f2",
"mandatoryInputTokens": 11529,
"nextReadFixedInputTokens": 10362,
"workingRetentionTokens": 661,
"inputBudget": 12352,
"estimatedInputTokens": 12274,
"requestBytes": 35502,
"reservation": 15998,
"observedInputRatio": 1.1365208796639485
},
{
"id": "aeea5541-c7fa-485c-9e58-f0eb06da126f",
"mandatoryInputTokens": 10674,
"nextReadFixedInputTokens": 10339,
"workingRetentionTokens": 1040,
"inputBudget": 12352,
"estimatedInputTokens": 12352,
"requestBytes": 35808,
"reservation": 16087,
"observedInputRatio": 1.1365208796639485
}
]
}
File diff suppressed because it is too large Load Diff
@@ -0,0 +1 @@
{"schemaVersion":1,"kind":"task-working-set","sessionId":"5a1b39be-8096-46e6-bc43-156ca308f6f9","projectId":"5e353edf-99cb-4fbd-aade-9d2c69caa7e9","taskId":"94a78e50-df05-4176-b033-32de563a347c","semantics":"recorded-tool-observations; file hashes identify observed revisions, not current filesystem guarantees","observationVersion":2,"entries":[{"source":{"call_id":"call_7ca0aaf713a34fb6b06af412a0806774","invocation_id":"b6f3cc9a-ae45-4a49-b79a-b71e2c55c221","tool":"read_file","run_id":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","group_index":3,"group_sha256":"d042fe08ebaf067f482a99a21639272eefccf6b04591399eb6288e7c6baa5e9f","result_artifact_id":"2ca4b27b-8766-4441-8d47-b11ee786eda1","result_sha256":"08b6595803497876c0745e6f72fab5d5a5233864e2f6447608b51adc2b7ddcf1","observed_at":"2026-11-03T22:56:07.627Z"},"observation":{"kind":"file","path":"src/amount.mjs","sha256":"84cb647328ec52dad27d288f3a6127ff3e1ad87274ae2d227ad44daa49cbb2ed","start_line":1,"end_line":2,"offset":0,"next_offset":51,"range_start_line":1,"range_end_line":2,"total_characters":51,"next_start_line":null,"budget_limited":false},"content":"export function amountToCents(value) { return 0; }\n","content_offset":0,"next_content_offset":51,"total_content_characters":51,"truncated":false,"content_sha256":"84cb647328ec52dad27d288f3a6127ff3e1ad87274ae2d227ad44daa49cbb2ed"},{"source":{"call_id":"call_dbec88442f9f43469ad0cef99c0534f6","invocation_id":"63495acd-4766-48d4-bc36-b79110443862","tool":"read_file","run_id":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","group_index":3,"group_sha256":"d042fe08ebaf067f482a99a21639272eefccf6b04591399eb6288e7c6baa5e9f","result_artifact_id":"7552c7bf-6105-4aa8-8cf4-99bcd6a73eab","result_sha256":"4cdaf349f368e66ecb05754fd3146c6b097426dee6f0d9b363480b79fbde897d","observed_at":"2026-11-03T22:56:07.678Z"},"observation":{"kind":"file","path":"src/report.mjs","sha256":"ba0a014e6e9df710d66e255a3a6f970f4e1c8af48accc81f33627029dcded7c0","start_line":1,"end_line":2,"offset":0,"next_offset":52,"range_start_line":1,"range_end_line":2,"total_characters":52,"next_start_line":null,"budget_limited":false},"content":"export function formatReport(groups) { return ''; }\n","content_offset":0,"next_content_offset":52,"total_content_characters":52,"truncated":false,"content_sha256":"ba0a014e6e9df710d66e255a3a6f970f4e1c8af48accc81f33627029dcded7c0"}]}
@@ -0,0 +1 @@
[{"role":"assistant","content":"我会先读取项目识别结果并按你指定的顺序封存 `test`、`build` 基线计划;随后读取九项测试及三个目标模块,依据实际契约准备完整改动提案。","tool_calls":[{"id":"call_5eb7405a2e6a4fb2bd2e2acf4d775dcb","type":"function","function":{"name":"inspect_project","arguments":"{}"}}]},{"role":"tool","tool_call_id":"call_5eb7405a2e6a4fb2bd2e2acf4d775dcb","content":"{\"projectId\":\"5e353edf-99cb-4fbd-aade-9d2c69caa7e9\",\"name\":\"owned-live-expense-report\",\"languages\":[\"JavaScript\"],\"packageManager\":\"npm\",\"scripts\":[{\"name\":\"test\",\"script\":\"node --test test/expense.test.mjs\",\"kind\":\"test\",\"framework\":\"node\",\"lifecycle\":[]},{\"name\":\"build\",\"script\":\"node scripts/build.mjs\",\"kind\":\"build\",\"framework\":null,\"lifecycle\":[]}],\"rules\":[],\"declarations\":{},\"entryPoints\":[],\"git\":{\"available\":true,\"head\":\"1832150638e0b6b3dfa3c4b0cd714e69819a417d\",\"branch\":\"main\",\"dirty\":true,\"status\":\"MM owner-staged.txt\\n M owner-unstaged.txt\\n?? owner-untracked.txt\\n\",\"statusSha256\":\"c37d286f0cb5f771a6c51831f1f8b5bcd903169e4f64fb4cd3b15cddeaa7eaa8\",\"complete\":true,\"contentFilters\":\"disabled-for-inspection\",\"submoduleWorktrees\":\"not-inspected\"},\"fingerprint\":\"b3ac594ca4c17cf9b0d9a3f3422a0f04b035cd96feec05c62cea42a69f0f8777\",\"sourceFingerprint\":\"2939702246bdddd91b3af4e235157165e2ed973f8ec3de00da62435e5e22638e\",\"inspectedAt\":\"2026-11-03T22:55:58.590Z\",\"scope\":{\"complete\":true,\"scannedFiles\":11,\"bytes\":3691,\"excludedFiles\":0,\"maximumFiles\":1000,\"maximumBytes\":16777216,\"note\":\"有界快照;Git工程遵循ignore并包含未跟踪源码,跳过依赖、链接和常见凭据路径。\"}}"}]
@@ -0,0 +1 @@
{"schemaVersion":1,"id":"d0afcd6a-edfb-41a8-8f8f-754ebbc4e2f3","sessionId":"5a1b39be-8096-46e6-bc43-156ca308f6f9","projectId":"5e353edf-99cb-4fbd-aade-9d2c69caa7e9","taskId":"94a78e50-df05-4176-b033-32de563a347c","runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","stepId":"c3f5dec8-26d1-4e6a-ae73-5d79d076c8da","requestIndex":5,"status":"prepared","createdAt":"2026-11-03T22:56:11.495Z","finishedAt":null,"requestSha256":"7730a738a187d49d7875c8bb37325e06d5c5f267585a734f356d9b3d8af05c26","requestBytes":35808,"estimatedInputTokens":12352,"requestArtifactId":"35298286-808e-42c5-81c1-723154e9ab03","tokenReservation":{"schemaVersion":1,"method":"observed-route-max-v1","overheadTokens":0,"reservedTokens":16087,"routes":[{"connectionId":"5b4daed9-b2f7-4de0-b949-573eba70c7b3","model":"gpt-6.1-sol","protocol":"chat-completions","endpoint":"https://jojocode.com/v1","localInputTokens":12352,"outputReservation":2048,"inputRatio":1.1365208796639485,"observedOutputTokens":2048,"observedTotalFloor":10086,"reservedTokens":16087,"sources":[{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"49d8a7e3-13f8-41b0-a336-f71267868e04","localInputTokens":8094,"reportedInputTokens":9199,"reportedOutputTokens":70,"totalTokens":9269},{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"9fa0fd0e-4434-498b-9691-156bd481d765","localInputTokens":9097,"reportedInputTokens":10065,"reportedOutputTokens":21,"totalTokens":10086},{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"2113b67b-6ea0-41de-8829-ed3a36820cd8","localInputTokens":10929,"reportedInputTokens":7539,"reportedOutputTokens":128,"totalTokens":7667},{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"6af65f19-5c39-4e8e-98c0-aead8dedafb2","localInputTokens":12218,"reportedInputTokens":8700,"reportedOutputTokens":82,"totalTokens":8782}]}]},"maxBudgetAttempts":3,"estimateMethod":"utf8-third-plus-framing-v1","beforeInputTokens":17043,"beforeBytes":49687,"budget":{"contextLimit":16000,"outputReservation":2048,"safetyTokens":1600,"inputBudget":12352,"targetInputTokens":12352,"runRemainingTokens":54196,"taskRemainingTokens":54196,"limitingReason":"context_limit"},"mandatoryInputTokens":10749,"nextReadFixedInputTokens":10272,"workingRetentionTokens":860,"workingRetentionPolicyVersion":1,"readBudgetPolicyVersion":2,"originalMessages":13,"retainedMessages":3,"archivedGroups":3,"retainedGroups":[0,4],"historyIndexArtifactId":"8c4fd7c0-ceef-42a3-91d3-4bf82c20b17b","historyIndexSha256":"9c5f4fb94c368ed336af8cb2b464af8d60fee083b30e723cbca6bc0ee6c518cd","actualUsage":null,"workingSetArtifactId":"e477b3db-b47b-4079-a760-c9e80ee48ec9","workingSetSha256":"99162fb5e73bc7fd267ae5cfd8257522273b2ab9f4923f3ceb57c67a39b3c2bf","workingSetEntries":4,"workingSetViewVersion":3,"latestToolsViewVersion":2,"latestToolsArtifactId":null,"latestToolsSha256":null,"latestToolsEntries":0,"projectMemoryArtifactId":null,"projectMemorySha256":null,"projectMemoryEntries":0,"skillCatalogArtifactId":null,"skillCatalogSha256":null,"skillCatalogEntries":0,"mcpCatalogArtifactId":null,"mcpCatalogSha256":null,"mcpCatalogEntries":0,"requestAttempts":0,"responseSha256":null,"source":"workbench"}
@@ -0,0 +1 @@
[{"role":"assistant","content":"","tool_calls":[{"id":"call_9109c8a1b5684a8fb410ab6207b477a8","type":"function","function":{"name":"read_file","arguments":"{\"path\":\"test/expense.test.mjs\",\"start_line\":1,\"end_line\":38,\"offset\":473,\"expected_sha256\":\"0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839\",\"limit\":8000}"}}]},{"role":"tool","tool_call_id":"call_9109c8a1b5684a8fb410ab6207b477a8","content":"{\"path\":\"test/expense.test.mjs\",\"start_line\":9,\"end_line\":31,\"total_lines\":38,\"content\":\"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 a\",\"sha256\":\"0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839\",\"bom\":false,\"truncated\":true,\"range_start_line\":1,\"range_end_line\":38,\"offset\":473,\"next_offset\":2089,\"total_characters\":2584,\"returned_characters\":1616,\"requested_offset\":473,\"next_start_line\":null,\"budget_limited\":true,\"maximum_message_bytes\":2202}"}]
@@ -0,0 +1 @@
{"id":"resp_0f6a71100813f9f4016aea667c06e887d0933167bbd9f2a798","object":"chat.completion","created":1793746558,"model":"gpt-6.1-sol","choices":[{"index":0,"message":{"role":"assistant","content":"我会先读取项目识别结果并按你指定的顺序封存 `test`、`build` 基线计划;随后读取九项测试及三个目标模块,依据实际契约准备完整改动提案。","tool_calls":[{"id":"call_5eb7405a2e6a4fb2bd2e2acf4d775dcb","type":"function","function":{"name":"inspect_project","arguments":"{}"}}]},"finish_reason":"tool_calls"}],"usage":{"prompt_tokens":9199,"completion_tokens":70,"total_tokens":9269},"service_tier":"default"}
@@ -0,0 +1 @@
{"schemaVersion":1,"id":"aeea5541-c7fa-485c-9e58-f0eb06da126f","sessionId":"5a1b39be-8096-46e6-bc43-156ca308f6f9","projectId":"5e353edf-99cb-4fbd-aade-9d2c69caa7e9","taskId":"94a78e50-df05-4176-b033-32de563a347c","runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","stepId":"18716612-05bd-47df-8bcc-c09621c0db2f","requestIndex":8,"status":"prepared","createdAt":"2026-11-03T22:56:29.079Z","finishedAt":null,"requestSha256":"4b055539bb7c2a63fe0a2b791baea54e18a976b45c853bcdf3548657e7098527","requestBytes":35808,"estimatedInputTokens":12352,"requestArtifactId":"fcd0e497-5cde-4052-a550-609d5a23f8cb","tokenReservation":{"schemaVersion":1,"method":"observed-route-max-v1","overheadTokens":0,"reservedTokens":16087,"routes":[{"connectionId":"5b4daed9-b2f7-4de0-b949-573eba70c7b3","model":"gpt-6.1-sol","protocol":"chat-completions","endpoint":"https://jojocode.com/v1","localInputTokens":12352,"outputReservation":2048,"inputRatio":1.1365208796639485,"observedOutputTokens":2048,"observedTotalFloor":10086,"reservedTokens":16087,"sources":[{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"49d8a7e3-13f8-41b0-a336-f71267868e04","localInputTokens":8094,"reportedInputTokens":9199,"reportedOutputTokens":70,"totalTokens":9269},{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"9fa0fd0e-4434-498b-9691-156bd481d765","localInputTokens":9097,"reportedInputTokens":10065,"reportedOutputTokens":21,"totalTokens":10086},{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"2113b67b-6ea0-41de-8829-ed3a36820cd8","localInputTokens":10929,"reportedInputTokens":7539,"reportedOutputTokens":128,"totalTokens":7667},{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"6af65f19-5c39-4e8e-98c0-aead8dedafb2","localInputTokens":12218,"reportedInputTokens":8700,"reportedOutputTokens":82,"totalTokens":8782},{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"51cc7d6d-5f0b-4085-a373-609c4c4ea32c","localInputTokens":12352,"reportedInputTokens":8843,"reportedOutputTokens":197,"totalTokens":9040},{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"d537d370-bbf0-45d6-876a-33a2cd25ecce","localInputTokens":12352,"reportedInputTokens":8852,"reportedOutputTokens":245,"totalTokens":9097},{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"4d4dcebd-d944-47d9-9c23-494ede9d6f77","localInputTokens":12274,"reportedInputTokens":8703,"reportedOutputTokens":103,"totalTokens":8806}]}]},"maxBudgetAttempts":1,"estimateMethod":"utf8-third-plus-framing-v1","beforeInputTokens":19915,"beforeBytes":58063,"budget":{"contextLimit":16000,"outputReservation":2048,"safetyTokens":1600,"inputBudget":12352,"targetInputTokens":12352,"runRemainingTokens":27253,"taskRemainingTokens":27253,"limitingReason":"context_limit"},"mandatoryInputTokens":10674,"nextReadFixedInputTokens":10339,"workingRetentionTokens":1040,"workingRetentionPolicyVersion":1,"readBudgetPolicyVersion":2,"originalMessages":23,"retainedMessages":3,"archivedGroups":6,"retainedGroups":[0,7],"historyIndexArtifactId":"08f0e4b1-de8b-40a9-9e26-dda83ba72bb2","historyIndexSha256":"e95201937e18ae705b22d566431aeefe59e5762aa4d5655d548766cb3cc25a28","actualUsage":null,"workingSetArtifactId":"19bcd5c5-30b2-4477-ae37-71fad2d55fc0","workingSetSha256":"4dda4ce135f99ae4b2d5bd3e29e4dc9fd5915cce0d3b0614e9c474cbb9c7a558","workingSetEntries":5,"workingSetViewVersion":3,"latestToolsViewVersion":2,"latestToolsArtifactId":null,"latestToolsSha256":null,"latestToolsEntries":0,"projectMemoryArtifactId":null,"projectMemorySha256":null,"projectMemoryEntries":0,"skillCatalogArtifactId":null,"skillCatalogSha256":null,"skillCatalogEntries":0,"mcpCatalogArtifactId":null,"mcpCatalogSha256":null,"mcpCatalogEntries":0,"requestAttempts":0,"responseSha256":null,"source":"workbench"}
@@ -0,0 +1 @@
{"path":"src/amount.mjs","start_line":1,"end_line":2,"total_lines":2,"content":"export function amountToCents(value) { return 0; }\n","sha256":"84cb647328ec52dad27d288f3a6127ff3e1ad87274ae2d227ad44daa49cbb2ed","bom":false,"truncated":false,"range_start_line":1,"range_end_line":2,"offset":0,"next_offset":51,"total_characters":51,"returned_characters":51,"requested_offset":0,"next_start_line":null,"budget_limited":false,"maximum_message_bytes":1024}
@@ -0,0 +1 @@
{"schemaVersion":1,"kind":"task-working-set","sessionId":"5a1b39be-8096-46e6-bc43-156ca308f6f9","projectId":"5e353edf-99cb-4fbd-aade-9d2c69caa7e9","taskId":"94a78e50-df05-4176-b033-32de563a347c","semantics":"recorded-tool-observations; file hashes identify observed revisions, not current filesystem guarantees","observationVersion":2,"entries":[{"source":{"call_id":"call_7ca0aaf713a34fb6b06af412a0806774","invocation_id":"b6f3cc9a-ae45-4a49-b79a-b71e2c55c221","tool":"read_file","run_id":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","group_index":3,"group_sha256":"d042fe08ebaf067f482a99a21639272eefccf6b04591399eb6288e7c6baa5e9f","result_artifact_id":"2ca4b27b-8766-4441-8d47-b11ee786eda1","result_sha256":"08b6595803497876c0745e6f72fab5d5a5233864e2f6447608b51adc2b7ddcf1","observed_at":"2026-11-03T22:56:07.627Z"},"observation":{"kind":"file","path":"src/amount.mjs","sha256":"84cb647328ec52dad27d288f3a6127ff3e1ad87274ae2d227ad44daa49cbb2ed","start_line":1,"end_line":2,"offset":0,"next_offset":51,"range_start_line":1,"range_end_line":2,"total_characters":51,"next_start_line":null,"budget_limited":false},"content":"export function amountToCents(value) { return 0; }\n","content_offset":0,"next_content_offset":51,"total_content_characters":51,"truncated":false,"content_sha256":"84cb647328ec52dad27d288f3a6127ff3e1ad87274ae2d227ad44daa49cbb2ed"},{"source":{"call_id":"call_dbec88442f9f43469ad0cef99c0534f6","invocation_id":"63495acd-4766-48d4-bc36-b79110443862","tool":"read_file","run_id":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","group_index":3,"group_sha256":"d042fe08ebaf067f482a99a21639272eefccf6b04591399eb6288e7c6baa5e9f","result_artifact_id":"7552c7bf-6105-4aa8-8cf4-99bcd6a73eab","result_sha256":"4cdaf349f368e66ecb05754fd3146c6b097426dee6f0d9b363480b79fbde897d","observed_at":"2026-11-03T22:56:07.678Z"},"observation":{"kind":"file","path":"src/report.mjs","sha256":"ba0a014e6e9df710d66e255a3a6f970f4e1c8af48accc81f33627029dcded7c0","start_line":1,"end_line":2,"offset":0,"next_offset":52,"range_start_line":1,"range_end_line":2,"total_characters":52,"next_start_line":null,"budget_limited":false},"content":"export function formatReport(groups) { return ''; }\n","content_offset":0,"next_content_offset":52,"total_content_characters":52,"truncated":false,"content_sha256":"ba0a014e6e9df710d66e255a3a6f970f4e1c8af48accc81f33627029dcded7c0"},{"source":{"call_id":"call_bba7c0bbdc874767a61a735efda0f601","invocation_id":"d64060a8-adc2-464c-a1f2-9884f699cc40","tool":"read_file","run_id":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","group_index":3,"group_sha256":"d042fe08ebaf067f482a99a21639272eefccf6b04591399eb6288e7c6baa5e9f","result_artifact_id":"de6e8e19-61e9-461c-83a0-11cfbc4a2785","result_sha256":"17ea0f01e00d78ced1813dd906e6ef4b14de864d14467d17538674fda3be87af","observed_at":"2026-11-03T22:56:07.643Z"},"observation":{"kind":"file","path":"src/summary.mjs","sha256":"48829850c11ca0cd0ab5e86bbac69a0c5f90297292168c1ba6dc338e2eae6ee7","start_line":1,"end_line":3,"offset":0,"next_offset":93,"range_start_line":1,"range_end_line":3,"total_characters":93,"next_start_line":null,"budget_limited":false},"content":"import { amountToCents } from './amount.mjs';\nexport function summarize(rows) { return []; }\n","content_offset":0,"next_content_offset":93,"total_content_characters":93,"truncated":false,"content_sha256":"48829850c11ca0cd0ab5e86bbac69a0c5f90297292168c1ba6dc338e2eae6ee7"},{"source":{"call_id":"call_9109c8a1b5684a8fb410ab6207b477a8","invocation_id":"90da55f2-2e70-4984-83a1-8f91db24413e","tool":"read_file","run_id":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","group_index":4,"group_sha256":"08d7613bf0977a1b6fbd18fb2be59c30b118e1d2291c3c20e16dec92ad0791df","result_artifact_id":"e067ec0a-3880-434d-9d8c-4654b27792f0","result_sha256":"497f99d674ace6cd47659d7e4ef1e45da6dc00aa07648c43abcaa18a744d657f","observed_at":"2026-11-03T22:56:11.462Z"},"observation":{"kind":"file","path":"test/expense.test.mjs","sha256":"0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839","start_line":9,"end_line":31,"offset":473,"next_offset":2089,"range_start_line":1,"range_end_line":38,"total_characters":2584,"next_start_line":null,"budget_limited":true},"content":"decimal numbers use the same cents contract',()=>{\n for(const [input,expected] of [[0,0],[1.01,101],[2.5,250],[-4.32,-4","content_offset":0,"next_content_offset":120,"total_content_characters":1616,"truncated":true,"content_sha256":"9dea55f5c55ef8a741000747bc2650d085b19d6ed04229cf8f4d732aa12453b4"}]}
@@ -0,0 +1,5 @@
> build
> node scripts/build.mjs
All three business modules compile.
@@ -0,0 +1 @@
{"schemaVersion":1,"id":"e563a13e-55c7-4383-8206-558095402968","sessionId":"5a1b39be-8096-46e6-bc43-156ca308f6f9","projectId":"5e353edf-99cb-4fbd-aade-9d2c69caa7e9","taskId":"94a78e50-df05-4176-b033-32de563a347c","runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","stepId":"9d21d47c-96ce-4dec-a72d-2a3d1227347b","requestIndex":2,"status":"prepared","createdAt":"2026-11-03T22:55:58.607Z","finishedAt":null,"requestSha256":"205f0b4873ba4dfdd160cc8ad89d926448c571bf4e7d7ae4a3e85e6c217f1e48","requestBytes":26090,"estimatedInputTokens":9097,"requestArtifactId":"69c87dee-45a9-4e4b-871a-1807275192f1","tokenReservation":{"schemaVersion":1,"method":"observed-route-max-v1","overheadTokens":0,"reservedTokens":12387,"routes":[{"connectionId":"5b4daed9-b2f7-4de0-b949-573eba70c7b3","model":"gpt-6.1-sol","protocol":"chat-completions","endpoint":"https://jojocode.com/v1","localInputTokens":9097,"outputReservation":2048,"inputRatio":1.1365208796639485,"observedOutputTokens":2048,"observedTotalFloor":9269,"reservedTokens":12387,"sources":[{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"49d8a7e3-13f8-41b0-a336-f71267868e04","localInputTokens":8094,"reportedInputTokens":9199,"reportedOutputTokens":70,"totalTokens":9269}]}]},"maxBudgetAttempts":6,"estimateMethod":"utf8-third-plus-framing-v1","beforeInputTokens":9097,"beforeBytes":26090,"budget":{"contextLimit":16000,"outputReservation":2048,"safetyTokens":1600,"inputBudget":12352,"targetInputTokens":12352,"runRemainingTokens":80731,"taskRemainingTokens":80731,"limitingReason":"context_limit"},"mandatoryInputTokens":9119,"nextReadFixedInputTokens":8784,"workingRetentionTokens":0,"workingRetentionPolicyVersion":1,"readBudgetPolicyVersion":2,"originalMessages":3,"retainedMessages":3,"archivedGroups":0,"retainedGroups":[0,1],"historyIndexArtifactId":null,"historyIndexSha256":null,"actualUsage":null,"workingSetArtifactId":null,"workingSetSha256":null,"workingSetEntries":0,"workingSetViewVersion":3,"latestToolsViewVersion":2,"latestToolsArtifactId":null,"latestToolsSha256":null,"latestToolsEntries":0,"projectMemoryArtifactId":null,"projectMemorySha256":null,"projectMemoryEntries":0,"skillCatalogArtifactId":null,"skillCatalogSha256":null,"skillCatalogEntries":0,"mcpCatalogArtifactId":null,"mcpCatalogSha256":null,"mcpCatalogEntries":0,"requestAttempts":0,"responseSha256":null,"source":"workbench"}
@@ -0,0 +1 @@
{"path":"test/expense.test.mjs","start_line":1,"end_line":9,"total_lines":38,"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","sha256":"0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839","bom":false,"truncated":true,"range_start_line":1,"range_end_line":38,"offset":0,"next_offset":472,"total_characters":2584,"returned_characters":472,"requested_offset":0,"next_start_line":null,"budget_limited":true,"maximum_message_bytes":1024}
@@ -0,0 +1 @@
[{"role":"assistant","content":"","tool_calls":[{"id":"call_57212dc2ff0243b194fcfeefdfd9f2c4","type":"function","function":{"name":"read_artifact","arguments":"{\"artifact_id\": \"e067ec0a-3880-434d-9d8c-4654b27792f0\", \"offset\": 0, \"limit\": 12000}"}},{"id":"call_e61d3ad7c20f44b1a3f116facf75fc62","type":"function","function":{"name":"read_artifact","arguments":"{\"artifact_id\": \"f1bf75d1-04d2-40de-a099-8efd552e4063\", \"limit\": 14000}"}},{"id":"call_966fb39a5e9748bf954060b889c2cdbb","type":"function","function":{"name":"inspect_task_plan","arguments":"{}"}},{"id":"call_2ec85fda70e440f99faf760cd0b062d7","type":"function","function":{"name":"read_file","arguments":"{\"path\": \"test/expense.test.mjs\", \"start_line\": 1, \"end_line\": 38, \"offset\": 2557, \"expected_sha256\": \"0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839\", \"limit\": 1000}"}}]},{"role":"tool","tool_call_id":"call_57212dc2ff0243b194fcfeefdfd9f2c4","content":"{\"artifact_id\":\"e067ec0a-3880-434d-9d8c-4654b27792f0\",\"kind\":\"tool-result\",\"sha256\":\"497f99d674ace6cd47659d7e4ef1e45da6dc00aa07648c43abcaa18a744d657f\",\"content\":\"{\\\"path\\\":\\\"test/expense.test.mjs\\\",\\\"start_line\\\":9,\\\"end_line\\\":31,\\\"total_lines\\\":38,\\\"content\\\":\\\"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(inp\",\"offset\":0,\"next_offset\":500,\"returned_characters\":500,\"total_characters\":2055,\"truncated\":true,\"requested_offset\":0,\"requested_limit\":12000,\"budget_limited\":true,\"maximum_message_bytes\":1024}"},{"role":"tool","tool_call_id":"call_e61d3ad7c20f44b1a3f116facf75fc62","content":"{\"artifact_id\":\"f1bf75d1-04d2-40de-a099-8efd552e4063\",\"kind\":\"context-group\",\"sha256\":\"d042fe08ebaf067f482a99a21639272eefccf6b04591399eb6288e7c6baa5e9f\",\"content\":\"[{\\\"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\\\\\\\"}\\\"\",\"offset\":0,\"next_offset\":362,\"returned_characters\":362,\"total_characters\":13197,\"truncated\":true,\"requested_offset\":0,\"requested_limit\":14000,\"budget_limited\":true,\"maximum_message_bytes\":1024}"},{"role":"tool","tool_call_id":"call_966fb39a5e9748bf954060b889c2cdbb","content":"{\"configured\":false,\"task_id\":\"94a78e50-df05-4176-b033-32de563a347c\",\"revision\":0,\"status\":\"not_planned\",\"steps\":[],\"all_verified\":false,\"binding_sha256\":null}"},{"role":"tool","tool_call_id":"call_2ec85fda70e440f99faf760cd0b062d7","content":"{\"path\":\"test/expense.test.mjs\",\"start_line\":36,\"end_line\":38,\"total_lines\":38,\"content\":\" (1)\\\\nUSD -0.01 (2)');\\n});\\n\",\"sha256\":\"0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839\",\"bom\":false,\"truncated\":true,\"range_start_line\":1,\"range_end_line\":38,\"offset\":2557,\"next_offset\":2584,\"total_characters\":2584,\"returned_characters\":27,\"requested_offset\":2557,\"next_start_line\":null,\"budget_limited\":false,\"maximum_message_bytes\":1024}"}]
@@ -0,0 +1 @@
{"artifact_id":"e067ec0a-3880-434d-9d8c-4654b27792f0","kind":"tool-result","sha256":"497f99d674ace6cd47659d7e4ef1e45da6dc00aa07648c43abcaa18a744d657f","content":"{\"path\":\"test/expense.test.mjs\",\"start_line\":9,\"end_line\":31,\"total_lines\":38,\"content\":\"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(inp","offset":0,"next_offset":500,"returned_characters":500,"total_characters":2055,"truncated":true,"requested_offset":0,"requested_limit":12000,"budget_limited":true,"maximum_message_bytes":1024}
@@ -0,0 +1 @@
{"id":"resp_0cffdfb8f97b8748016aea6688610087d2a59d73f1056a3798","object":"chat.completion","created":1793746571,"model":"gpt-6.1-sol","choices":[{"index":0,"message":{"role":"assistant","tool_calls":[{"id":"call_9109c8a1b5684a8fb410ab6207b477a8","type":"function","function":{"name":"read_file","arguments":"{\"path\":\"test/expense.test.mjs\",\"start_line\":1,\"end_line\":38,\"offset\":473,\"expected_sha256\":\"0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839\",\"limit\":8000}"}}]},"finish_reason":"tool_calls"}],"usage":{"prompt_tokens":8700,"completion_tokens":82,"total_tokens":8782},"service_tier":"default"}
@@ -0,0 +1 @@
{"projectId":"5e353edf-99cb-4fbd-aade-9d2c69caa7e9","name":"owned-live-expense-report","languages":["JavaScript"],"packageManager":"npm","scripts":[{"name":"test","script":"node --test test/expense.test.mjs","kind":"test","framework":"node","lifecycle":[]},{"name":"build","script":"node scripts/build.mjs","kind":"build","framework":null,"lifecycle":[]}],"rules":[],"declarations":{},"entryPoints":[],"git":{"available":true,"head":"1832150638e0b6b3dfa3c4b0cd714e69819a417d","branch":"main","dirty":true,"status":"MM owner-staged.txt\n M owner-unstaged.txt\n?? owner-untracked.txt\n","statusSha256":"c37d286f0cb5f771a6c51831f1f8b5bcd903169e4f64fb4cd3b15cddeaa7eaa8","complete":true,"contentFilters":"disabled-for-inspection","submoduleWorktrees":"not-inspected"},"fingerprint":"b3ac594ca4c17cf9b0d9a3f3422a0f04b035cd96feec05c62cea42a69f0f8777","sourceFingerprint":"2939702246bdddd91b3af4e235157165e2ed973f8ec3de00da62435e5e22638e","inspectedAt":"2026-11-03T22:55:58.590Z","scope":{"complete":true,"scannedFiles":11,"bytes":3691,"excludedFiles":0,"maximumFiles":1000,"maximumBytes":16777216,"note":"有界快照;Git工程遵循ignore并包含未跟踪源码,跳过依赖、链接和常见凭据路径。"}}
@@ -0,0 +1 @@
{"id":"resp_059dc60673f2930b016aea667fa18c87d0bdebc2e3ca0b4663","object":"chat.completion","created":1793746560,"model":"gpt-6.1-sol","choices":[{"index":0,"message":{"role":"assistant","tool_calls":[{"id":"call_56fb7fe30f7a48c0a466eedca7cb1c33","type":"function","function":{"name":"plan_checks","arguments":"{\"names\":[\"test\",\"build\"]}"}}]},"finish_reason":"tool_calls"}],"usage":{"prompt_tokens":10065,"completion_tokens":21,"total_tokens":10086},"service_tier":"default"}
@@ -0,0 +1 @@
{"path":"src/report.mjs","start_line":1,"end_line":2,"total_lines":2,"content":"export function formatReport(groups) { return ''; }\n","sha256":"ba0a014e6e9df710d66e255a3a6f970f4e1c8af48accc81f33627029dcded7c0","bom":false,"truncated":false,"range_start_line":1,"range_end_line":2,"offset":0,"next_offset":52,"total_characters":52,"returned_characters":52,"requested_offset":0,"next_start_line":null,"budget_limited":false,"maximum_message_bytes":1024}
@@ -0,0 +1 @@
{"id":"resp_000e24a5432ebb85016aea669e061087d2b99808b45aea919a","object":"chat.completion","created":1793746590,"model":"gpt-6.1-sol","choices":[{"index":0,"message":{"role":"assistant","tool_calls":[{"id":"call_bc1bccc7a3e547a0b59c2c40584d4a9f","type":"function","function":{"name":"plan_checks","arguments":"{\"names\":[\"test\",\"build\"]}"}}]},"finish_reason":"tool_calls"}],"usage":{"prompt_tokens":13294,"completion_tokens":21,"total_tokens":13315},"service_tier":"default"}
@@ -0,0 +1 @@
{"id":"resp_007fde9abaa759cc016aea6698a59087d191a6a4aabc860643","object":"chat.completion","created":1793746588,"model":"gpt-6.1-sol","choices":[{"index":0,"message":{"role":"assistant","tool_calls":[{"id":"call_29a4d20351e94a769b162e0faef94db9","type":"function","function":{"name":"inspect_project","arguments":"{}"}}]},"finish_reason":"tool_calls"}],"usage":{"prompt_tokens":8703,"completion_tokens":103,"total_tokens":8806,"completion_tokens_details":{"reasoning_tokens":87}},"service_tier":"default"}
@@ -0,0 +1 @@
{"schemaVersion":1,"id":"925b963a-7530-4a76-a4e0-79f05b9edad9","sessionId":"5a1b39be-8096-46e6-bc43-156ca308f6f9","projectId":"5e353edf-99cb-4fbd-aade-9d2c69caa7e9","taskId":"94a78e50-df05-4176-b033-32de563a347c","runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","stepId":"00456a87-97bf-4158-b9b3-4560f701e152","requestIndex":3,"status":"prepared","createdAt":"2026-11-03T22:56:00.991Z","finishedAt":null,"requestSha256":"657d7d990d3ab49b3e49d3bd979acd845a755f58c65f026cdc4ac078010e8842","requestBytes":31537,"estimatedInputTokens":10929,"requestArtifactId":"51923962-5021-4291-961c-89f12ea8bad4","tokenReservation":{"schemaVersion":1,"method":"observed-route-max-v1","overheadTokens":0,"reservedTokens":14470,"routes":[{"connectionId":"5b4daed9-b2f7-4de0-b949-573eba70c7b3","model":"gpt-6.1-sol","protocol":"chat-completions","endpoint":"https://jojocode.com/v1","localInputTokens":10929,"outputReservation":2048,"inputRatio":1.1365208796639485,"observedOutputTokens":2048,"observedTotalFloor":10086,"reservedTokens":14470,"sources":[{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"49d8a7e3-13f8-41b0-a336-f71267868e04","localInputTokens":8094,"reportedInputTokens":9199,"reportedOutputTokens":70,"totalTokens":9269},{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"9fa0fd0e-4434-498b-9691-156bd481d765","localInputTokens":9097,"reportedInputTokens":10065,"reportedOutputTokens":21,"totalTokens":10086}]}]},"maxBudgetAttempts":4,"estimateMethod":"utf8-third-plus-framing-v1","beforeInputTokens":10929,"beforeBytes":31537,"budget":{"contextLimit":16000,"outputReservation":2048,"safetyTokens":1600,"inputBudget":12352,"targetInputTokens":12352,"runRemainingTokens":70645,"taskRemainingTokens":70645,"limitingReason":"context_limit"},"mandatoryInputTokens":9825,"nextReadFixedInputTokens":9229,"workingRetentionTokens":0,"workingRetentionPolicyVersion":1,"readBudgetPolicyVersion":2,"originalMessages":5,"retainedMessages":5,"archivedGroups":0,"retainedGroups":[0,1,2],"historyIndexArtifactId":null,"historyIndexSha256":null,"actualUsage":null,"workingSetArtifactId":null,"workingSetSha256":null,"workingSetEntries":0,"workingSetViewVersion":3,"latestToolsViewVersion":2,"latestToolsArtifactId":null,"latestToolsSha256":null,"latestToolsEntries":0,"projectMemoryArtifactId":null,"projectMemorySha256":null,"projectMemoryEntries":0,"skillCatalogArtifactId":null,"skillCatalogSha256":null,"skillCatalogEntries":0,"mcpCatalogArtifactId":null,"mcpCatalogSha256":null,"mcpCatalogEntries":0,"requestAttempts":0,"responseSha256":null,"source":"workbench"}
@@ -0,0 +1 @@
{"path":"test/expense.test.mjs","start_line":31,"end_line":36,"total_lines":38,"content":"ssert.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","sha256":"0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839","bom":false,"truncated":true,"range_start_line":1,"range_end_line":38,"offset":2089,"next_offset":2557,"total_characters":2584,"returned_characters":468,"requested_offset":2089,"next_start_line":null,"budget_limited":true,"maximum_message_bytes":1025}
@@ -0,0 +1 @@
{"configured":false,"task_id":"94a78e50-df05-4176-b033-32de563a347c","revision":0,"status":"not_planned","steps":[],"all_verified":false,"binding_sha256":null}
@@ -0,0 +1 @@
{"id":"resp_0404a77114077af2016aea668c296c87d2b16c08c2a8d817ea","object":"chat.completion","created":1793746576,"model":"gpt-6.1-sol","choices":[{"index":0,"message":{"role":"assistant","tool_calls":[{"id":"call_215bba984b9245968aec38955fd8aa2f","type":"function","function":{"name":"read_file","arguments":"{\"path\": \"test/expense.test.mjs\", \"start_line\": 1, \"end_line\": 38, \"offset\": 0, \"expected_sha256\": \"0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839\", \"limit\": 473}"}},{"id":"call_39c508f5777e479fb58b9e65aef37894","type":"function","function":{"name":"read_file","arguments":"{\"path\": \"test/expense.test.mjs\", \"start_line\": 1, \"end_line\": 38, \"offset\": 2089, \"expected_sha256\": \"0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839\", \"limit\": 1000}"}}]},"finish_reason":"tool_calls"}],"usage":{"prompt_tokens":8843,"completion_tokens":197,"total_tokens":9040,"completion_tokens_details":{"reasoning_tokens":19}},"service_tier":"default"}
@@ -0,0 +1 @@
{"projectId":"5e353edf-99cb-4fbd-aade-9d2c69caa7e9","name":"owned-live-expense-report","languages":["JavaScript"],"packageManager":"npm","scripts":[{"name":"test","script":"node --test test/expense.test.mjs","kind":"test","framework":"node","lifecycle":[]},{"name":"build","script":"node scripts/build.mjs","kind":"build","framework":null,"lifecycle":[]}],"rules":[],"declarations":{},"entryPoints":[],"git":{"available":true,"head":"1832150638e0b6b3dfa3c4b0cd714e69819a417d","branch":"main","dirty":true,"status":"MM owner-staged.txt\n M owner-unstaged.txt\n?? owner-untracked.txt\n","statusSha256":"c37d286f0cb5f771a6c51831f1f8b5bcd903169e4f64fb4cd3b15cddeaa7eaa8","complete":true,"contentFilters":"disabled-for-inspection","submoduleWorktrees":"not-inspected"},"fingerprint":"b3ac594ca4c17cf9b0d9a3f3422a0f04b035cd96feec05c62cea42a69f0f8777","sourceFingerprint":"2939702246bdddd91b3af4e235157165e2ed973f8ec3de00da62435e5e22638e","inspectedAt":"2026-11-03T22:56:31.260Z","scope":{"complete":true,"scannedFiles":11,"bytes":3691,"excludedFiles":0,"maximumFiles":1000,"maximumBytes":16777216,"note":"有界快照;Git工程遵循ignore并包含未跟踪源码,跳过依赖、链接和常见凭据路径。"}}
@@ -0,0 +1 @@
{"id":"1c46ffc1-3b24-4fb8-b207-3305ccd14fd1","sessionId":"5a1b39be-8096-46e6-bc43-156ca308f6f9","projectId":"5e353edf-99cb-4fbd-aade-9d2c69caa7e9","taskId":"94a78e50-df05-4176-b033-32de563a347c","runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","status":"planned","createdAt":"2026-11-03T22:56:00.882Z","fingerprint":"b3ac594ca4c17cf9b0d9a3f3422a0f04b035cd96feec05c62cea42a69f0f8777","sourceFingerprint":"2939702246bdddd91b3af4e235157165e2ed973f8ec3de00da62435e5e22638e","project":{"projectId":"5e353edf-99cb-4fbd-aade-9d2c69caa7e9","name":"owned-live-expense-report","languages":["JavaScript"],"packageManager":"npm","scripts":[{"name":"test","script":"node --test test/expense.test.mjs","kind":"test","framework":"node","lifecycle":[]},{"name":"build","script":"node scripts/build.mjs","kind":"build","framework":null,"lifecycle":[]}],"rules":[],"declarations":{},"entryPoints":[],"git":{"available":true,"head":"1832150638e0b6b3dfa3c4b0cd714e69819a417d","branch":"main","dirty":true,"status":"MM owner-staged.txt\n M owner-unstaged.txt\n?? owner-untracked.txt\n","statusSha256":"c37d286f0cb5f771a6c51831f1f8b5bcd903169e4f64fb4cd3b15cddeaa7eaa8","complete":true,"contentFilters":"disabled-for-inspection","submoduleWorktrees":"not-inspected"},"fingerprint":"b3ac594ca4c17cf9b0d9a3f3422a0f04b035cd96feec05c62cea42a69f0f8777","sourceFingerprint":"2939702246bdddd91b3af4e235157165e2ed973f8ec3de00da62435e5e22638e","inspectedAt":"2026-11-03T22:56:00.880Z","scope":{"complete":true,"scannedFiles":11,"bytes":3691,"excludedFiles":0,"maximumFiles":1000,"maximumBytes":16777216,"note":"有界快照;Git工程遵循ignore并包含未跟踪源码,跳过依赖、链接和常见凭据路径。"}},"artifactId":"e7ba7f05-6868-42cf-9df7-2a8a53834b9c","checks":[{"id":"8cd27985-2e14-4310-bce1-e5c2d45a3e48","name":"test","script":"node --test test/expense.test.mjs","kind":"test","framework":"node","lifecycle":[],"command":"npm run test"},{"id":"2db3b463-f934-473e-9b18-f5836d2eb838","name":"build","script":"node scripts/build.mjs","kind":"build","framework":null,"lifecycle":[],"command":"npm run build"}],"environment":{"kind":"node","identity":"e6bb96bf7b30e2d7d8f075df02654f685543fbade9b56cc245f3030248f82735","dependencyInputs":"5fd535fc8dbf59ebd0cf7f974775ebb86c47c0b3bf779ce3ec404bcaec3b3092","status":"ready","installed":{"status":"missing","files":0,"bytes":0,"sha256":null},"declarations":[{"path":"D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-t\\node\\expense-project\\package.json","sha256":"6ad63026b2fe9de7513a4f6704c372a86108ee3d018a1f04883dc0a409ea4c24","bytes":188}],"runtime":{"status":"available","node":{"path":"D:\\Ai-project\\REA逆向\\Agent-Workbench\\releases\\Agent-Workbench-1.14.0-win-x64-20261030235440461\\runtime\\node.exe","sha256":"d702daa815eabbff763c7d3808e235cf031cf2ca70211b56847bc72f51e240e5","bytes":93915464,"version":"v24.22.1"},"npm":{"path":"C:\\Users\\wangy\\AppData\\Local\\Programs\\AgentWorkbench\\versions\\Agent-Workbench-1.24.7-win-x64-20261103164618190\\runtime\\node_modules\\npm\\bin\\npm-cli.js","sha256":"3ce7cba6f5128dd5f54c98b6a5036b0f850496878cc2e21044b675fe3c594e3e","bytes":56,"version":"11.19.1","manifest":{"path":"C:\\Users\\wangy\\AppData\\Local\\Programs\\AgentWorkbench\\versions\\Agent-Workbench-1.24.7-win-x64-20261103164618190\\runtime\\node_modules\\npm\\package.json","sha256":"d5b859b88af16e893fbc2d28819db601a8543b241f8c80459f70898be2777c12","bytes":6856}}},"preparation":null},"contractArtifactId":"d24bde2e-72c7-4d5b-967c-389355d90314","contractSha256":"4ae07068a701d69faf182484730627624f74a4c6968f36a86e76d9a88fb47d41"}
@@ -0,0 +1,235 @@
> test
> node --test test/expense.test.mjs
✖ decimal strings become exact cents including zero and refunds (0.8548ms)
✖ finite decimal numbers use the same cents contract (0.1441ms)
✖ malformed overprecision nonfinite and unsafe amounts are rejected (0.1584ms)
✖ independent currencies are sorted and summed without floating point loss (0.6728ms)
✖ refunds cancel totals while counting every original record (0.1617ms)
✖ summarizing retains caller rows and handles an empty list (0.1386ms)
✖ invalid rows currency and unsafe aggregate totals are rejected (0.0938ms)
✖ reports use two decimals and render negative subunit amounts (0.1447ms)
✖ complete expense flow preserves exact decimal sums (0.1179ms)
ℹ tests 9
ℹ suites 0
ℹ pass 0
ℹ fail 9
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 61.8439
✖ failing tests:
test at test\expense.test.mjs:6:1
✖ decimal strings become exact cents including zero and refunds (0.8548ms)
AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
0 !== 1234
at TestContext.<anonymous> (file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/.qa/live-delivery-t/node/expense-project/test/expense.test.mjs:7:124)
at Test.runInAsyncScope (node:async_hooks:227:14)
at Test.run (node:internal/test_runner/test:1402:25)
at Test.start (node:internal/test_runner/test:1262:17)
at startSubtestAfterBootstrap (node:internal/test_runner/harness:387:17) {
generatedMessage: true,
code: 'ERR_ASSERTION',
actual: 0,
expected: 1234,
operator: 'strictEqual',
diff: 'simple'
}
test at test\expense.test.mjs:9:1
✖ finite decimal numbers use the same cents contract (0.1441ms)
AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
0 !== 101
at TestContext.<anonymous> (file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/.qa/live-delivery-t/node/expense-project/test/expense.test.mjs:10:83)
at Test.runInAsyncScope (node:async_hooks:227:14)
at Test.run (node:internal/test_runner/test:1402:25)
at Test.processPendingSubtests (node:internal/test_runner/test:974:18)
at Test.postRun (node:internal/test_runner/test:1542:19)
at Test.run (node:internal/test_runner/test:1467:12)
at async startSubtestAfterBootstrap (node:internal/test_runner/harness:387:3) {
generatedMessage: true,
code: 'ERR_ASSERTION',
actual: 0,
expected: 101,
operator: 'strictEqual',
diff: 'simple'
}
test at test\expense.test.mjs:12:1
✖ malformed overprecision nonfinite and unsafe amounts are rejected (0.1584ms)
AssertionError [ERR_ASSERTION]: Missing expected exception (TypeError).
at TestContext.<anonymous> (file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/.qa/live-delivery-t/node/expense-project/test/expense.test.mjs:13:126)
at Test.runInAsyncScope (node:async_hooks:227:14)
at Test.run (node:internal/test_runner/test:1402:25)
at Test.processPendingSubtests (node:internal/test_runner/test:974:18)
at Test.postRun (node:internal/test_runner/test:1542:19)
at Test.run (node:internal/test_runner/test:1467:12)
at async Test.processPendingSubtests (node:internal/test_runner/test:974:7) {
generatedMessage: false,
code: 'ERR_ASSERTION',
actual: undefined,
operator: 'throws',
diff: 'simple'
}
test at test\expense.test.mjs:15:1
✖ independent currencies are sorted and summed without floating point loss (0.6728ms)
AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
+ actual - expected
+ []
- [
- {
- cents: 300,
- count: 1,
- currency: 'CNY'
- },
- {
- cents: 30,
- count: 2,
- currency: 'USD'
- }
- ]
at TestContext.<anonymous> (file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/.qa/live-delivery-t/node/expense-project/test/expense.test.mjs:16:10)
at Test.runInAsyncScope (node:async_hooks:227:14)
at Test.run (node:internal/test_runner/test:1402:25)
at Test.processPendingSubtests (node:internal/test_runner/test:974:18)
at Test.postRun (node:internal/test_runner/test:1542:19)
at Test.run (node:internal/test_runner/test:1467:12)
at async Test.processPendingSubtests (node:internal/test_runner/test:974:7) {
generatedMessage: true,
code: 'ERR_ASSERTION',
actual: [],
expected: [ { currency: 'CNY', cents: 300, count: 1 }, { currency: 'USD', cents: 30, count: 2 } ],
operator: 'deepStrictEqual',
diff: 'simple'
}
test at test\expense.test.mjs:19:1
✖ refunds cancel totals while counting every original record (0.1617ms)
AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
+ actual - expected
+ []
- [
- {
- cents: 0,
- count: 2,
- currency: 'EUR'
- }
- ]
at TestContext.<anonymous> (file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/.qa/live-delivery-t/node/expense-project/test/expense.test.mjs:20:10)
at Test.runInAsyncScope (node:async_hooks:227:14)
at Test.run (node:internal/test_runner/test:1402:25)
at Test.processPendingSubtests (node:internal/test_runner/test:974:18)
at Test.postRun (node:internal/test_runner/test:1542:19)
at Test.run (node:internal/test_runner/test:1467:12)
at async Test.processPendingSubtests (node:internal/test_runner/test:974:7) {
generatedMessage: true,
code: 'ERR_ASSERTION',
actual: [],
expected: [ { currency: 'EUR', cents: 0, count: 2 } ],
operator: 'deepStrictEqual',
diff: 'simple'
}
test at test\expense.test.mjs:22:1
✖ summarizing retains caller rows and handles an empty list (0.1386ms)
AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
+ actual - expected
+ []
- [
- {
- cents: 200,
- count: 1,
- currency: 'USD'
- }
- ]
at TestContext.<anonymous> (file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/.qa/live-delivery-t/node/expense-project/test/expense.test.mjs:24:10)
at Test.runInAsyncScope (node:async_hooks:227:14)
at Test.run (node:internal/test_runner/test:1402:25)
at Test.processPendingSubtests (node:internal/test_runner/test:974:18)
at Test.postRun (node:internal/test_runner/test:1542:19)
at Test.run (node:internal/test_runner/test:1467:12)
at async Test.processPendingSubtests (node:internal/test_runner/test:974:7) {
generatedMessage: true,
code: 'ERR_ASSERTION',
actual: [],
expected: [ { currency: 'USD', cents: 200, count: 1 } ],
operator: 'deepStrictEqual',
diff: 'simple'
}
test at test\expense.test.mjs:26:1
✖ invalid rows currency and unsafe aggregate totals are rejected (0.0938ms)
AssertionError [ERR_ASSERTION]: Missing expected exception (TypeError).
at TestContext.<anonymous> (file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/.qa/live-delivery-t/node/expense-project/test/expense.test.mjs:28:91)
at Test.runInAsyncScope (node:async_hooks:227:14)
at Test.run (node:internal/test_runner/test:1402:25)
at Test.processPendingSubtests (node:internal/test_runner/test:974:18)
at Test.postRun (node:internal/test_runner/test:1542:19)
at Test.run (node:internal/test_runner/test:1467:12)
at async Test.processPendingSubtests (node:internal/test_runner/test:974:7) {
generatedMessage: false,
code: 'ERR_ASSERTION',
actual: undefined,
operator: 'throws',
diff: 'simple'
}
test at test\expense.test.mjs:30:1
✖ reports use two decimals and render negative subunit amounts (0.1447ms)
AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
+ actual - expected
+ ''
- 'CNY 3.00 (2)\nUSD -1.05 (1)'
at TestContext.<anonymous> (file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/.qa/live-delivery-t/node/expense-project/test/expense.test.mjs:31:10)
at Test.runInAsyncScope (node:async_hooks:227:14)
at Test.run (node:internal/test_runner/test:1402:25)
at Test.processPendingSubtests (node:internal/test_runner/test:974:18)
at Test.postRun (node:internal/test_runner/test:1542:19)
at Test.run (node:internal/test_runner/test:1467:12)
at async Test.processPendingSubtests (node:internal/test_runner/test:974:7) {
generatedMessage: true,
code: 'ERR_ASSERTION',
actual: '',
expected: 'CNY 3.00 (2)\nUSD -1.05 (1)',
operator: 'strictEqual',
diff: 'simple'
}
test at test\expense.test.mjs:34:1
✖ complete expense flow preserves exact decimal sums (0.1179ms)
AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
+ actual - expected
+ ''
- 'CNY 10.50 (1)\nUSD -0.01 (2)'
at TestContext.<anonymous> (file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/.qa/live-delivery-t/node/expense-project/test/expense.test.mjs:35:10)
at Test.runInAsyncScope (node:async_hooks:227:14)
at Test.run (node:internal/test_runner/test:1402:25)
at Test.processPendingSubtests (node:internal/test_runner/test:974:18)
at Test.postRun (node:internal/test_runner/test:1542:19)
at Test.run (node:internal/test_runner/test:1467:12)
at async Test.processPendingSubtests (node:internal/test_runner/test:974:7) {
generatedMessage: true,
code: 'ERR_ASSERTION',
actual: '',
expected: 'CNY 10.50 (1)\nUSD -0.01 (2)',
operator: 'strictEqual',
diff: 'simple'
}
@@ -0,0 +1 @@
{"artifact_id":"f1bf75d1-04d2-40de-a099-8efd552e4063","kind":"context-group","sha256":"d042fe08ebaf067f482a99a21639272eefccf6b04591399eb6288e7c6baa5e9f","content":"[{\"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\\\"}\"","offset":0,"next_offset":362,"returned_characters":362,"total_characters":13197,"truncated":true,"requested_offset":0,"requested_limit":14000,"budget_limited":true,"maximum_message_bytes":1024}
@@ -0,0 +1 @@
{"projectId":"5e353edf-99cb-4fbd-aade-9d2c69caa7e9","name":"owned-live-expense-report","languages":["JavaScript"],"packageManager":"npm","scripts":[{"name":"test","script":"node --test test/expense.test.mjs","kind":"test","framework":"node","lifecycle":[]},{"name":"build","script":"node scripts/build.mjs","kind":"build","framework":null,"lifecycle":[]}],"rules":[],"declarations":{},"entryPoints":[],"git":{"available":true,"head":"1832150638e0b6b3dfa3c4b0cd714e69819a417d","branch":"main","dirty":true,"status":"MM owner-staged.txt\n M owner-unstaged.txt\n?? owner-untracked.txt\n","statusSha256":"c37d286f0cb5f771a6c51831f1f8b5bcd903169e4f64fb4cd3b15cddeaa7eaa8","complete":true,"contentFilters":"disabled-for-inspection","submoduleWorktrees":"not-inspected"},"fingerprint":"b3ac594ca4c17cf9b0d9a3f3422a0f04b035cd96feec05c62cea42a69f0f8777","sourceFingerprint":"2939702246bdddd91b3af4e235157165e2ed973f8ec3de00da62435e5e22638e","inspectedAt":"2026-11-03T22:56:29.032Z","scope":{"complete":true,"scannedFiles":11,"bytes":3691,"excludedFiles":0,"maximumFiles":1000,"maximumBytes":16777216,"note":"有界快照;Git工程遵循ignore并包含未跟踪源码,跳过依赖、链接和常见凭据路径。"}}
@@ -0,0 +1 @@
{"id":"resp_05448e7b05c3e556016aea6681c3f887d2b1dc574de273fb30","object":"chat.completion","created":1793746565,"model":"gpt-6.1-sol","choices":[{"index":0,"message":{"role":"assistant","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\"}"}}]},"finish_reason":"tool_calls"}],"usage":{"prompt_tokens":7539,"completion_tokens":128,"total_tokens":7667},"service_tier":"default"}
@@ -0,0 +1 @@
{"schemaVersion":1,"id":"60c19ef8-ea40-441b-a578-e63c0f1288f2","sessionId":"5a1b39be-8096-46e6-bc43-156ca308f6f9","projectId":"5e353edf-99cb-4fbd-aade-9d2c69caa7e9","taskId":"94a78e50-df05-4176-b033-32de563a347c","runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","stepId":"0a93b69f-5a59-4673-93e6-7c90cb701a28","requestIndex":7,"status":"prepared","createdAt":"2026-11-03T22:56:23.910Z","finishedAt":null,"requestSha256":"99bb1800ae57968fb7d984abfc1a2d7e7ed45a1cf4103783214a911003c1f747","requestBytes":35502,"estimatedInputTokens":12274,"requestArtifactId":"2275eb33-533f-44fb-95ad-d1ae47362ce9","tokenReservation":{"schemaVersion":1,"method":"observed-route-max-v1","overheadTokens":0,"reservedTokens":15998,"routes":[{"connectionId":"5b4daed9-b2f7-4de0-b949-573eba70c7b3","model":"gpt-6.1-sol","protocol":"chat-completions","endpoint":"https://jojocode.com/v1","localInputTokens":12274,"outputReservation":2048,"inputRatio":1.1365208796639485,"observedOutputTokens":2048,"observedTotalFloor":10086,"reservedTokens":15998,"sources":[{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"49d8a7e3-13f8-41b0-a336-f71267868e04","localInputTokens":8094,"reportedInputTokens":9199,"reportedOutputTokens":70,"totalTokens":9269},{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"9fa0fd0e-4434-498b-9691-156bd481d765","localInputTokens":9097,"reportedInputTokens":10065,"reportedOutputTokens":21,"totalTokens":10086},{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"2113b67b-6ea0-41de-8829-ed3a36820cd8","localInputTokens":10929,"reportedInputTokens":7539,"reportedOutputTokens":128,"totalTokens":7667},{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"6af65f19-5c39-4e8e-98c0-aead8dedafb2","localInputTokens":12218,"reportedInputTokens":8700,"reportedOutputTokens":82,"totalTokens":8782},{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"51cc7d6d-5f0b-4085-a373-609c4c4ea32c","localInputTokens":12352,"reportedInputTokens":8843,"reportedOutputTokens":197,"totalTokens":9040},{"runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","attemptId":"d537d370-bbf0-45d6-876a-33a2cd25ecce","localInputTokens":12352,"reportedInputTokens":8852,"reportedOutputTokens":245,"totalTokens":9097}]}]},"maxBudgetAttempts":2,"estimateMethod":"utf8-third-plus-framing-v1","beforeInputTokens":19394,"beforeBytes":56548,"budget":{"contextLimit":16000,"outputReservation":2048,"safetyTokens":1600,"inputBudget":12352,"targetInputTokens":12352,"runRemainingTokens":36059,"taskRemainingTokens":36059,"limitingReason":"context_limit"},"mandatoryInputTokens":11529,"nextReadFixedInputTokens":10362,"workingRetentionTokens":661,"workingRetentionPolicyVersion":1,"readBudgetPolicyVersion":2,"originalMessages":21,"retainedMessages":6,"archivedGroups":5,"retainedGroups":[0,6],"historyIndexArtifactId":"f2146a90-cf7f-497a-b321-2dc9f9ee1791","historyIndexSha256":"bf396aa608327cf6a8d281bf8f836a4d01648270b87efabe0dba6636e5043b68","actualUsage":null,"workingSetArtifactId":"037734f1-619e-4b7d-87f8-089085689f60","workingSetSha256":"23f52f2be661e45b695c28530036a6dc9fec42c386fc30c16cf9a8556016735b","workingSetEntries":2,"workingSetViewVersion":3,"latestToolsViewVersion":2,"latestToolsArtifactId":null,"latestToolsSha256":null,"latestToolsEntries":0,"projectMemoryArtifactId":null,"projectMemorySha256":null,"projectMemoryEntries":0,"skillCatalogArtifactId":null,"skillCatalogSha256":null,"skillCatalogEntries":0,"mcpCatalogArtifactId":null,"mcpCatalogSha256":null,"mcpCatalogEntries":0,"requestAttempts":0,"responseSha256":null,"source":"workbench"}
@@ -0,0 +1 @@
{"schemaVersion":1,"id":"26a57941-93d6-41e8-a94d-fa651d548973","sessionId":"5a1b39be-8096-46e6-bc43-156ca308f6f9","projectId":"5e353edf-99cb-4fbd-aade-9d2c69caa7e9","taskId":"94a78e50-df05-4176-b033-32de563a347c","runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","stepId":"2f7b6e21-dc36-4640-88ce-16aabc97ad49","requestIndex":1,"status":"prepared","createdAt":"2026-11-03T22:55:53.984Z","finishedAt":null,"requestSha256":"5949bebb196bd6669cb37f08cda67de760da3d8c3da196938adb5cff7f03cc99","requestBytes":23129,"estimatedInputTokens":8094,"requestArtifactId":"7aee04bd-ae28-4dfb-bbbd-b016f5a6cce2","tokenReservation":{"schemaVersion":1,"method":"observed-route-max-v1","overheadTokens":0,"reservedTokens":10142,"routes":[{"connectionId":"5b4daed9-b2f7-4de0-b949-573eba70c7b3","model":"gpt-6.1-sol","protocol":"chat-completions","endpoint":"https://jojocode.com/v1","localInputTokens":8094,"outputReservation":2048,"inputRatio":1,"observedOutputTokens":2048,"observedTotalFloor":0,"reservedTokens":10142,"sources":[]}]},"maxBudgetAttempts":8,"estimateMethod":"utf8-third-plus-framing-v1","beforeInputTokens":8094,"beforeBytes":23129,"budget":{"contextLimit":16000,"outputReservation":2048,"safetyTokens":1600,"inputBudget":12352,"targetInputTokens":12352,"runRemainingTokens":90000,"taskRemainingTokens":90000,"limitingReason":"context_limit"},"mandatoryInputTokens":8094,"nextReadFixedInputTokens":8094,"workingRetentionTokens":0,"workingRetentionPolicyVersion":1,"readBudgetPolicyVersion":2,"originalMessages":1,"retainedMessages":1,"archivedGroups":0,"retainedGroups":[0],"historyIndexArtifactId":null,"historyIndexSha256":null,"actualUsage":null,"workingSetArtifactId":null,"workingSetSha256":null,"workingSetEntries":0,"workingSetViewVersion":3,"latestToolsViewVersion":2,"latestToolsArtifactId":null,"latestToolsSha256":null,"latestToolsEntries":0,"projectMemoryArtifactId":null,"projectMemorySha256":null,"projectMemoryEntries":0,"skillCatalogArtifactId":null,"skillCatalogSha256":null,"skillCatalogEntries":0,"mcpCatalogArtifactId":null,"mcpCatalogSha256":null,"mcpCatalogEntries":0,"requestAttempts":0,"responseSha256":null,"source":"workbench"}
@@ -0,0 +1 @@
{"id":"resp_06a69a4a26ba85a0016aea6691d46487d2a3cc4540b053f8cf","object":"chat.completion","created":1793746583,"model":"gpt-6.1-sol","choices":[{"index":0,"message":{"role":"assistant","tool_calls":[{"id":"call_57212dc2ff0243b194fcfeefdfd9f2c4","type":"function","function":{"name":"read_artifact","arguments":"{\"artifact_id\": \"e067ec0a-3880-434d-9d8c-4654b27792f0\", \"offset\": 0, \"limit\": 12000}"}},{"id":"call_e61d3ad7c20f44b1a3f116facf75fc62","type":"function","function":{"name":"read_artifact","arguments":"{\"artifact_id\": \"f1bf75d1-04d2-40de-a099-8efd552e4063\", \"limit\": 14000}"}},{"id":"call_966fb39a5e9748bf954060b889c2cdbb","type":"function","function":{"name":"inspect_task_plan","arguments":"{}"}},{"id":"call_2ec85fda70e440f99faf760cd0b062d7","type":"function","function":{"name":"read_file","arguments":"{\"path\": \"test/expense.test.mjs\", \"start_line\": 1, \"end_line\": 38, \"offset\": 2557, \"expected_sha256\": \"0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839\", \"limit\": 1000}"}}]},"finish_reason":"tool_calls"}],"usage":{"prompt_tokens":8852,"completion_tokens":245,"total_tokens":9097,"completion_tokens_details":{"reasoning_tokens":42}},"service_tier":"default"}
@@ -0,0 +1 @@
[{"role":"assistant","content":"","tool_calls":[{"id":"call_56fb7fe30f7a48c0a466eedca7cb1c33","type":"function","function":{"name":"plan_checks","arguments":"{\"names\":[\"test\",\"build\"]}"}}]},{"role":"tool","tool_call_id":"call_56fb7fe30f7a48c0a466eedca7cb1c33","content":"{\"id\":\"1c46ffc1-3b24-4fb8-b207-3305ccd14fd1\",\"sessionId\":\"5a1b39be-8096-46e6-bc43-156ca308f6f9\",\"projectId\":\"5e353edf-99cb-4fbd-aade-9d2c69caa7e9\",\"taskId\":\"94a78e50-df05-4176-b033-32de563a347c\",\"runId\":\"714f56ac-55a2-4cd3-acbe-df2cf09f5329\",\"status\":\"planned\",\"createdAt\":\"2026-11-03T22:56:00.882Z\",\"fingerprint\":\"b3ac594ca4c17cf9b0d9a3f3422a0f04b035cd96feec05c62cea42a69f0f8777\",\"sourceFingerprint\":\"2939702246bdddd91b3af4e235157165e2ed973f8ec3de00da62435e5e22638e\",\"project\":{\"projectId\":\"5e353edf-99cb-4fbd-aade-9d2c69caa7e9\",\"name\":\"owned-live-expense-report\",\"languages\":[\"JavaScript\"],\"packageManager\":\"npm\",\"scripts\":[{\"name\":\"test\",\"script\":\"node --test test/expense.test.mjs\",\"kind\":\"test\",\"framework\":\"node\",\"lifecycle\":[]},{\"name\":\"build\",\"script\":\"node scripts/build.mjs\",\"kind\":\"build\",\"framework\":null,\"lifecycle\":[]}],\"rules\":[],\"declarations\":{},\"entryPoints\":[],\"git\":{\"available\":true,\"head\":\"1832150638e0b6b3dfa3c4b0cd714e69819a417d\",\"branch\":\"main\",\"dirty\":true,\"status\":\"MM owner-staged.txt\\n M owner-unstaged.txt\\n?? owner-untracked.txt\\n\",\"statusSha256\":\"c37d286f0cb5f771a6c51831f1f8b5bcd903169e4f64fb4cd3b15cddeaa7eaa8\",\"complete\":true,\"contentFilters\":\"disabled-for-inspection\",\"submoduleWorktrees\":\"not-inspected\"},\"fingerprint\":\"b3ac594ca4c17cf9b0d9a3f3422a0f04b035cd96feec05c62cea42a69f0f8777\",\"sourceFingerprint\":\"2939702246bdddd91b3af4e235157165e2ed973f8ec3de00da62435e5e22638e\",\"inspectedAt\":\"2026-11-03T22:56:00.880Z\",\"scope\":{\"complete\":true,\"scannedFiles\":11,\"bytes\":3691,\"excludedFiles\":0,\"maximumFiles\":1000,\"maximumBytes\":16777216,\"note\":\"有界快照;Git工程遵循ignore并包含未跟踪源码,跳过依赖、链接和常见凭据路径。\"}},\"artifactId\":\"e7ba7f05-6868-42cf-9df7-2a8a53834b9c\",\"checks\":[{\"id\":\"8cd27985-2e14-4310-bce1-e5c2d45a3e48\",\"name\":\"test\",\"script\":\"node --test test/expense.test.mjs\",\"kind\":\"test\",\"framework\":\"node\",\"lifecycle\":[],\"command\":\"npm run test\"},{\"id\":\"2db3b463-f934-473e-9b18-f5836d2eb838\",\"name\":\"build\",\"script\":\"node scripts/build.mjs\",\"kind\":\"build\",\"framework\":null,\"lifecycle\":[],\"command\":\"npm run build\"}],\"environment\":{\"kind\":\"node\",\"identity\":\"e6bb96bf7b30e2d7d8f075df02654f685543fbade9b56cc245f3030248f82735\",\"dependencyInputs\":\"5fd535fc8dbf59ebd0cf7f974775ebb86c47c0b3bf779ce3ec404bcaec3b3092\",\"status\":\"ready\",\"installed\":{\"status\":\"missing\",\"files\":0,\"bytes\":0,\"sha256\":null},\"declarations\":[{\"path\":\"D:\\\\Ai-project\\\\REA逆向\\\\Agent-Workbench\\\\.qa\\\\live-delivery-t\\\\node\\\\expense-project\\\\package.json\",\"sha256\":\"6ad63026b2fe9de7513a4f6704c372a86108ee3d018a1f04883dc0a409ea4c24\",\"bytes\":188}],\"runtime\":{\"status\":\"available\",\"node\":{\"path\":\"D:\\\\Ai-project\\\\REA逆向\\\\Agent-Workbench\\\\releases\\\\Agent-Workbench-1.14.0-win-x64-20261030235440461\\\\runtime\\\\node.exe\",\"sha256\":\"d702daa815eabbff763c7d3808e235cf031cf2ca70211b56847bc72f51e240e5\",\"bytes\":93915464,\"version\":\"v24.22.1\"},\"npm\":{\"path\":\"C:\\\\Users\\\\wangy\\\\AppData\\\\Local\\\\Programs\\\\AgentWorkbench\\\\versions\\\\Agent-Workbench-1.24.7-win-x64-20261103164618190\\\\runtime\\\\node_modules\\\\npm\\\\bin\\\\npm-cli.js\",\"sha256\":\"3ce7cba6f5128dd5f54c98b6a5036b0f850496878cc2e21044b675fe3c594e3e\",\"bytes\":56,\"version\":\"11.19.1\",\"manifest\":{\"path\":\"C:\\\\Users\\\\wangy\\\\AppData\\\\Local\\\\Programs\\\\AgentWorkbench\\\\versions\\\\Agent-Workbench-1.24.7-win-x64-20261103164618190\\\\runtime\\\\node_modules\\\\npm\\\\package.json\",\"sha256\":\"d5b859b88af16e893fbc2d28819db601a8543b241f8c80459f70898be2777c12\",\"bytes\":6856}}},\"preparation\":null},\"contractArtifactId\":\"d24bde2e-72c7-4d5b-967c-389355d90314\",\"contractSha256\":\"4ae07068a701d69faf182484730627624f74a4c6968f36a86e76d9a88fb47d41\"}"}]
@@ -0,0 +1 @@
{"schemaVersion":1,"kind":"sealed-check-plan","id":"1c46ffc1-3b24-4fb8-b207-3305ccd14fd1","sessionId":"5a1b39be-8096-46e6-bc43-156ca308f6f9","projectId":"5e353edf-99cb-4fbd-aade-9d2c69caa7e9","taskId":"94a78e50-df05-4176-b033-32de563a347c","runId":"714f56ac-55a2-4cd3-acbe-df2cf09f5329","fingerprint":"b3ac594ca4c17cf9b0d9a3f3422a0f04b035cd96feec05c62cea42a69f0f8777","sourceFingerprint":"2939702246bdddd91b3af4e235157165e2ed973f8ec3de00da62435e5e22638e","checks":[{"id":"8cd27985-2e14-4310-bce1-e5c2d45a3e48","name":"test","script":"node --test test/expense.test.mjs","kind":"test","framework":"node","lifecycle":[],"command":"npm run test"},{"id":"2db3b463-f934-473e-9b18-f5836d2eb838","name":"build","script":"node scripts/build.mjs","kind":"build","framework":null,"lifecycle":[],"command":"npm run build"}],"environment":{"kind":"node","identity":"e6bb96bf7b30e2d7d8f075df02654f685543fbade9b56cc245f3030248f82735","dependencyInputs":"5fd535fc8dbf59ebd0cf7f974775ebb86c47c0b3bf779ce3ec404bcaec3b3092","status":"ready","installed":{"status":"missing","files":0,"bytes":0,"sha256":null},"declarations":[{"path":"D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-t\\node\\expense-project\\package.json","sha256":"6ad63026b2fe9de7513a4f6704c372a86108ee3d018a1f04883dc0a409ea4c24","bytes":188}],"runtime":{"status":"available","node":{"path":"D:\\Ai-project\\REA逆向\\Agent-Workbench\\releases\\Agent-Workbench-1.14.0-win-x64-20261030235440461\\runtime\\node.exe","sha256":"d702daa815eabbff763c7d3808e235cf031cf2ca70211b56847bc72f51e240e5","bytes":93915464,"version":"v24.22.1"},"npm":{"path":"C:\\Users\\wangy\\AppData\\Local\\Programs\\AgentWorkbench\\versions\\Agent-Workbench-1.24.7-win-x64-20261103164618190\\runtime\\node_modules\\npm\\bin\\npm-cli.js","sha256":"3ce7cba6f5128dd5f54c98b6a5036b0f850496878cc2e21044b675fe3c594e3e","bytes":56,"version":"11.19.1","manifest":{"path":"C:\\Users\\wangy\\AppData\\Local\\Programs\\AgentWorkbench\\versions\\Agent-Workbench-1.24.7-win-x64-20261103164618190\\runtime\\node_modules\\npm\\package.json","sha256":"d5b859b88af16e893fbc2d28819db601a8543b241f8c80459f70898be2777c12","bytes":6856}}},"preparation":null}}
@@ -0,0 +1 @@
{"path":"test/expense.test.mjs","start_line":36,"end_line":38,"total_lines":38,"content":" (1)\\nUSD -0.01 (2)');\n});\n","sha256":"0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839","bom":false,"truncated":true,"range_start_line":1,"range_end_line":38,"offset":2557,"next_offset":2584,"total_characters":2584,"returned_characters":27,"requested_offset":2557,"next_start_line":null,"budget_limited":false,"maximum_message_bytes":1024}

Some files were not shown because too many files have changed in this diff Show More