test: seal jojocode delivery trial and network diagnosis review

This commit is contained in:
Agent Workbench Dev
2026-11-03 22:45:26 +08:00
parent 9d549a71a3
commit dca6cbdb2c
90 changed files with 1206565 additions and 0 deletions
+7
View File
@@ -203,3 +203,10 @@ docs/live-context-o-evidence/**/artifacts/** binary
docs/live-context-o-offline.txt binary
docs/live-context-o-git-index.txt binary
docs/live-context-o-release-identity.json -text
docs/live-delivery-p-evidence/** -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol
docs/live-delivery-p-evidence/**/*.log binary
docs/live-delivery-p-evidence/**/*.txt binary
docs/live-delivery-p-offline.txt binary
docs/live-delivery-p-git-index.txt binary
docs/live-delivery-p-index-first.txt binary
+1
View File
@@ -38,3 +38,4 @@
/.DS_Store
!docs/delivery-integrity-i-evidence/**/*.log
!/docs/live-context-o-evidence/**/*.log
!/docs/live-delivery-p-evidence/**/*.log
+2
View File
@@ -1,5 +1,7 @@
# Agent Workbench项目执行规范
P已完成新的jojocode5b4/Chat JSON独立实测:预检1请求/112报告tokens/0工具/strict matched;新Node首请求UND_ERR_CONNECT_TIMEOUT,0工具/修改/检查/交付,1未知预留10141,未重试切池或续跑旧Task。两轮12次无HTTP TLS握手11成功/1固定IPv6超时,仅证明观察波动,不是唯一根因或API稳定性证明。正式仍1.24.5/source676103c4/PID36552/原Provider,未改产品或重打包。原59公开项目75导出/3605工件/207原尝试及原行、预算/高性能池按声明核对保持;当前61项目77会话/6167记录/13115事件/outbox/3610工件,新增均归属P。目标连接3→4→5/凭据1,原缺省身份三字段显式恢复record/[]/空串规范化单列;全局/legacy展示修订61→65,9229关闭。75份/55891232字节证据离线通过,见docs/QA-LIVE-DELIVERY-P.md及回顾。下一先所属连接DNS/TCP/TLS诊断开发和独立验证,再新有界Node;不能为通过强制IPv4/关闭证书/扩大预算。真实Node、React/Python、原版Purge收益仍未验收,1.25和更新性能保持计划。不委派子代理、不重启正式进程、不提取/复制/重存Key,不推送。
O已本地交付:1.24.5/source676103c4/候选20261103133956264,重复goal和计划诊断回声定向修复,105相关/25升级安装、552输入独立重建22/22、三归档/便携、三载荷16K回放、源码25历史UI、12实际安装及16+9安装文件流程通过。正式保留PID36552/Provider,原58项目74会话与全部原行/导出/工件/模型中心在网页/原生回看后再次精确保持,9229关闭。新同预算Node2请求/4838报告tokens/1未知预留11095,第二上游502/Retry-After60,0修改/检查/交付,旧失败不续跑;原74导出/3596工件/205尝试与声明原状态恢复通过,凭据1、连接3→4→5。315份/140408882字节证据离线通过,本轮合计5请求/16227报告tokens/1未知,Purge收益未测试,见docs/QA-LIVE-CONTEXT-O.md及回顾。保持当前用户高性能池jojocode+93d,不恢复过期N池或启用旧09b。原旧Node metadata registry逆算未匹配的限制保持;新恢复不倒推旧结果。正式更新677958ms重复核验单列性能,下一先新预检/Node闭环,再React/Python/Purge,1.25仍计划。
N当前结论优先:用户明确确认apikey密钥属于GPT分组,原请求误填Claude;结束供应商Claude故障推断。34组I前/M前与当前GPT请求字节/预算对照、24组型号对照、144相关回归及2个实际GPT协议重定向场景通过。220份src仍与正式M冻结一致,未回滚或修改产品代码;保留I交付/防空转、K模型选择及M独立Messages能力。见docs/ROUTING-AUDIT-N.md。
+2
View File
@@ -1,5 +1,7 @@
# 新真实样本计划(O已交付上下文修复,新的Node仍待闭环)
P补充:另一既有jojocode连接的新预检通过,新Node首连接超时,真实闭环仍未通过。两次尝试共112报告tokens/1未知预留10141,原状态按声明恢复,75份证据离线通过;独立TLS有波动但不证明原超时唯一根因。下一先落实[所属连接诊断切片](RETROSPECTIVE-LIVE-DELIVERY-P.md),之后另开有界样本,不续跑旧任务、不扩大本例预算,见[本轮结果](QA-LIVE-DELIVERY-P.md)。本计划的Node→React/Python→原版Purge前置关系保持。
O已执行本计划的新GPT单次预检,1请求/120报告tokens/0工具,标识匹配。旧Node2请求后context_limit已定向修复并交付1.24.5;新的同预算Node在第二请求遇上游502,2请求/4838报告tokens/1未知预留11095,未修改或交付。315份证据离线通过,见[完整结果](QA-LIVE-CONTEXT-O.md)。下一仍按下面顺序,先固定可用连接另开有界样本,不自动继续旧502或context_limit任务;原版Purge与React/Python不提前记通过。
下方N及J/M段落保留原计划时点,当前结果以O为准。
+2
View File
@@ -1,5 +1,7 @@
# 后续执行计划
P最新:jojocode新单次预检1请求/112报告tokens/0工具通过,新Node首连接UND_ERR_CONNECT_TIMEOUT,1未知预留10141、0修改/检查/交付;未重试或切池。12次独立TLS握手11通过/1固定IPv6超时,不能认定唯一根因。原59项目75会话/3605工件/207尝试及默认预算/池按声明恢复,正式仍1.24.5,无产品改动。75份/55891232字节证据离线通过。下一先做可取消、无Key/无HTTP的所属连接诊断与实际入口验收,再新有界Node;React/Python/Purge和更新性能分别按前置条件推进。见[结果](QA-LIVE-DELIVERY-P.md)及[具体下一切片](RETROSPECTIVE-LIVE-DELIVERY-P.md)。下方O等保持历史时点。
O最新:1.24.5上下文去重已完成独立发行及保留原PID/Provider升级;源码/便携/安装16K回放、105相关/25升级安装、552输入重建22/22、12实际安装及正式网页/原生通过。新同预算Node样本第二请求上游502,未交付;本轮合计5请求/16227报告tokens/1未知,315份证据离线通过。下一先固定可用连接,独立预检和新Node闭环,再React/Python及原版PurgeAB/BA;旧失败不续跑。更新677958ms的重复核验单独优化,1.25仍计划,具体完成标准见[本阶段回顾](RETROSPECTIVE-LIVE-CONTEXT-O.md)。下方“最新”均按其历史时点理解。
J最新:用户指定 apikey Claude 的单次真实预检已结束,请求 claude-opus-5-5、返回 gpt-6.1-sol,4334 报告 tokens、0 工具,严格暂停并恢复原池/参数。原数据与所属新增核对完成,[结果与下一入口](LIVE-MODEL-IDENTITY-J-RESULTS.md)已记录,30份证据离线通过。更正或新选连接后另开首请求预检,通过才做新Node工程;当前工程/Purge未启动,旧失败不重试。以下段落按原历史时点理解。
+52
View File
@@ -0,0 +1,52 @@
# P:jojocode 独立真实交付实测
本轮完成了一次新的固定连接预检、一个新的 Node 工程样本和独立网络检查。预检通过,工程样本首请求连接超时,未完成交付。没有新的产品代码改动或发行,正式仍为 1.24.5;没有把网络失败解释为模型协议错误。
## 固定范围与实际结果
| 项目 | 固定条件 | 实际结果 |
| --- | --- | --- |
| 连接 | jojocode / `5b4daed9-b2f7-4de0-b949-573eba70c7b3`,`gpt-6.1-sol`,Chat JSON,原 Provider 与凭据修订 1 | 单独选线,未使用 legacy 或默认池派发 |
| 单次预检 | 1 请求,16000 tokens,256 输出,无工具、重试或切池 | 1 请求,112 报告 tokens,原 JSON 型号 matched,0 工具 |
| 新 Node 工程 | 最多 8 请求、90000 tokens、16K 上下文、2048 输出;原 9 测试与 build、完整批次审查及模型准备的本地 Git | 首尝试 `UND_ERR_CONNECT_TIMEOUT`,0 工具、修改、检查、交付 |
| 网络检查 | 两个既有供应商域名,各两轮默认双栈、IPv4、IPv6 TLS 握手 | 12 次中 11 成功、1 固定 IPv6 握手超时;0 HTTP、0 模型请求 |
预检会话为 `60728f43-2ff3-4279-918f-9ad4d1bc83fe`;Node 会话为 `73cfff62-8e93-4056-b42d-682a37784f7b`,Task 为 `01388c5e-0c48-46cb-ba47-7d8e0fbe73b0`。两者均为新的自有样本,没有续跑 O/J/E/H 等旧失败。
Node 原请求地址是 `https://jojocode.com/v1/chat/completions`,原请求 23127 字节。连接阶段约 10 秒超时,诊断 `stage=connect`、`replaySafety=before_model_send`、`responseReceived=false`,没有 HTTP 状态、响应原文或已返回型号可核对。原请求和账本保持,不补造响应,不自动重试。
Node 保守记录 1 次未知用量、10141 tokens 估算预留,0 仅指报告 tokens,不能据此断言免费。预留来自原 ContextPlan 的 8093 输入估算与 2048 输出预留,16K、1600 安全预留和原 8 请求/90000 上限均保持。本轮合计 2 次尝试、112 报告 tokens、1 未知用量/10141 估算预留。
## 网络观察的边界
两轮 DNS 都返回了 IPv4/IPv6 地址。四次使用与 Provider 相同地址族选择参数的独立 TLS 握手均成功;另一次固定 IPv6 握手在 11 秒达到诊断期限。证书校验始终启用,没有发送 HTTP、Key 或原模型请求。
这证明观察期间路径存在波动,不能证明它就是原 Node 失败的唯一原因;后续握手成功也不保证模型 API、工具调用或工程交付可用。本轮没有强制切 IPv4、写系统代理、关闭证书核验或修改正确的 Chat 协议。
## 验收过程与状态恢复
发送前复查发现,jojocode 原先缺省三个身份设置字段。连接 API 是部分更新,恢复时省略这些字段会继承实验期间的 `require-match`。驱动已在 Node 开始前改为显式恢复原 `record`、`[]`、空串语义,保存完整原 raw 配置,并单列这三项新增默认字段。没有宣称它们的 raw 字节与原始缺省形式一致。
新驱动还要求监督读取完整模型变更批次和 Git 计划、记录具体审核结论后才应用或确认。监督不提供实现代码。本例未到提案阶段,这些门禁未被触发,不能声称本例验收了审查后完整交付。
预检首只读核对器误用了不存在的 `artifacts` 表,改按真实 `records` 与工件文件 SHA 核对,首失败日志保留。最终核对首轮未扣除 legacy 展示修订随全局配置修订变化的字段,亦保留原驱动、日志和同一冻结快照;后续只修正该精确声明,未重复模型请求或配置保存。
首次 Git 索引核对发现全局 `*.log` 忽略规则遗漏了本轮原日志;已增加本证据目录的精确例外和原字节属性,再检查全部清单文件。首失败保存在[索引日志](live-delivery-p-index-first.txt),没有降低文件数或 SHA 期望来绕过。
最终核对通过:
- 原 59 个公开项目、75 个会话导出、原会话/记录/事件/outbox 每行、3605 份工件和 207 条完整原模型尝试保持。
- 当前 61 项目、77 会话、6167 记录、13115 事件及 outbox、3610 工件。两项目/会话和两尝试全部归属本轮。
- 原预算、默认高性能池选择及成员恢复;目标外连接保持。旧 apikey/09b 继续停用。
- 目标连接修订 3→4→5,凭据仍 1;全局及 legacy 展示修订 61→65,更新时间、登记顺序、实际健康变化及上述显式身份默认值单列。
- 原 PID 36552/Provider 与正式 1.24.5 安装保持,调试端口 9229 关闭。网络检查后的全部持久表与 Node 恢复后快照一致。
## 证据与下一步
[清单](live-delivery-p-evidence/manifest.json)封存 75 份文件、55891232 字节,SHA-256 为 `c2ea37b5c3e34ae76e0e9283c937eb0d4082aaceedae06ecab355c8c6eb5d0aa`。原请求、原预检响应、失败账本、配置前后原件、恢复快照、TLS 原结果和不可执行的驱动文本均在其中。独立[离线核验器](../scripts/verify-live-delivery-p.mjs)核对原字节、身份、预算、未知用量、Git 基线与声明的恢复范围;不联网或接触凭据。
[离线收据](live-delivery-p-offline.txt)与[Git 索引收据](live-delivery-p-git-index.txt)均通过;索引含清单 76 份、55904611 字节逐 SHA 保持。可在仓库根目录用 Node 运行 `scripts/verify-live-delivery-p.mjs`;提交前追加 `--index` 核对暂存证据原字节。
本轮没有改产品源码,未重复已有打包、安装或原生窗口验收,没有新的桌面回看结论。请求/响应相同型号也不认证模型权重。真实 Node 闭环、React/Python 扩展与原版 Purge AB/BA 均未通过本轮验收。
下一切片先按[回顾与执行计划](RETROSPECTIVE-LIVE-DELIVERY-P.md)完善连接诊断,再做新的有界真实样本;不重放本例。更新性能和 1.25 的产品能力仍分别排期。
+32
View File
@@ -0,0 +1,32 @@
# P:真实交付与连接问题回顾
本轮把另一个已配置连接带到独立真实样本。身份预检通过,Node 首请求未建立连接,工程能力仍没有新闭环。网络波动有独立观察,但没有足够证据将单一 IPv6 地址、供应商路由或工作台协议认定为唯一根因。
## 已完成与未完成
| 事项 | 状态与依据 |
| --- | --- |
| jojocode 单独选线与原 JSON 型号 | 预检 1 请求/112 报告 tokens/0 工具,严格 matched |
| Node 自主实现 | 连接超时,0 工具/修改/测试;未通过 |
| 未知用量与恢复 | 原记录保留,10141 估算预留;原数据及默认预算/号池按声明范围核对通过 |
| 验收驱动质量 | 发送前修正缺省身份设置恢复;加入完整内容审查门禁,未在本例触发 |
| 网络路径 | 12 次独立 TLS 握手中 11 成功、1 固定 IPv6 超时;没有模型 API 可用性结论 |
| React/Python/Purge 收益 | 未开展;保持 Node 前置关系 |
本轮没有发现可据此修改 Chat/Messages/Responses 协议的证据,也没有新的产品源码修复。保留 I/K/M/O 的正确实现,不为获得通过而抬高上下文、降低原测试或重复失败 Task。
## 下一开发切片:把连接诊断做成可用流程
1. 在模型连接诊断中区分 DNS、TCP/TLS、HTTP/上游错误、等待响应和流式中断。现有错误和原请求归属继续保留;新增读网检查独立于实际模型调用,不把握手通过标为模型已验证。
2. 对明确选中的连接执行有界、可取消的只读检查,绑定连接修订和实际运输参数,记录地址族、选中地址、阶段耗时与证书校验结果。全程不读/发 Key,不发送原请求,不修改系统代理或路由。代理路线与直连结果必须明确区分。
3. 用本地 DNS 失败、TCP 拒绝、TLS 无响应、证书拒绝、取消、地址族切换和并发停止场景验证。先复现和测量,再决定是否需要运输层修复;不能直接硬编码 IP、强制 IPv4、关证书或仅增加模型响应时限。
4. 补齐模型中心实际入口、明确结果文案及桌面/窄屏回看。开发验证使用隔离宿主与自有端口;只有产品改动通过相关回归和独立发行验收后才升级正式版,保留原 PID/Provider 和用户数据。
5. 然后另开新的有界预检/Node 样本。继续原 16K/2048、8 请求/90000 tokens、原 9 测试/build/完整审查/Git,旧失败不续跑,预检通过不自动宣称交付通过。所有新增调用另立身份、预算和原件,不能用连续开样本掩盖失败或超出已冻结预算。
## 后续顺序
Node 真实闭环通过后,分别验证 React 和 Python,再做原版 Purge 同源、同题、同预算 AB/BA。比较成功交付率、tokens、时延、监督次数与未知用量;失败提前结束不能记成节省。
更新性能继续单列:O 的 677958ms 有明确重复扫描收据,后续优化保持候选篡改、额外文件、路径替换、发布故障回退和原数据核验。1.25 的任务要求/交付复核、多供应商、多模态与新手机能力保持原规划,先完成当前可靠性切片。
阶段完成时更新计划、记录失败和限制、封存原证据、执行相关检查并按范围本地提交。未经授权不推送;不会将本轮文档/实测提交冒充新产品发行。
@@ -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,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-p');
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'].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,62 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { publicSnapshot, databaseSnapshot, canonical } from './desktop-f-state.mjs';
import { root, origin, dataRoot, original, connectionId, save, meta, client } from './live-delivery-p-common.mjs';
import { inspectorClosed } from './live-delivery-p-inspector.mjs';
const read = name => JSON.parse(fs.readFileSync(path.join(root, name)));
const previous = read('node/after.json'), node = read('node/result.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), 'Current database still equals the frozen final snapshot.');
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 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 initialCenter = original.center, center = after.modelCenter;
assert.deepEqual(center.selected, initialCenter.selected); assert.deepEqual(center.pools, initialCenter.pools);
const expectedConnection = { ...initialCenter.connections.find(value => value.id === connectionId),
modelIdentityPolicy: 'record', modelIdentityAliases: [], modelIdentityAliasSource: '' };
const actualConnection = center.connections.find(value => value.id === connectionId);
assert.equal(actualConnection.revision, expectedConnection.revision + 2); 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(value => value.id !== connectionId)) {
const next = center.connections.find(value => value.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, 'Legacy display revision follows the global configuration revision.');
} else assert.deepEqual(next, item);
}
assert.deepEqual({ ...boot.config, configRevision: original.config.configRevision }, original.config);
const ownedProjects = [read('preflight/owned.json').project.id, read('node/owned.json').project.id];
const ownedSessions = [read('preflight/owned.json').session.id, read('node/owned.json').session.id];
assert.deepEqual(boot.projects.filter(value => !ownedProjects.includes(value.id)), original.projects);
assert.deepEqual(after.database.sessionIds.filter(value => !ownedSessions.includes(value)), before.database.sessionIds);
const attempts = meta('modelAttempts'), oldAttempts = read('preflight/original-attempts.json');
for (const item of oldAttempts) assert.deepEqual(attempts.find(value => value.id === item.id), item);
const added = attempts.filter(value => !oldAttempts.some(item => item.id === value.id));
assert.equal(added.length, 2); assert.ok(added.every(value => ownedSessions.includes(value.sessionId)));
for (const name of ['src/amount.mjs', 'src/summary.mjs', 'src/report.mjs']) assert.deepEqual(fs.readFileSync(path.join(root, 'node/source-before', name)), fs.readFileSync(path.join(root, 'node/source-after', name)));
assert.deepEqual(node.approvals, []); assert.deepEqual(node.applications, []);
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,
finalCounts: Object.fromEntries(Object.entries(after.database.tables).map(([name, table]) => [name, table.count])),
ownedProjects, ownedSessions, addedAttempts: added.length, exactSinceNodeRestoration: true,
originalSessionExportsRowsAndArtifactsExact: true, originalPublicProjectsExact: true, originalAttemptsExact: true,
originalBudgetsSelectionAndPoolRestored: true, connectionRevision: [expectedConnection.revision, actualConnection.revision], credentialRevision: 1,
identityDefaultsExplicitlyNormalized: true, observedHealthAndStatusExcludedFromConfigurationEquality: true,
legacyDisplayRevisionFollowsGlobalConfigurationRevision: [original.config.configRevision, boot.config.configRevision],
inspectorClosed: await inspectorClosed(), modelRequests: 2, reportedTokens: 112, unknownRequests: 1, estimatedUnknownTokens: 10141,
nodeDelivered: false, purgeBenefitTested: false, keyReadOrResaved: false, productSourceChanged: false };
save('final/result.json', result); console.log(JSON.stringify(result));
} finally { await close(); }
@@ -0,0 +1,20 @@
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-p'); 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.5'); 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, 3);
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, []);
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-p-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,31 @@
import tls from 'node:tls';
import dns from 'node:dns/promises';
import fs from 'node:fs';
import path from 'node:path';
import { root, save } from './live-delivery-p-common.mjs';
const connect = (host, options) => new Promise(resolve => {
const start = Date.now(); let done = false;
const socket = tls.connect({ host, port: 443, servername: host, rejectUnauthorized: true, ...options });
const finish = value => { if (done) return; done = true; clearTimeout(timer); const address = socket.remoteAddress;
socket.destroy(); resolve({ ...value, address, elapsedMs: Date.now() - start }); };
const timer = setTimeout(() => finish({ success: false, code: 'QA_TLS_TIMEOUT' }), 11000);
socket.once('secureConnect', () => finish({ success: socket.authorized, protocol: socket.getProtocol(), certificateAuthorized: socket.authorized }));
socket.once('error', error => finish({ success: false, code: error.code, causes: error.errors?.map(value => ({ code: value.code, address: value.address, port: value.port })) }));
});
const targets = ['jojocode.com', 'api.apikey.fan'];
const results = [];
for (let round = 1; round <= 2; round++) {
results.push(...await Promise.all(targets.map(async host => {
let lookup; try { lookup = await dns.lookup(host, { all: true }); } catch (error) { lookup = { code: error.code }; }
const trials = await Promise.all([
{ mode: 'same-family-selection-as-provider', options: { autoSelectFamily: true, autoSelectFamilyAttemptTimeout: 250 } },
{ mode: 'ipv4-only-diagnostic', options: { family: 4 } },
{ mode: 'ipv6-only-diagnostic', options: { family: 6 } },
].map(async ({ mode, options }) => ({ mode, ...await connect(host, options) })));
return { round, host, lookup, trials };
})));
}
const result = { recordedAt: new Date().toISOString(), results, realModelRequests: 0, httpRequests: 0,
tlsCertificateValidationEnabled: true, keyValuesReadOrSent: false, productConfigurationChanged: false,
scope: 'DNS and authenticated TLS handshake only; no HTTP headers/body, no original request replay, and no proof of model/API availability.' };
save('network/result.json', result); console.log(JSON.stringify(result));
@@ -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-p-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.5');
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, 3);
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.__gptPProbeOnce ??= new Set();
ensure(!globalThis.__gptPProbeOnce.has(input.sessionId), 'This sample cannot be replayed.');
globalThis.__gptPProbeOnce.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: 'P · 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-p-common.mjs';
import { inspectorClosed } from './live-delivery-p-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.5');
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-p-inspector.mjs';
import { root, origin, dataRoot, connectionId, save, meta, client, captureAttempts } from './live-delivery-p-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.5');
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, 3);
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'), '# P 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: 'P · 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,23 @@
import fs from 'node:fs';
import assert from 'node:assert/strict';
const write = (name, value) => fs.writeFileSync('.qa/live-delivery-p-' + name + '.mjs', value, { flag: 'wx' });
const once = (text, from, to) => { assert.equal(text.split(from).length, 2, from); return text.replace(from, to); };
let common = fs.readFileSync('.qa/live-o-common.mjs', 'utf8').replaceAll('.qa/live-retest-o', '.qa/live-delivery-p')
.replaceAll('93d0cf6d-4f32-4918-9da8-6f125aa8a6e5', '5b4daed9-b2f7-4de0-b949-573eba70c7b3');
write('common', common);
let payload = fs.readFileSync('.qa/live-o-preflight-payload.mjs', 'utf8').replaceAll('__gptOProbeOnce', '__gptPProbeOnce')
.replaceAll('O · GPT', 'P · GPT');
payload = once(payload, "connection.modelIdentityPolicy === 'record'", "(connection.modelIdentityPolicy ?? 'record') === 'record'");
write('payload', payload);
write('inspector', fs.readFileSync('.qa/live-o-inspector.mjs', 'utf8').replaceAll('./live-o-preflight-payload.mjs', './live-delivery-p-payload.mjs'));
let preflight = fs.readFileSync('.qa/live-o-preflight-resume.mjs', 'utf8')
.replaceAll('./live-o-inspector.mjs', './live-delivery-p-inspector.mjs').replaceAll('./live-o-common.mjs', './live-delivery-p-common.mjs')
.replaceAll('preflight-resumed', 'preflight').replaceAll('1.24.4', '1.24.5').replaceAll('O GPT', 'P GPT').replaceAll('O · 正确GPT', 'P · jojocode GPT');
preflight = once(preflight, "assert.equal(connection.revision, 1);", "assert.equal(connection.revision, 3);");
preflight = once(preflight, "assert.equal(connection.modelIdentityPolicy, 'record');", "assert.equal(connection.modelIdentityPolicy ?? 'record', 'record');");
preflight = once(preflight, "console.log(JSON.stringify(result));", "console.log(JSON.stringify({ passed, requests: result.requests, usage: result.usage, reportedModels: result.reportedModels, stopReason: result.stopReason }));");
write('preflight', preflight);
let node = fs.readFileSync('.qa/live-p-node.mjs', 'utf8').replaceAll('./live-o-common.mjs', './live-delivery-p-common.mjs')
.replaceAll('preflight-resumed', 'preflight').replaceAll('node-after-fix', 'node');
write('node', node);
console.log(JSON.stringify({ prepared: ['common', 'payload', 'inspector', 'preflight', 'node'], root: '.qa/live-delivery-p', modelRequests: 0 }));
@@ -0,0 +1,40 @@
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-p'), target = path.resolve('docs/live-delivery-p-evidence');
assert.equal(fs.existsSync(target), false, 'Never overwrite sealed evidence.');
const read = name => JSON.parse(fs.readFileSync(path.join(source, name), 'utf8'));
assert.equal(read('preflight/result.json').passed, true); assert.equal(read('node/result.json').success, false);
assert.equal(read('final/result.json').passed, true);
const git = args => execFileSync('git', args, { encoding: 'utf8', windowsHide: true }).trim();
assert.equal(git(['diff', '--name-only', '--', 'src', 'package.json', 'package-lock.json']), '');
fs.mkdirSync(target); const files = [], sha = bytes => createHash('sha256').update(bytes).digest('hex');
const copy = (file, relative) => {
const bytes = fs.readFileSync(file), 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 = (folder, relative = '') => {
for (const entry of fs.readdirSync(folder, { withFileTypes: true })) {
if (['expense-project', 'identity-only', '.git', 'node_modules'].includes(entry.name)) continue;
const name = path.posix.join(relative, entry.name), file = path.join(folder, entry.name);
assert.equal(entry.isSymbolicLink(), false);
if (entry.isDirectory()) walk(file, name); else { assert.equal(entry.isFile(), true); copy(file, 'run/' + name); }
}
};
walk(source);
for (const name of ['prepare-live-delivery-p.mjs', 'live-delivery-p-initial.mjs', 'live-delivery-p-common.mjs', 'live-delivery-p-inspector.mjs',
'live-delivery-p-payload.mjs', 'live-delivery-p-preflight.mjs', 'live-delivery-p-preflight-audit.mjs', 'live-delivery-p-node.mjs',
'live-delivery-p-network.mjs', 'live-delivery-p-final-audit.mjs', 'desktop-f-state.mjs', 'seal-live-delivery-p.mjs']) copy(path.join('.qa', name), 'drivers/' + name + '.txt');
copy('docs/live-context-o-release-identity.json', 'provenance/release-1.24.5.json');
const release = JSON.parse(fs.readFileSync('docs/live-context-o-release-identity.json', 'utf8'));
const manifest = { schemaVersion: 1, kind: 'owned-live-delivery-p-evidence', createdAt: new Date().toISOString(),
version: '1.24.5', releaseSourceCommit: release.sourceCommit, experimentBaseCommit: git(['rev-parse', 'HEAD']), 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/result.json' },
note: 'Original bounded jojocode preflight and failed Node connection attempt. No HTTP response exists for the Node timeout. TLS diagnostics send no HTTP or credentials. Drivers are inert text; no replay. Original identity defaults explicitly normalized on restore; no new product release.',
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, value) => sum + value.bytes, 0), manifestSha256: sha(fs.readFileSync(path.join(target, 'manifest.json'))) }));
+394
View File
@@ -0,0 +1,394 @@
{
"schemaVersion": 1,
"kind": "owned-live-delivery-p-evidence",
"createdAt": "2026-11-03T14:41:59.187Z",
"version": "1.24.5",
"releaseSourceCommit": "676103c42635bb1ba46169ba526c135f19123244",
"experimentBaseCommit": "9d549a71a3cbdcba066eda66a7b4851015af5a3e",
"branch": "test/live-delivery-p-1.24.5",
"references": {
"initial": "run/current.json",
"preflight": "run/preflight/result.json",
"node": "run/node/result.json",
"final": "run/final/result.json",
"network": "run/network/result.json"
},
"note": "Original bounded jojocode preflight and failed Node connection attempt. No HTTP response exists for the Node timeout. TLS diagnostics send no HTTP or credentials. Drivers are inert text; no replay. Original identity defaults explicitly normalized on restore; no new product release.",
"files": [
{
"path": "drivers/desktop-f-state.mjs.txt",
"bytes": 5932,
"sha256": "6cf41ebd2ce55fe6fe3175948e9b964fac99975aca3132420a83b1d122e08b0b"
},
{
"path": "drivers/live-delivery-p-common.mjs.txt",
"bytes": 3057,
"sha256": "653ddc37c32aabfa68ee675f661085e4fa8ec7e9bcd6498a5182b17024c63611"
},
{
"path": "drivers/live-delivery-p-final-audit.mjs.txt",
"bytes": 5874,
"sha256": "e5739cbe8bc382e88a0afdf5a26ffa9593ee15f89e0a66d29eea58ff387aa25b"
},
{
"path": "drivers/live-delivery-p-initial.mjs.txt",
"bytes": 2053,
"sha256": "fa69d5dcfe74524fe84ed896b85ab16c7561480f56bd159b5fbc93d6bdd6fc62"
},
{
"path": "drivers/live-delivery-p-inspector.mjs.txt",
"bytes": 3329,
"sha256": "7735cebbdb4302de5199b754f4ddcb6517e9e9f6b49905602b6d80393d021c54"
},
{
"path": "drivers/live-delivery-p-network.mjs.txt",
"bytes": 2191,
"sha256": "0f00bd6c4a3e7b1180db04cf0f3ed003ecae3849d00628184b2f69dfe3364184"
},
{
"path": "drivers/live-delivery-p-node.mjs.txt",
"bytes": 23935,
"sha256": "85bd84617ac2be7e7bdfcc98cc75dea529048a5634d573d69cc7c5ed4f9bcda4"
},
{
"path": "drivers/live-delivery-p-payload.mjs.txt",
"bytes": 7367,
"sha256": "17dc662692bd95a37d07c6b573c38d464fa834aaaa1d0ac2d7b7f4b52900f26f"
},
{
"path": "drivers/live-delivery-p-preflight-audit.mjs.txt",
"bytes": 3090,
"sha256": "f1c5b27519f0f3ad821650780de840bf0fb23df662ccc57fe8686f78cd187269"
},
{
"path": "drivers/live-delivery-p-preflight.mjs.txt",
"bytes": 6152,
"sha256": "429d39fae981eb8211c02d971bafe56c7ba7b69e3011f310ddf308ea26ea067c"
},
{
"path": "drivers/prepare-live-delivery-p.mjs.txt",
"bytes": 2291,
"sha256": "937cb86925c199d176bfa407d4a70e609d0c96b91368c0acc04a1b7f77bb7681"
},
{
"path": "drivers/seal-live-delivery-p.mjs.txt",
"bytes": 3515,
"sha256": "40adcb33c0f10ca142d53135888790a9459aaf85e33c05b4e3dde7f21fed7286"
},
{
"path": "provenance/release-1.24.5.json",
"bytes": 4707,
"sha256": "fd5b4db6b615027eccd47ce7bd6ea709a969717f06137715aba1d36355d499c8"
},
{
"path": "run/current.json",
"bytes": 9709178,
"sha256": "ac7d0d43e2f60f3343b486e3892b74e33e772d9133de5a82984cde45a7c9a337"
},
{
"path": "run/final-audit-final.log",
"bytes": 1280,
"sha256": "c671ca58f97c4083e7b1f5e4d2e8562fdda781ddc8b41d1076bac451d7e78a22"
},
{
"path": "run/final-audit-first-driver.txt",
"bytes": 5099,
"sha256": "7e2ae60aea5ec484fbe35a0f49c6f1c9a9c021b7e78081c9a9ae651dff7310a6"
},
{
"path": "run/final-audit-first.log",
"bytes": 2948,
"sha256": "c11971612a42588f5d6c654e012ec59223aca25945d78fc3c1b2454d0cf9ae3e"
},
{
"path": "run/final/result.json",
"bytes": 1509,
"sha256": "1305229c56757ca67a4d111f8cb42a703caee775e0500127da53200fab6c9802"
},
{
"path": "run/final/snapshot.json",
"bytes": 9006724,
"sha256": "67cfce7306fbae0a03eb3f35cfa0020afeac6de3fe82c0b2bfacff3ab2c453f1"
},
{
"path": "run/network-driver.log",
"bytes": 3021,
"sha256": "7d0ba26a37b7a145e4b61c81c47f839475e1bf341e8cc348fa222f7b7ef52564"
},
{
"path": "run/network/result.json",
"bytes": 5020,
"sha256": "e71e7f6823aeed2521ba8698616666119ce507d87f147407095d661c88dfe7b2"
},
{
"path": "run/node-driver.log",
"bytes": 463,
"sha256": "5070cd331a37f9984baa675f5436f5ef5369729c414711e2171faabd7a7e6bb2"
},
{
"path": "run/node/after.json",
"bytes": 9006724,
"sha256": "6c16ac33ad6016de2c76ea1da36e3fcba058cea1a47f7ec9a96eb128538a2817"
},
{
"path": "run/node/attempts.json",
"bytes": 3428,
"sha256": "a48416f5f153e5eed3062a6393e12ee7c60e7c5e27208c5cc167e494b3b1827a"
},
{
"path": "run/node/before.json",
"bytes": 8994204,
"sha256": "ed5345c6dac5ac19c0e70d2bec18e6f422b64fd2d7b540dbbf6092b92f0ded52"
},
{
"path": "run/node/captures/bb3669eb-a878-4029-92e8-9f9ee1c1ece0-request.json",
"bytes": 23127,
"sha256": "6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3"
},
{
"path": "run/node/connection-frozen.json",
"bytes": 1415,
"sha256": "c0a45a20ccdea0a36353dacc442773771c64a6422b15e3f36bd33fc7488ffbe9"
},
{
"path": "run/node/connection-restored.json",
"bytes": 1408,
"sha256": "0b7535021ee1687e28b850e6c52aac1d339ae1e19508bdf51593099195b9a3f9"
},
{
"path": "run/node/contract.json",
"bytes": 2869,
"sha256": "5fd01465e0f1c1d61e5fd192cc799d696e03bc08161816c1044f432f2f846a1f"
},
{
"path": "run/node/declared-identity-default-normalization.json",
"bytes": 416,
"sha256": "1854e67c419dcfabdfffbced1ec2a77835e6b84da5252b09c934751ba819228a"
},
{
"path": "run/node/export.json",
"bytes": 31987,
"sha256": "4075e6fb224e324141335962910ed006ae81a260e483bfcd85569361bac7007e"
},
{
"path": "run/node/final-public-metadata.json",
"bytes": 3978,
"sha256": "a44eca9d5e48b39c2d617a2672aafda7dcd04bf871102b4a14791ca565e71c19"
},
{
"path": "run/node/git-final.json",
"bytes": 240,
"sha256": "453f10ff45a227ff6833f2061aa387dc6e7a1a42b28d16b6c5825d0615366176"
},
{
"path": "run/node/goal.txt",
"bytes": 1193,
"sha256": "d5f2cb382e917c073d379742a0dc468d7326f242d6fb9bb392da99d8af3393dd"
},
{
"path": "run/node/model-outcome.json",
"bytes": 2180,
"sha256": "885c78e117d2e0b108ecefab8cff88bbd9e1d41a787cbc2df17d9614baf4f3e7"
},
{
"path": "run/node/original-attempts.json",
"bytes": 463901,
"sha256": "a843a1d1f7eb742ea17c26f85f04755e6460975c42383f1f9387eb96fa4fef45"
},
{
"path": "run/node/original-public-metadata.json",
"bytes": 3861,
"sha256": "a4a96ed39ff2976d7a8beeea26043ccb5557bbaf1fb19642314132d687424b8e"
},
{
"path": "run/node/owned.json",
"bytes": 1784,
"sha256": "471ff3b2d4b95f632e9e675505fcfa53d1fc2c461970a4b62aa35457ad0475e4"
},
{
"path": "run/node/restoration.json",
"bytes": 825,
"sha256": "e106ffc25ef528f61b6370141a88207e671bbf3884115d5a5cd7d2ab5c78c829"
},
{
"path": "run/node/result.json",
"bytes": 2180,
"sha256": "885c78e117d2e0b108ecefab8cff88bbd9e1d41a787cbc2df17d9614baf4f3e7"
},
{
"path": "run/node/session.json",
"bytes": 29863,
"sha256": "4defddc804d647643c90b406f5f05dbf52d8162365310021b673ef9e6bdccb20"
},
{
"path": "run/node/source-after/src/amount.mjs",
"bytes": 51,
"sha256": "84cb647328ec52dad27d288f3a6127ff3e1ad87274ae2d227ad44daa49cbb2ed"
},
{
"path": "run/node/source-after/src/report.mjs",
"bytes": 52,
"sha256": "ba0a014e6e9df710d66e255a3a6f970f4e1c8af48accc81f33627029dcded7c0"
},
{
"path": "run/node/source-after/src/summary.mjs",
"bytes": 93,
"sha256": "48829850c11ca0cd0ab5e86bbac69a0c5f90297292168c1ba6dc338e2eae6ee7"
},
{
"path": "run/node/source-before/.gitignore",
"bytes": 27,
"sha256": "cab0bc87cad1b1214d71b023eee742986044093ff4b4331cd6a51098af6bdce6"
},
{
"path": "run/node/source-before/owner-staged.txt",
"bytes": 40,
"sha256": "56b0dda452eaf9aead80f0e4ad971d7befa3cf152c3553923f8fde46e1fd336a"
},
{
"path": "run/node/source-before/owner-unstaged.txt",
"bytes": 22,
"sha256": "468bfb2956a4ac040508fc5ffd915cf8057fb7420e22c41a3cc2d094785f0d3e"
},
{
"path": "run/node/source-before/owner-untracked.txt",
"bytes": 23,
"sha256": "e32ab29a12ed13d72c2ed603b2360e1b4e35afb0fe4280db2e523ad2c6c5bc8d"
},
{
"path": "run/node/source-before/package.json",
"bytes": 188,
"sha256": "6ad63026b2fe9de7513a4f6704c372a86108ee3d018a1f04883dc0a409ea4c24"
},
{
"path": "run/node/source-before/README.md",
"bytes": 136,
"sha256": "5e35a4dace9537e7c4cc815ce7054f73c171f053f1cccb9ff141f49ecb3c013e"
},
{
"path": "run/node/source-before/scripts/build.mjs",
"bytes": 475,
"sha256": "7279bc7c707c0f3ccbae63b14f0abed248ad3755be14f9e37128124ae9267526"
},
{
"path": "run/node/source-before/src/amount.mjs",
"bytes": 51,
"sha256": "84cb647328ec52dad27d288f3a6127ff3e1ad87274ae2d227ad44daa49cbb2ed"
},
{
"path": "run/node/source-before/src/report.mjs",
"bytes": 52,
"sha256": "ba0a014e6e9df710d66e255a3a6f970f4e1c8af48accc81f33627029dcded7c0"
},
{
"path": "run/node/source-before/src/summary.mjs",
"bytes": 93,
"sha256": "48829850c11ca0cd0ab5e86bbac69a0c5f90297292168c1ba6dc338e2eae6ee7"
},
{
"path": "run/node/source-before/test/expense.test.mjs",
"bytes": 2584,
"sha256": "0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839"
},
{
"path": "run/node/source-identity.json",
"bytes": 1202,
"sha256": "b95a2ccf5e392f8baac00b845c37f45284dc17f768f5e2e943863eb7af5e60f3"
},
{
"path": "run/preflight-audit-final.log",
"bytes": 479,
"sha256": "0681bca4cce1e89207ca0cc6b5f341ff438345a91ef8dc2b38cfa69d1c837cb5"
},
{
"path": "run/preflight-audit-first.log",
"bytes": 671,
"sha256": "87d402921f53743045cb658955e9eadec9b534d84c44f77818de85868adc0dab"
},
{
"path": "run/preflight-driver.log",
"bytes": 375,
"sha256": "b01b7d667c9949ffb59f305d085f456e27654b14577428fb4bde89f2e6ef3e44"
},
{
"path": "run/preflight/after.json",
"bytes": 8994204,
"sha256": "66972f8400da04a212c905d8d0fda31dfa91aa3f545f010e205fd6b66ec14eaf"
},
{
"path": "run/preflight/attempts.json",
"bytes": 4370,
"sha256": "b8383d1e8d5162732278a8ac98a796611bf68585cea9a3d39450e5c16132f301"
},
{
"path": "run/preflight/before.json",
"bytes": 8980523,
"sha256": "ab1669d1017329473ca8d4543ce89f93c57467969671a665a4114c78d9d75055"
},
{
"path": "run/preflight/captures/b36e9080-e24f-4f22-a04d-ce70240de579-request.json",
"bytes": 444,
"sha256": "ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8"
},
{
"path": "run/preflight/captures/b36e9080-e24f-4f22-a04d-ce70240de579-response.txt",
"bytes": 360,
"sha256": "c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f"
},
{
"path": "run/preflight/contract.json",
"bytes": 2483,
"sha256": "b98091ec7b32bab366530e6639d6390b4d549338b46e5d5b519bd0f275370461"
},
{
"path": "run/preflight/export.json",
"bytes": 22621,
"sha256": "839b041c657125f38972c258630ff1db7a7c38e2c176aee2ace3ee503c75a964"
},
{
"path": "run/preflight/expression.js",
"bytes": 7920,
"sha256": "f48958a1fcd692c2da505aaec596c1e1a61c81c2f1f1d7441a860cd49d36e5dc"
},
{
"path": "run/preflight/host-result.json",
"bytes": 706,
"sha256": "d5cc6bb8b1204b4134241a6ee67dcec8c95b2b4a0ffa7b8253e97e8704b76920"
},
{
"path": "run/preflight/input.json",
"bytes": 688,
"sha256": "fde0d82adbd796c6ef1ea51114f114e76d7497d30a2cf7866617537e54fdb403"
},
{
"path": "run/preflight/inspector-final.json",
"bytes": 21,
"sha256": "a54ac5bb1f80f63e97d0fdea2ed11b5d547130e28378703d643019b310611f98"
},
{
"path": "run/preflight/original-attempts.json",
"bytes": 459534,
"sha256": "c7caad9599367e2798dd745beafbedd0d568fee1393ad023bd627e99b379f3ef"
},
{
"path": "run/preflight/owned.json",
"bytes": 1788,
"sha256": "3447a7f31a5f59ff7f23fc6119083516b7449721e440ea6fb0cbcf0d9fb6aea1"
},
{
"path": "run/preflight/restoration.json",
"bytes": 558,
"sha256": "e01dccb5030e87a94ff74a8416bcf97dc3d3fe86acf46e01f1f2e962c9ed950f"
},
{
"path": "run/preflight/result.json",
"bytes": 2304,
"sha256": "65b4b5d95b4a7b57b97293c0a9bdbe8b4d54a9a65db3374dad6c95182d88180a"
},
{
"path": "run/preflight/session.json",
"bytes": 21776,
"sha256": "4eaac8413dde0e7355287ad2c69c4dd4be3ba1eb714f0858cf564179e488a85b"
}
]
}
@@ -0,0 +1,119 @@
{
"schemaVersion": 1,
"version": "1.24.5",
"sourceCommit": "676103c42635bb1ba46169ba526c135f19123244",
"candidate": "Agent-Workbench-1.24.5-win-x64-20261103133956264",
"portableRoot": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\releases\\Agent-Workbench-1.24.5-win-x64-20261103133956264",
"installedRuntimeRoot": "C:\\Users\\wangy\\AppData\\Local\\Programs\\AgentWorkbench\\versions\\Agent-Workbench-1.24.5-win-x64-20261103133956264",
"installer": {
"path": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\releases\\Agent-Workbench-1.24.5-win-x64-20261103133956264-Setup.exe",
"bytes": 213188773,
"sha256": "1060b2ef6856bff71ec2dd8f1ca997eb0b3b83d90026dfbf9a1a80a05d32b1a2",
"compiler": {
"version": "6.3.1",
"sha256": "3b22d36fc7e7c421d8caf780008ecdb42b14b3f0371b9bafe3cad64e6648d9cf"
},
"source": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\installer-build-752c83cd-ea6d-4f11-8c20-190b81a44ae2\\installer.iss",
"version": "1.24.5",
"candidateDirectory": "Agent-Workbench-1.24.5-win-x64-20261103133956264",
"qaFixture": null
},
"archives": {
"portable": {
"path": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\releases\\Agent-Workbench-1.24.5-win-x64-20261103133956264.zip",
"bytes": 242774949,
"sha256": "35f9ff5561db0ddff83fe550764c4bca8c73267d0eb7db76e690fc9dc3b88f59"
},
"source": {
"path": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\releases\\Agent-Workbench-1.24.5-source-20261103133956264.zip",
"bytes": 904093134,
"sha256": "fc570dad35e82b92eb21c26766326f8088b50d83c14e18a64ef7dbd3b9b57c2b"
},
"evidence": {
"path": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\releases\\Agent-Workbench-1.24.5-evidence-20261103133956264.zip",
"bytes": 662944972,
"sha256": "44d600b0a3d33c2b058afd8d0ff2142e414b356ba9bf016dcaba51e82e2e4392"
}
},
"documentation": {
"sourceCommit": "676103c42635bb1ba46169ba526c135f19123244",
"originalFiles": 19684,
"originalBytes": 2082068477,
"shippedFiles": 144,
"shippedBytes": 1118186,
"evidenceManifestSha256": "b537a2a752f5559ae137a55772701f52fa54fa0d862cf9dce657330f2f7634d9"
},
"formalBeforeRealSample": {
"url": "http://127.0.0.1:4318",
"pid": 36552,
"hasKey": true,
"projects": 58,
"sessions": 74,
"retention": {
"originalRows": "exact",
"originalExports": "exact",
"originalArtifactBytes": "exact",
"originalModelCenter": "exact"
},
"desktopWindows": 1,
"inspectorClosed": true,
"manifestSha256": "44e442109062fd2f33891aa414ff7b328f951948de1836cd1caf9b775342ec81",
"runtimeIdentity": "ff2a8b8d69648a32740c9725e2d88a4e4c34bd95d69497798fdd67409a45d7d9"
},
"formalAfterRealSample": {
"pid": 36552,
"version": "1.24.5",
"hasKey": true,
"active": [],
"projects": 59,
"sessions": 75,
"records": 6152,
"events": 13081,
"outbox": 13081,
"originalStateRestoration": {
"passed": true,
"originalExports": 74,
"originalArtifactFiles": 3596,
"originalRowsExact": [
"sessions",
"records",
"events",
"outbox"
],
"budgetsAndSelectionRestored": true,
"poolsUnchanged": true,
"originalPublicProjectsExact": true,
"originalAttemptsExact": 205,
"rawConfigExceptRevisionExact": true,
"registryExceptDeclaredRevisionTimestampOrderExact": true,
"otherMetadataRowsExact": true,
"originalCredentialRevision": 1,
"finalCredentialRevision": 1,
"changedOnlyMonotonicConfigAndConnectionRevisionsAndObservedHealth": true,
"pid": 36552,
"version": "1.24.5",
"noKeyExtractedOrResaved": true
}
},
"realSamples": {
"preflight": "passed",
"originalNode": "context_limit before request three; no delivery",
"fixedNode": "first response matched, second request upstream HTTP 502; no delivery",
"requests": 5,
"reportedTokens": 16227,
"unknownRequests": 1,
"estimatedUnknownTokens": 11095,
"automaticRetry": false,
"modelWeightsAuthenticated": false,
"originalPurgeBenefitTested": false
},
"evidence": {
"manifest": "docs/live-context-o-evidence/manifest.json",
"sha256": "81960cc7d2c274a9fef325969a70bd723dd01dc2af957d4335acb6bdd2ac217f",
"files": 315,
"bytes": 140408882,
"offline": "docs/live-context-o-offline.txt",
"gitIndex": "docs/live-context-o-git-index.txt"
},
"scope": "Local context fix and independently validated immutable release with exact formal upgrade retention. Separate bounded real sample ended on actual upstream 502; no verified engineering delivery or Purge benefit."
}
File diff suppressed because one or more lines are too long
@@ -0,0 +1 @@
{"passed":true,"pid":36552,"version":"1.24.5","runtimeRoot":"C:\\Users\\wangy\\AppData\\Local\\Programs\\AgentWorkbench\\versions\\Agent-Workbench-1.24.5-win-x64-20261103133956264","originalProjects":59,"originalSessions":75,"originalArtifacts":3605,"originalAttempts":207,"finalProjects":61,"finalSessions":77,"finalCounts":{"events":13115,"metadata":6,"outbox":13115,"projects":61,"records":6167,"sessions":77,"sqlite_sequence":1},"ownedProjects":["3f4d91e0-e9d4-4338-bece-b3211507888c","2732b99f-fc5b-47dc-8b07-0b8993b8761c"],"ownedSessions":["60728f43-2ff3-4279-918f-9ad4d1bc83fe","73cfff62-8e93-4056-b42d-682a37784f7b"],"addedAttempts":2,"exactSinceNodeRestoration":true,"originalSessionExportsRowsAndArtifactsExact":true,"originalPublicProjectsExact":true,"originalAttemptsExact":true,"originalBudgetsSelectionAndPoolRestored":true,"connectionRevision":[3,5],"credentialRevision":1,"identityDefaultsExplicitlyNormalized":true,"observedHealthAndStatusExcludedFromConfigurationEquality":true,"legacyDisplayRevisionFollowsGlobalConfigurationRevision":[61,65],"inspectorClosed":true,"modelRequests":2,"reportedTokens":112,"unknownRequests":1,"estimatedUnknownTokens":10141,"nodeDelivered":false,"purgeBenefitTested":false,"keyReadOrResaved":false,"productSourceChanged":false}
@@ -0,0 +1,52 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { publicSnapshot, canonical } from './desktop-f-state.mjs';
import { root, origin, dataRoot, original, connectionId, save, meta, client } from './live-delivery-p-common.mjs';
import { inspectorClosed } from './live-delivery-p-inspector.mjs';
const read = name => JSON.parse(fs.readFileSync(path.join(root, name)));
const previous = read('node/after.json'), node = read('node/result.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 after = await publicSnapshot(origin, dataRoot); save('final/snapshot.json', after);
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 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 initialCenter = original.center, center = after.modelCenter;
assert.deepEqual(center.selected, initialCenter.selected); assert.deepEqual(center.pools, initialCenter.pools);
const expectedConnection = { ...initialCenter.connections.find(value => value.id === connectionId),
modelIdentityPolicy: 'record', modelIdentityAliases: [], modelIdentityAliasSource: '' };
const actualConnection = center.connections.find(value => value.id === connectionId);
assert.equal(actualConnection.revision, expectedConnection.revision + 2); 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(value => value.id !== connectionId)) assert.deepEqual(center.connections.find(value => value.id === item.id), item);
assert.deepEqual({ ...boot.config, configRevision: original.config.configRevision }, original.config);
const ownedProjects = [read('preflight/owned.json').project.id, read('node/owned.json').project.id];
const ownedSessions = [read('preflight/owned.json').session.id, read('node/owned.json').session.id];
assert.deepEqual(boot.projects.filter(value => !ownedProjects.includes(value.id)), original.projects);
assert.deepEqual(after.database.sessionIds.filter(value => !ownedSessions.includes(value)), before.database.sessionIds);
const attempts = meta('modelAttempts'), oldAttempts = read('preflight/original-attempts.json');
for (const item of oldAttempts) assert.deepEqual(attempts.find(value => value.id === item.id), item);
const added = attempts.filter(value => !oldAttempts.some(item => item.id === value.id));
assert.equal(added.length, 2); assert.ok(added.every(value => ownedSessions.includes(value.sessionId)));
for (const name of ['src/amount.mjs', 'src/summary.mjs', 'src/report.mjs']) assert.deepEqual(fs.readFileSync(path.join(root, 'node/source-before', name)), fs.readFileSync(path.join(root, 'node/source-after', name)));
assert.deepEqual(node.approvals, []); assert.deepEqual(node.applications, []);
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,
finalCounts: Object.fromEntries(Object.entries(after.database.tables).map(([name, table]) => [name, table.count])),
ownedProjects, ownedSessions, addedAttempts: added.length, exactSinceNodeRestoration: true,
originalSessionExportsRowsAndArtifactsExact: true, originalPublicProjectsExact: true, originalAttemptsExact: true,
originalBudgetsSelectionAndPoolRestored: true, connectionRevision: [expectedConnection.revision, actualConnection.revision], credentialRevision: 1,
identityDefaultsExplicitlyNormalized: true, observedHealthAndStatusExcludedFromConfigurationEquality: true,
inspectorClosed: await inspectorClosed(), modelRequests: 2, reportedTokens: 112, unknownRequests: 1, estimatedUnknownTokens: 10141,
nodeDelivered: false, purgeBenefitTested: false, keyReadOrResaved: false, productSourceChanged: false };
save('final/result.json', result); console.log(JSON.stringify(result));
} finally { await close(); }
@@ -0,0 +1,108 @@
node:internal/modules/run_main:107
triggerUncaughtException(
^
AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
+ actual - expected
... Skipped lines
{
activeRequests: 0,
baseUrl: 'https://jojocode.com/v1',
brand: '兼容服务',
capabilities: {
...
requiresKey: false,
+ revision: 65,
- revision: 61,
savedCredential: {
message: '当前凭据只在宿主内存中。',
status: 'not_saved',
storage: 'memory'
},
at file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/.qa/live-delivery-p-final-audit.mjs:29:99
at process.processTicksAndRejections (node:internal/process/task_queues:104:5) {
generatedMessage: true,
code: 'ERR_ASSERTION',
actual: {
id: 'legacy-default',
name: '原模型连接',
brand: '兼容服务',
protocol: 'chat-completions',
baseUrl: 'https://jojocode.com/v1',
model: 'gpt-6.1-sol',
enabled: true,
requiresKey: false,
revision: 65,
contextLimit: 16000,
maxOutputTokens: 2048,
concurrency: 1,
source: 'legacy',
hasKey: true,
credentialRevision: 1,
credentialStorage: 'memory',
savedCredential: { status: 'not_saved', storage: 'memory', message: '当前凭据只在宿主内存中。' },
status: 'configured',
activeRequests: 0,
health: { state: 'unverified' },
streaming: false,
capabilitySchema: 1,
capabilityDeclarations: {
text: 'supported',
tools: 'supported',
streaming: 'unknown',
vision: 'unknown',
audio: 'unknown'
},
capabilities: {
text: 'protocol_declared',
tools: 'protocol_declared',
streaming: 'unknown',
vision: 'unknown',
audio: 'unknown'
}
},
expected: {
id: 'legacy-default',
name: '原模型连接',
brand: '兼容服务',
protocol: 'chat-completions',
baseUrl: 'https://jojocode.com/v1',
model: 'gpt-6.1-sol',
enabled: true,
requiresKey: false,
revision: 61,
contextLimit: 16000,
maxOutputTokens: 2048,
concurrency: 1,
source: 'legacy',
hasKey: true,
credentialRevision: 1,
credentialStorage: 'memory',
savedCredential: { status: 'not_saved', storage: 'memory', message: '当前凭据只在宿主内存中。' },
status: 'configured',
activeRequests: 0,
health: { state: 'unverified' },
streaming: false,
capabilitySchema: 1,
capabilityDeclarations: {
text: 'supported',
tools: 'supported',
streaming: 'unknown',
vision: 'unknown',
audio: 'unknown'
},
capabilities: {
text: 'protocol_declared',
tools: 'protocol_declared',
streaming: 'unknown',
vision: 'unknown',
audio: 'unknown'
}
},
operator: 'deepStrictEqual',
diff: 'simple'
}
Node.js v24.22.1
@@ -0,0 +1,55 @@
{
"passed": true,
"pid": 36552,
"version": "1.24.5",
"runtimeRoot": "C:\\Users\\wangy\\AppData\\Local\\Programs\\AgentWorkbench\\versions\\Agent-Workbench-1.24.5-win-x64-20261103133956264",
"originalProjects": 59,
"originalSessions": 75,
"originalArtifacts": 3605,
"originalAttempts": 207,
"finalProjects": 61,
"finalSessions": 77,
"finalCounts": {
"events": 13115,
"metadata": 6,
"outbox": 13115,
"projects": 61,
"records": 6167,
"sessions": 77,
"sqlite_sequence": 1
},
"ownedProjects": [
"3f4d91e0-e9d4-4338-bece-b3211507888c",
"2732b99f-fc5b-47dc-8b07-0b8993b8761c"
],
"ownedSessions": [
"60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"73cfff62-8e93-4056-b42d-682a37784f7b"
],
"addedAttempts": 2,
"exactSinceNodeRestoration": true,
"originalSessionExportsRowsAndArtifactsExact": true,
"originalPublicProjectsExact": true,
"originalAttemptsExact": true,
"originalBudgetsSelectionAndPoolRestored": true,
"connectionRevision": [
3,
5
],
"credentialRevision": 1,
"identityDefaultsExplicitlyNormalized": true,
"observedHealthAndStatusExcludedFromConfigurationEquality": true,
"legacyDisplayRevisionFollowsGlobalConfigurationRevision": [
61,
65
],
"inspectorClosed": true,
"modelRequests": 2,
"reportedTokens": 112,
"unknownRequests": 1,
"estimatedUnknownTokens": 10141,
"nodeDelivered": false,
"purgeBenefitTested": false,
"keyReadOrResaved": false,
"productSourceChanged": false
}
File diff suppressed because one or more lines are too long
@@ -0,0 +1 @@
{"recordedAt":"2026-11-03T14:38:53.070Z","results":[{"round":1,"host":"jojocode.com","lookup":[{"address":"2606:4700:3035::ac43:928c","family":6},{"address":"2606:4700:3030::6815:2f68","family":6},{"address":"172.67.146.140","family":4},{"address":"104.21.47.104","family":4}],"trials":[{"mode":"same-family-selection-as-provider","success":true,"protocol":"TLSv1.3","certificateAuthorized":true,"address":"2606:4700:3035::ac43:928c","elapsedMs":2056},{"mode":"ipv4-only-diagnostic","success":true,"protocol":"TLSv1.3","certificateAuthorized":true,"address":"172.67.146.140","elapsedMs":6141},{"mode":"ipv6-only-diagnostic","success":true,"protocol":"TLSv1.3","certificateAuthorized":true,"address":"2606:4700:3035::ac43:928c","elapsedMs":6101}]},{"round":1,"host":"api.apikey.fan","lookup":[{"address":"2606:4700::6812:1a5","family":6},{"address":"2606:4700::6812:a5","family":6},{"address":"104.18.0.165","family":4},{"address":"104.18.1.165","family":4}],"trials":[{"mode":"same-family-selection-as-provider","success":true,"protocol":"TLSv1.3","certificateAuthorized":true,"address":"104.18.1.165","elapsedMs":1478},{"mode":"ipv4-only-diagnostic","success":true,"protocol":"TLSv1.3","certificateAuthorized":true,"address":"104.18.0.165","elapsedMs":757},{"mode":"ipv6-only-diagnostic","success":true,"protocol":"TLSv1.3","certificateAuthorized":true,"address":"2606:4700::6812:1a5","elapsedMs":755}]},{"round":2,"host":"jojocode.com","lookup":[{"address":"2606:4700:3035::ac43:928c","family":6},{"address":"2606:4700:3030::6815:2f68","family":6},{"address":"172.67.146.140","family":4},{"address":"104.21.47.104","family":4}],"trials":[{"mode":"same-family-selection-as-provider","success":true,"protocol":"TLSv1.3","certificateAuthorized":true,"address":"2606:4700:3030::6815:2f68","elapsedMs":1083},{"mode":"ipv4-only-diagnostic","success":true,"protocol":"TLSv1.3","certificateAuthorized":true,"address":"172.67.146.140","elapsedMs":628},{"mode":"ipv6-only-diagnostic","success":false,"code":"QA_TLS_TIMEOUT","address":"2606:4700:3035::ac43:928c","elapsedMs":11007}]},{"round":2,"host":"api.apikey.fan","lookup":[{"address":"2606:4700::6812:1a5","family":6},{"address":"2606:4700::6812:a5","family":6},{"address":"104.18.0.165","family":4},{"address":"104.18.1.165","family":4}],"trials":[{"mode":"same-family-selection-as-provider","success":true,"protocol":"TLSv1.3","certificateAuthorized":true,"address":"104.18.1.165","elapsedMs":3655},{"mode":"ipv4-only-diagnostic","success":true,"protocol":"TLSv1.3","certificateAuthorized":true,"address":"104.18.0.165","elapsedMs":1919},{"mode":"ipv6-only-diagnostic","success":true,"protocol":"TLSv1.3","certificateAuthorized":true,"address":"2606:4700::6812:1a5","elapsedMs":646}]}],"realModelRequests":0,"httpRequests":0,"tlsCertificateValidationEnabled":true,"keyValuesReadOrSent":false,"productConfigurationChanged":false,"scope":"DNS and authenticated TLS handshake only; no HTTP headers/body, no original request replay, and no proof of model/API availability."}
@@ -0,0 +1,202 @@
{
"recordedAt": "2026-11-03T14:38:53.070Z",
"results": [
{
"round": 1,
"host": "jojocode.com",
"lookup": [
{
"address": "2606:4700:3035::ac43:928c",
"family": 6
},
{
"address": "2606:4700:3030::6815:2f68",
"family": 6
},
{
"address": "172.67.146.140",
"family": 4
},
{
"address": "104.21.47.104",
"family": 4
}
],
"trials": [
{
"mode": "same-family-selection-as-provider",
"success": true,
"protocol": "TLSv1.3",
"certificateAuthorized": true,
"address": "2606:4700:3035::ac43:928c",
"elapsedMs": 2056
},
{
"mode": "ipv4-only-diagnostic",
"success": true,
"protocol": "TLSv1.3",
"certificateAuthorized": true,
"address": "172.67.146.140",
"elapsedMs": 6141
},
{
"mode": "ipv6-only-diagnostic",
"success": true,
"protocol": "TLSv1.3",
"certificateAuthorized": true,
"address": "2606:4700:3035::ac43:928c",
"elapsedMs": 6101
}
]
},
{
"round": 1,
"host": "api.apikey.fan",
"lookup": [
{
"address": "2606:4700::6812:1a5",
"family": 6
},
{
"address": "2606:4700::6812:a5",
"family": 6
},
{
"address": "104.18.0.165",
"family": 4
},
{
"address": "104.18.1.165",
"family": 4
}
],
"trials": [
{
"mode": "same-family-selection-as-provider",
"success": true,
"protocol": "TLSv1.3",
"certificateAuthorized": true,
"address": "104.18.1.165",
"elapsedMs": 1478
},
{
"mode": "ipv4-only-diagnostic",
"success": true,
"protocol": "TLSv1.3",
"certificateAuthorized": true,
"address": "104.18.0.165",
"elapsedMs": 757
},
{
"mode": "ipv6-only-diagnostic",
"success": true,
"protocol": "TLSv1.3",
"certificateAuthorized": true,
"address": "2606:4700::6812:1a5",
"elapsedMs": 755
}
]
},
{
"round": 2,
"host": "jojocode.com",
"lookup": [
{
"address": "2606:4700:3035::ac43:928c",
"family": 6
},
{
"address": "2606:4700:3030::6815:2f68",
"family": 6
},
{
"address": "172.67.146.140",
"family": 4
},
{
"address": "104.21.47.104",
"family": 4
}
],
"trials": [
{
"mode": "same-family-selection-as-provider",
"success": true,
"protocol": "TLSv1.3",
"certificateAuthorized": true,
"address": "2606:4700:3030::6815:2f68",
"elapsedMs": 1083
},
{
"mode": "ipv4-only-diagnostic",
"success": true,
"protocol": "TLSv1.3",
"certificateAuthorized": true,
"address": "172.67.146.140",
"elapsedMs": 628
},
{
"mode": "ipv6-only-diagnostic",
"success": false,
"code": "QA_TLS_TIMEOUT",
"address": "2606:4700:3035::ac43:928c",
"elapsedMs": 11007
}
]
},
{
"round": 2,
"host": "api.apikey.fan",
"lookup": [
{
"address": "2606:4700::6812:1a5",
"family": 6
},
{
"address": "2606:4700::6812:a5",
"family": 6
},
{
"address": "104.18.0.165",
"family": 4
},
{
"address": "104.18.1.165",
"family": 4
}
],
"trials": [
{
"mode": "same-family-selection-as-provider",
"success": true,
"protocol": "TLSv1.3",
"certificateAuthorized": true,
"address": "104.18.1.165",
"elapsedMs": 3655
},
{
"mode": "ipv4-only-diagnostic",
"success": true,
"protocol": "TLSv1.3",
"certificateAuthorized": true,
"address": "104.18.0.165",
"elapsedMs": 1919
},
{
"mode": "ipv6-only-diagnostic",
"success": true,
"protocol": "TLSv1.3",
"certificateAuthorized": true,
"address": "2606:4700::6812:1a5",
"elapsedMs": 646
}
]
}
],
"realModelRequests": 0,
"httpRequests": 0,
"tlsCertificateValidationEnabled": true,
"keyValuesReadOrSent": false,
"productConfigurationChanged": false,
"scope": "DNS and authenticated TLS handshake only; no HTTP headers/body, no original request replay, and no proof of model/API availability."
}
@@ -0,0 +1,3 @@
{"status":"running","requests":0,"tokens":0,"checks":[],"elapsedSeconds":10}
{"status":"failed","requests":1,"tokens":0,"checks":[],"elapsedSeconds":20}
{"success":false,"attempts":1,"usage":{"requests":1,"inputTokens":0,"outputTokens":0,"totalTokens":0,"unknownRequests":1,"estimatedUnknownTokens":10141},"state":"failed","stopReason":null,"error":"模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。"}
File diff suppressed because one or more lines are too long
@@ -0,0 +1,92 @@
[
{
"id": "bb3669eb-a878-4029-92e8-9f9ee1c1ece0",
"requestId": "ff49f738-f19d-479c-8508-16b845e2047e",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"sessionId": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"connectionRevision": 4,
"credentialRevision": 1,
"poolId": null,
"poolRevision": 4,
"model": "gpt-6.1-sol",
"protocol": "chat-completions",
"streaming": false,
"endpoint": "https://jojocode.com/v1",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"ordinal": 1,
"status": "failed",
"startedAt": "2026-11-03T14:37:29.308Z",
"requestBytes": 23127,
"requirements": [
"text",
"tools"
],
"rejections": [],
"requestSha256": "6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3",
"usage": null,
"usageStatus": "unknown",
"requestArtifactId": "caddb9bf-0648-4f0e-b928-d630b9df9d62",
"wireAttemptId": "a1ee34cd-e67b-4bc5-af55-f3e62e8ba03a",
"modelIdentity": {
"schemaVersion": 1,
"requestedModel": "gpt-6.1-sol",
"reportedModels": [],
"status": "incomplete",
"complete": false,
"invalidIdentifiers": false,
"policy": "require-match",
"scope": "Identifiers in the outgoing request and upstream response; neither equal identifiers nor a declared mapping authenticate model weights."
},
"diagnostic": {
"id": "4e4ed0df-a715-4a74-8538-2d3f7f01286e",
"source": "model_connection",
"origin": "local",
"stage": "model_request",
"kind": "timeout",
"code": "UND_ERR_CONNECT_TIMEOUT",
"endpoint": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"route": "/chat/completions",
"attempts": 1,
"occurredAt": "2026-11-03T14:37:39.918Z",
"retryable": true,
"failoverAllowed": false,
"outcome": "failed",
"network": {
"stage": "connect",
"replaySafety": "before_model_send",
"responseReceived": false,
"causesComplete": true,
"transport": {
"schemaVersion": 1,
"implementation": "undici-7.30.1",
"autoSelectFamily": true,
"familyAttemptTimeoutMs": 250,
"connectTimeoutMs": 10000,
"httpProxyConfigured": false,
"httpsProxyConfigured": false,
"noProxyConfigured": false
},
"causes": [
{
"code": "UND_ERR_CONNECT_TIMEOUT"
}
]
},
"title": "模型服务连接超时",
"message": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"suggestion": "核对网络、DNS、IPv4/IPv6候选及代理;这是建立连接时超时,增加模型响应等待时限不能修复连接。",
"detail": "模型服务连接超时",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"wireAttemptId": "a1ee34cd-e67b-4bc5-af55-f3e62e8ba03a",
"retryDecision": "attempt_limit",
"remainingWaitBudgetMs": 289396
},
"reason": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"httpStatus": null,
"finishedAt": "2026-11-03T14:37:39.928Z"
}
]
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@@ -0,0 +1,53 @@
{
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"name": "jojocode",
"brand": "兼容服务",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
},
"streaming": false,
"modelIdentityPolicy": "require-match",
"modelIdentityAliases": [],
"modelIdentityAliasSource": "",
"baseUrl": "https://jojocode.com/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 4,
"source": "manual",
"createdAt": "2026-10-30T14:36:37.791Z",
"updatedAt": "2026-11-03T14:37:29.114Z",
"hasKey": true,
"credentialRevision": 1,
"credentialStorage": "memory",
"savedCredential": {
"storage": "windows-user-dpapi",
"status": "source_changed",
"enabled": true,
"connectionRevision": 2,
"credentialRevision": 1,
"savedAt": "2026-10-31T11:30:08.471Z",
"message": "原保存块无法用于当前连接;重新填写后保存,或删除原保存。"
},
"status": "configured",
"activeRequests": 0,
"health": {
"state": "unverified"
},
"capabilities": {
"text": "protocol_declared",
"tools": "protocol_declared",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
}
}
@@ -0,0 +1,53 @@
{
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"name": "jojocode",
"brand": "兼容服务",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
},
"streaming": false,
"modelIdentityPolicy": "record",
"modelIdentityAliases": [],
"modelIdentityAliasSource": "",
"baseUrl": "https://jojocode.com/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 5,
"source": "manual",
"createdAt": "2026-10-30T14:36:37.791Z",
"updatedAt": "2026-11-03T14:37:41.151Z",
"hasKey": true,
"credentialRevision": 1,
"credentialStorage": "memory",
"savedCredential": {
"storage": "windows-user-dpapi",
"status": "source_changed",
"enabled": true,
"connectionRevision": 2,
"credentialRevision": 1,
"savedAt": "2026-10-31T11:30:08.471Z",
"message": "原保存块无法用于当前连接;重新填写后保存,或删除原保存。"
},
"status": "configured",
"activeRequests": 0,
"health": {
"state": "unverified"
},
"capabilities": {
"text": "protocol_declared",
"tools": "protocol_declared",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
}
}
@@ -0,0 +1,92 @@
{
"kind": "new-real-Node-engineering",
"version": "1.24.5",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"connection": {
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"name": "jojocode",
"brand": "兼容服务",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
},
"streaming": false,
"baseUrl": "https://jojocode.com/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 3,
"source": "manual",
"createdAt": "2026-10-30T14:36:37.791Z",
"updatedAt": "2026-11-02T13:25:07.450Z",
"hasKey": true,
"credentialRevision": 1,
"credentialStorage": "memory",
"savedCredential": {
"storage": "windows-user-dpapi",
"status": "source_changed",
"enabled": true,
"connectionRevision": 2,
"credentialRevision": 1,
"savedAt": "2026-10-31T11:30:08.471Z",
"message": "原保存块无法用于当前连接;重新填写后保存,或删除原保存。"
},
"status": "configured",
"activeRequests": 0,
"health": {
"state": "responded",
"lastSuccessAt": "2026-11-03T14:34:55.022Z",
"cooldownUntil": 0,
"failures": 0
},
"capabilities": {
"text": "protocol_declared",
"tools": "protocol_declared",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
}
},
"maxRequests": 8,
"maxTokens": 90000,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"maxDurationMs": 600000,
"allowed": [
"src/amount.mjs",
"src/summary.mjs",
"src/report.mjs"
],
"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": {
"type": "pool",
"id": "68e30376-b799-445b-a858-db2dba9920a0"
},
"originalBudgets": {
"contextLimit": 16000,
"maxSteps": 12,
"maxOutputTokens": 2048,
"maxRunTokens": 200000,
"maxTaskTokens": 1000000,
"maxRunDurationMs": 600000
},
"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."
}
@@ -0,0 +1,11 @@
{
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"added": {
"modelIdentityPolicy": "record",
"modelIdentityAliases": [],
"modelIdentityAliasSource": ""
},
"originalRawStatePreserved": true,
"originalSemanticsRestored": true,
"reason": "The public partial-update API retains missing fields; restore explicit original default semantics rather than silently retaining require-match."
}
@@ -0,0 +1,736 @@
{
"schemaVersion": 1,
"executionSchemaVersion": 1,
"exportedAt": "2026-11-03T14:37:40.271Z",
"project": {
"id": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\node\\expense-project",
"name": "expense-project",
"addedAt": "2026-11-03T14:37:29.107Z"
},
"session": {
"id": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"title": "修复这个Node费用报表工程的amount、summar",
"status": "failed",
"createdAt": "2026-11-03T14:37:29.110Z",
"updatedAt": "2026-11-03T14:37:39.945Z",
"messages": [
{
"id": "cbdafe54-21f1-4a86-994f-c7ff8a04203a",
"role": "user",
"content": "修复这个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,请合并独立工具调用并避免重复观察。",
"createdAt": "2026-11-03T14:37:29.290Z"
},
{
"id": "4aeace4a-6cf9-44b4-af8b-844877d121cf",
"role": "system",
"content": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"createdAt": "2026-11-03T14:37:39.933Z"
}
],
"providerMessages": [
{
"role": "user",
"content": "修复这个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,请合并独立工具调用并避免重复观察。"
}
],
"events": [
{
"id": "b1eebbf6-ad23-4e5b-872d-022e3df0283f",
"createdAt": "2026-11-03T14:37:29.315Z",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"kind": "model",
"source": "model_connection",
"label": "模型连接失败",
"phase": "failed",
"startedAt": "2026-11-03T14:37:29.315Z",
"contextPlanId": "ff49f738-f19d-479c-8508-16b845e2047e",
"attempts": 1,
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"modelAttemptId": "bb3669eb-a878-4029-92e8-9f9ee1c1ece0",
"actualModel": "gpt-6.1-sol",
"output": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"diagnostic": {
"id": "4e4ed0df-a715-4a74-8538-2d3f7f01286e",
"source": "model_connection",
"origin": "local",
"stage": "model_request",
"kind": "timeout",
"code": "UND_ERR_CONNECT_TIMEOUT",
"endpoint": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"route": "/chat/completions",
"attempts": 1,
"occurredAt": "2026-11-03T14:37:39.918Z",
"retryable": true,
"failoverAllowed": false,
"outcome": "failed",
"network": {
"stage": "connect",
"replaySafety": "before_model_send",
"responseReceived": false,
"causesComplete": true,
"transport": {
"schemaVersion": 1,
"implementation": "undici-7.30.1",
"autoSelectFamily": true,
"familyAttemptTimeoutMs": 250,
"connectTimeoutMs": 10000,
"httpProxyConfigured": false,
"httpsProxyConfigured": false,
"noProxyConfigured": false
},
"causes": [
{
"code": "UND_ERR_CONNECT_TIMEOUT"
}
]
},
"title": "模型服务连接超时",
"message": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"suggestion": "核对网络、DNS、IPv4/IPv6候选及代理;这是建立连接时超时,增加模型响应等待时限不能修复连接。",
"detail": "模型服务连接超时",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"wireAttemptId": "a1ee34cd-e67b-4bc5-af55-f3e62e8ba03a",
"retryDecision": "attempt_limit",
"remainingWaitBudgetMs": 289396
},
"durationMs": 10604,
"finishedAt": "2026-11-03T14:37:39.918Z"
},
{
"id": "c3a286ca-9d67-4d59-a870-2cfa784b10c9",
"createdAt": "2026-11-03T14:37:39.936Z",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"kind": "error",
"source": "model_connection",
"label": "模型服务连接超时",
"phase": "failed",
"output": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"diagnostic": {
"id": "4e4ed0df-a715-4a74-8538-2d3f7f01286e",
"source": "model_connection",
"origin": "local",
"stage": "model_request",
"kind": "timeout",
"code": "UND_ERR_CONNECT_TIMEOUT",
"endpoint": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"route": "/chat/completions",
"attempts": 1,
"occurredAt": "2026-11-03T14:37:39.918Z",
"retryable": true,
"failoverAllowed": false,
"outcome": "failed",
"network": {
"stage": "connect",
"replaySafety": "before_model_send",
"responseReceived": false,
"causesComplete": true,
"transport": {
"schemaVersion": 1,
"implementation": "undici-7.30.1",
"autoSelectFamily": true,
"familyAttemptTimeoutMs": 250,
"connectTimeoutMs": 10000,
"httpProxyConfigured": false,
"httpsProxyConfigured": false,
"noProxyConfigured": false
},
"causes": [
{
"code": "UND_ERR_CONNECT_TIMEOUT"
}
]
},
"title": "模型服务连接超时",
"message": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"suggestion": "核对网络、DNS、IPv4/IPv6候选及代理;这是建立连接时超时,增加模型响应等待时限不能修复连接。",
"detail": "模型服务连接超时",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"wireAttemptId": "a1ee34cd-e67b-4bc5-af55-f3e62e8ba03a",
"retryDecision": "attempt_limit",
"remainingWaitBudgetMs": 289396,
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96"
}
}
],
"changes": [],
"approvals": [],
"failure": {
"id": "4e4ed0df-a715-4a74-8538-2d3f7f01286e",
"source": "model_connection",
"origin": "local",
"stage": "model_request",
"kind": "timeout",
"code": "UND_ERR_CONNECT_TIMEOUT",
"endpoint": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"route": "/chat/completions",
"attempts": 1,
"occurredAt": "2026-11-03T14:37:39.918Z",
"retryable": true,
"failoverAllowed": false,
"outcome": "failed",
"network": {
"stage": "connect",
"replaySafety": "before_model_send",
"responseReceived": false,
"causesComplete": true,
"transport": {
"schemaVersion": 1,
"implementation": "undici-7.30.1",
"autoSelectFamily": true,
"familyAttemptTimeoutMs": 250,
"connectTimeoutMs": 10000,
"httpProxyConfigured": false,
"httpsProxyConfigured": false,
"noProxyConfigured": false
},
"causes": [
{
"code": "UND_ERR_CONNECT_TIMEOUT"
}
]
},
"title": "模型服务连接超时",
"message": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"suggestion": "核对网络、DNS、IPv4/IPv6候选及代理;这是建立连接时超时,增加模型响应等待时限不能修复连接。",
"detail": "模型服务连接超时",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"wireAttemptId": "a1ee34cd-e67b-4bc5-af55-f3e62e8ba03a",
"retryDecision": "attempt_limit",
"remainingWaitBudgetMs": 289396,
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"messageId": "4aeace4a-6cf9-44b4-af8b-844877d121cf"
},
"lastFailure": {
"id": "4e4ed0df-a715-4a74-8538-2d3f7f01286e",
"source": "model_connection",
"origin": "local",
"stage": "model_request",
"kind": "timeout",
"code": "UND_ERR_CONNECT_TIMEOUT",
"endpoint": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"route": "/chat/completions",
"attempts": 1,
"occurredAt": "2026-11-03T14:37:39.918Z",
"retryable": true,
"failoverAllowed": false,
"outcome": "failed",
"network": {
"stage": "connect",
"replaySafety": "before_model_send",
"responseReceived": false,
"causesComplete": true,
"transport": {
"schemaVersion": 1,
"implementation": "undici-7.30.1",
"autoSelectFamily": true,
"familyAttemptTimeoutMs": 250,
"connectTimeoutMs": 10000,
"httpProxyConfigured": false,
"httpsProxyConfigured": false,
"noProxyConfigured": false
},
"causes": [
{
"code": "UND_ERR_CONNECT_TIMEOUT"
}
]
},
"title": "模型服务连接超时",
"message": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"suggestion": "核对网络、DNS、IPv4/IPv6候选及代理;这是建立连接时超时,增加模型响应等待时限不能修复连接。",
"detail": "模型服务连接超时",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"wireAttemptId": "a1ee34cd-e67b-4bc5-af55-f3e62e8ba03a",
"retryDecision": "attempt_limit",
"remainingWaitBudgetMs": 289396,
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96"
},
"compactions": 0,
"estimatedTokens": 8093,
"usage": null,
"archived": false,
"revision": 17,
"eventSeq": 13115,
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"recoveryNotice": null,
"executionMode": "compatible"
},
"execution": {
"schemaVersion": 1,
"task": {
"schemaVersion": 1,
"id": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"sessionId": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"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,请合并独立工具调用并避免重复观察。",
"instructions": [],
"constraints": [],
"acceptance": [],
"status": "failed",
"previousTaskId": null,
"createdAt": "2026-11-03T14:37:29.288Z",
"updatedAt": "2026-11-03T14:37:39.945Z",
"activeRunId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"usage": {
"requests": 1,
"inputTokens": 0,
"outputTokens": 0,
"totalTokens": 0,
"unknownRequests": 1,
"estimatedUnknownTokens": 10141
},
"budget": {
"maxTokens": 90000
},
"verification": {
"status": "not_configured",
"checkJobId": null
},
"origin": "workbench",
"contract": {
"schemaVersion": 1,
"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,请合并独立工具调用并避免重复观察。",
"kind": "general",
"checks": "required"
},
"workspaceIdentity": {
"kind": "local-project",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\node\\expense-project"
},
"stagnation": null
},
"run": {
"schemaVersion": 1,
"id": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"sessionId": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"engine": "workbench",
"status": "failed",
"startedAt": "2026-11-03T14:37:29.288Z",
"finishedAt": "2026-11-03T14:37:39.945Z",
"resumeOf": null,
"model": {
"mode": "compatible",
"baseUrl": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"contextLimit": 16000,
"maxOutputTokens": 2048,
"configRevision": 63,
"modelResponseTimeoutMs": 300000,
"modelStreamIdleTimeoutMs": 120000,
"protocol": "chat-completions",
"streaming": false,
"nativeParameters": {},
"routing": {
"type": "connection",
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"revision": 4,
"strategy": "round-robin",
"sticky": true,
"maxAttempts": 1,
"queueTimeoutMs": 15000,
"members": [
{
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"name": "jojocode",
"brand": "兼容服务",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
},
"streaming": false,
"modelIdentityPolicy": "require-match",
"modelIdentityAliases": [],
"modelIdentityAliasSource": "",
"baseUrl": "https://jojocode.com/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 4,
"source": "manual",
"createdAt": "2026-10-30T14:36:37.791Z",
"updatedAt": "2026-11-03T14:37:29.114Z",
"weight": 1,
"credentialRevision": 1
}
]
}
},
"budget": {
"maxSteps": 8,
"maxDurationMs": 600000,
"maxTokens": 90000,
"maxTaskTokens": 90000
},
"usage": {
"requests": 1,
"inputTokens": 0,
"outputTokens": 0,
"totalTokens": 0,
"unknownRequests": 1,
"estimatedUnknownTokens": 10141
},
"steps": 1,
"toolCalls": 0,
"stopReason": null,
"checkpoint": {
"stepId": "f21d3594-bc6b-4339-9c8e-f1a17608a581",
"completedToolIds": [],
"pendingToolIds": [],
"requiresVerification": []
},
"origin": "workbench",
"purpose": "execution",
"workspaceIdentity": {
"kind": "local-project",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\node\\expense-project"
},
"currentContextPlanId": "ff49f738-f19d-479c-8508-16b845e2047e",
"consumption": [
{
"attemptId": "bb3669eb-a878-4029-92e8-9f9ee1c1ece0",
"requestId": "ff49f738-f19d-479c-8508-16b845e2047e",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"connectionName": "jojocode",
"model": "gpt-6.1-sol",
"endpoint": "https://jojocode.com/v1",
"protocol": "chat-completions",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"responseUrl": null,
"redirected": false,
"startedAt": "2026-11-03T14:37:29.314Z",
"finishedAt": "2026-11-03T14:37:39.922Z",
"outcome": "failed",
"usageStatus": "unknown",
"usage": null,
"localEstimate": {
"schemaVersion": 1,
"inputTokens": 8093,
"outputTokens": 2048,
"requestSha256": "6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3",
"requestBytes": 23127,
"estimateMethod": "utf8-third-plus-framing-v1"
},
"modelIdentity": {
"schemaVersion": 1,
"requestedModel": "gpt-6.1-sol",
"reportedModels": [],
"status": "incomplete",
"complete": false,
"invalidIdentifiers": false,
"policy": "require-match",
"scope": "Identifiers in the outgoing request and upstream response; neither equal identifiers nor a declared mapping authenticate model weights."
},
"estimatedUnknownTokens": 10141
}
]
},
"workspaceIdentity": {
"kind": "local-project",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\node\\expense-project"
},
"workspaces": [],
"runs": [
{
"id": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"status": "failed",
"startedAt": "2026-11-03T14:37:29.288Z",
"finishedAt": "2026-11-03T14:37:39.945Z",
"steps": 1,
"toolCalls": 0,
"usage": {
"requests": 1,
"inputTokens": 0,
"outputTokens": 0,
"totalTokens": 0,
"unknownRequests": 1,
"estimatedUnknownTokens": 10141
},
"stopReason": null,
"model": {
"mode": "compatible",
"baseUrl": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"contextLimit": 16000,
"maxOutputTokens": 2048,
"configRevision": 63,
"modelResponseTimeoutMs": 300000,
"modelStreamIdleTimeoutMs": 120000,
"protocol": "chat-completions",
"streaming": false,
"nativeParameters": {},
"routing": {
"type": "connection",
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"revision": 4,
"strategy": "round-robin",
"sticky": true,
"maxAttempts": 1,
"queueTimeoutMs": 15000,
"members": [
{
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"name": "jojocode",
"brand": "兼容服务",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
},
"streaming": false,
"modelIdentityPolicy": "require-match",
"modelIdentityAliases": [],
"modelIdentityAliasSource": "",
"baseUrl": "https://jojocode.com/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 4,
"source": "manual",
"createdAt": "2026-10-30T14:36:37.791Z",
"updatedAt": "2026-11-03T14:37:29.114Z",
"weight": 1,
"credentialRevision": 1
}
]
}
},
"budget": {
"maxSteps": 8,
"maxDurationMs": 600000,
"maxTokens": 90000,
"maxTaskTokens": 90000
},
"resumeOf": null,
"purpose": "execution",
"consumption": [
{
"attemptId": "bb3669eb-a878-4029-92e8-9f9ee1c1ece0",
"requestId": "ff49f738-f19d-479c-8508-16b845e2047e",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"connectionName": "jojocode",
"model": "gpt-6.1-sol",
"endpoint": "https://jojocode.com/v1",
"protocol": "chat-completions",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"responseUrl": null,
"redirected": false,
"startedAt": "2026-11-03T14:37:29.314Z",
"finishedAt": "2026-11-03T14:37:39.922Z",
"outcome": "failed",
"usageStatus": "unknown",
"usage": null,
"localEstimate": {
"schemaVersion": 1,
"inputTokens": 8093,
"outputTokens": 2048,
"requestSha256": "6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3",
"requestBytes": 23127,
"estimateMethod": "utf8-third-plus-framing-v1"
},
"modelIdentity": {
"schemaVersion": 1,
"requestedModel": "gpt-6.1-sol",
"reportedModels": [],
"status": "incomplete",
"complete": false,
"invalidIdentifiers": false,
"policy": "require-match",
"scope": "Identifiers in the outgoing request and upstream response; neither equal identifiers nor a declared mapping authenticate model weights."
},
"estimatedUnknownTokens": 10141
}
],
"workspaceIdentity": {
"kind": "local-project",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\node\\expense-project"
}
}
],
"progress": {
"totalTools": 0,
"completedTools": 0,
"requiresVerification": []
},
"artifacts": [
{
"id": "638f2a9e-0f4a-416e-b30f-d90870eed8a3",
"sessionId": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"kind": "model-request",
"mediaType": "application/json",
"sha256": "6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3",
"bytes": 23127,
"relative": "6e/6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3.blob",
"createdAt": "2026-11-03T14:37:29.302Z",
"status": "stored"
},
{
"id": "3e6faf5b-9cd7-4f2b-8924-172182cdc600",
"sessionId": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"kind": "context-plan",
"mediaType": "application/json",
"sha256": "3a43d6473febcf05daa09ef36e46b176232e5b5eb3f1dc52ac89c12f3dcfe40a",
"bytes": 2093,
"relative": "3a/3a43d6473febcf05daa09ef36e46b176232e5b5eb3f1dc52ac89c12f3dcfe40a.blob",
"createdAt": "2026-11-03T14:37:29.305Z",
"status": "stored"
},
{
"id": "caddb9bf-0648-4f0e-b928-d630b9df9d62",
"sessionId": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"kind": "model-attempt-request",
"mediaType": "application/json",
"sha256": "6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3",
"bytes": 23127,
"relative": "6e/6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3.blob",
"createdAt": "2026-11-03T14:37:29.308Z",
"status": "stored"
}
],
"checks": [],
"browsingTabs": [],
"browsingActions": [],
"previewPlans": [],
"previewJobs": [],
"mcpJobs": [],
"taskPlans": [],
"taskProofs": [],
"researchTargets": [],
"researchJobs": [],
"engineJobs": [],
"browserPlans": [],
"browserJobs": [],
"contextPlans": [
{
"schemaVersion": 1,
"id": "ff49f738-f19d-479c-8508-16b845e2047e",
"sessionId": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"stepId": "f21d3594-bc6b-4339-9c8e-f1a17608a581",
"requestIndex": 1,
"status": "failed",
"createdAt": "2026-11-03T14:37:29.302Z",
"finishedAt": "2026-11-03T14:37:39.931Z",
"requestSha256": "6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3",
"requestBytes": 23127,
"estimatedInputTokens": 8093,
"requestArtifactId": "638f2a9e-0f4a-416e-b30f-d90870eed8a3",
"tokenReservation": {
"schemaVersion": 1,
"method": "observed-route-max-v1",
"overheadTokens": 0,
"reservedTokens": 10141,
"routes": [
{
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"model": "gpt-6.1-sol",
"protocol": "chat-completions",
"endpoint": "https://jojocode.com/v1",
"localInputTokens": 8093,
"outputReservation": 2048,
"inputRatio": 1,
"observedOutputTokens": 2048,
"observedTotalFloor": 0,
"reservedTokens": 10141,
"sources": []
}
]
},
"maxBudgetAttempts": 8,
"estimateMethod": "utf8-third-plus-framing-v1",
"beforeInputTokens": 8093,
"beforeBytes": 23127,
"budget": {
"contextLimit": 16000,
"outputReservation": 2048,
"safetyTokens": 1600,
"inputBudget": 12352,
"targetInputTokens": 12352,
"runRemainingTokens": 90000,
"taskRemainingTokens": 90000,
"limitingReason": "context_limit"
},
"mandatoryInputTokens": 8093,
"nextReadFixedInputTokens": 8093,
"workingRetentionTokens": 0,
"workingRetentionPolicyVersion": 1,
"originalMessages": 1,
"retainedMessages": 1,
"archivedGroups": 0,
"retainedGroups": [
0
],
"historyIndexArtifactId": null,
"historyIndexSha256": null,
"actualUsage": null,
"workingSetArtifactId": null,
"workingSetSha256": null,
"workingSetEntries": 0,
"workingSetViewVersion": 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": 1,
"responseSha256": null,
"source": "workbench",
"artifactId": "3e6faf5b-9cd7-4f2b-8924-172182cdc600",
"error": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。"
}
],
"changeSets": [],
"plans": [],
"deliveries": [],
"deliveryPlans": [],
"accountedTaskTokens": 10141
}
}
@@ -0,0 +1,137 @@
{
"config": {
"mode": "compatible",
"baseUrl": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"contextLimit": 16000,
"maxSteps": 12,
"maxOutputTokens": 2048,
"maxRunDurationMs": 600000,
"maxRunTokens": 200000,
"maxTaskTokens": 1000000,
"configRevision": 65,
"modelResponseTimeoutMs": 300000,
"modelStreamIdleTimeoutMs": 120000
},
"registry": {
"schema": 1,
"revision": 84,
"selected": {
"type": "pool",
"id": "68e30376-b799-445b-a858-db2dba9920a0"
},
"connections": [
{
"id": "09b0293b-faad-45c3-832d-7c8b615813aa",
"name": "apikey",
"brand": "GPT 兼容代理",
"protocol": "responses",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "supported",
"vision": "unknown",
"audio": "unknown"
},
"streaming": true,
"nativeParameters": {},
"outputTokenField": "max_output_tokens",
"modelIdentityPolicy": "record",
"modelIdentityAliases": [],
"modelIdentityAliasSource": "",
"baseUrl": "https://api.apikey.fan/v1",
"enabled": false,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 11,
"source": "manual",
"createdAt": "2026-10-31T16:36:46.574Z",
"updatedAt": "2026-11-03T12:31:04.656Z"
},
{
"id": "93d0cf6d-4f32-4918-9da8-6f125aa8a6e5",
"name": "apikey",
"brand": "OpenAI",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "supported",
"vision": "unknown",
"audio": "unknown"
},
"streaming": true,
"modelIdentityPolicy": "record",
"modelIdentityAliases": [],
"modelIdentityAliasSource": "https://api.apikey.fan",
"baseUrl": "https://api.apikey.fan/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 1,
"revision": 5,
"source": "manual",
"createdAt": "2026-11-03T12:27:23.484Z",
"updatedAt": "2026-11-03T14:19:18.648Z"
},
{
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"name": "jojocode",
"brand": "兼容服务",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
},
"streaming": false,
"modelIdentityPolicy": "record",
"modelIdentityAliases": [],
"modelIdentityAliasSource": "",
"baseUrl": "https://jojocode.com/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 5,
"source": "manual",
"createdAt": "2026-10-30T14:36:37.791Z",
"updatedAt": "2026-11-03T14:37:41.151Z"
}
],
"pools": [
{
"id": "68e30376-b799-445b-a858-db2dba9920a0",
"name": "高性能",
"members": [
{
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"weight": 1
},
{
"connectionId": "93d0cf6d-4f32-4918-9da8-6f125aa8a6e5",
"weight": 1
}
],
"strategy": "round-robin",
"sticky": true,
"maxAttempts": 3,
"queueTimeoutMs": 15000,
"revision": 5
}
],
"imports": {}
}
}
@@ -0,0 +1,7 @@
{
"head": "67c317ce7eebabb182852021953dcf137b9b0a9e",
"status": "MM owner-staged.txt\n M owner-unstaged.txt\n?? owner-untracked.txt\n",
"stagedBefore": "Owner staged change\n",
"stagedAfter": "Owner staged change\n",
"diff": ""
}
@@ -0,0 +1 @@
修复这个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,请合并独立工具调用并避免重复观察。
@@ -0,0 +1,68 @@
{
"success": false,
"failure": {
"name": "Error",
"message": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"stack": "Error: 模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。\n at file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/.qa/live-delivery-p-node.mjs:120:42\n at process.processTicksAndRejections (node:internal/process/task_queues:104:5)",
"at": "2026-11-03T14:37:40.269Z",
"automaticReplay": false
},
"version": "1.24.5",
"sessionId": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"sourceRoot": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\node\\expense-project",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"requestedModel": "gpt-6.1-sol",
"usage": {
"requests": 1,
"inputTokens": 0,
"outputTokens": 0,
"totalTokens": 0,
"unknownRequests": 1,
"estimatedUnknownTokens": 10141
},
"state": "failed",
"stopReason": null,
"attempts": 1,
"identitiesValid": false,
"captures": [
{
"attemptId": "bb3669eb-a878-4029-92e8-9f9ee1c1ece0",
"kind": "request",
"artifactId": "caddb9bf-0648-4f0e-b928-d630b9df9d62",
"path": "node/captures/bb3669eb-a878-4029-92e8-9f9ee1c1ece0-request.json",
"sha256": "6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3",
"bytes": 23127
}
],
"approvals": [],
"applications": [],
"continuations": [
{
"beforeRequests": 0,
"remainingSteps": 8,
"at": "2026-11-03T14:37:29.121Z"
}
],
"observations": [
{
"status": "running",
"requests": 0,
"tokens": 0,
"checks": [],
"elapsedSeconds": 10
},
{
"status": "failed",
"requests": 1,
"tokens": 0,
"checks": [],
"elapsedSeconds": 20
}
],
"modelImplementationSuppliedBySupervisor": false,
"modelWeightsAuthenticated": false,
"originalPurgeBenefitTested": false,
"elapsedSeconds": 20
}
File diff suppressed because one or more lines are too long
@@ -0,0 +1,134 @@
{
"config": {
"mode": "compatible",
"baseUrl": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"contextLimit": 16000,
"maxSteps": 12,
"maxOutputTokens": 2048,
"maxRunDurationMs": 600000,
"maxRunTokens": 200000,
"maxTaskTokens": 1000000,
"configRevision": 61,
"modelResponseTimeoutMs": 300000,
"modelStreamIdleTimeoutMs": 120000
},
"registry": {
"schema": 1,
"revision": 80,
"selected": {
"type": "pool",
"id": "68e30376-b799-445b-a858-db2dba9920a0"
},
"connections": [
{
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"name": "jojocode",
"brand": "兼容服务",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
},
"streaming": false,
"baseUrl": "https://jojocode.com/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 3,
"source": "manual",
"createdAt": "2026-10-30T14:36:37.791Z",
"updatedAt": "2026-11-02T13:25:07.450Z"
},
{
"id": "09b0293b-faad-45c3-832d-7c8b615813aa",
"name": "apikey",
"brand": "GPT 兼容代理",
"protocol": "responses",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "supported",
"vision": "unknown",
"audio": "unknown"
},
"streaming": true,
"nativeParameters": {},
"outputTokenField": "max_output_tokens",
"modelIdentityPolicy": "record",
"modelIdentityAliases": [],
"modelIdentityAliasSource": "",
"baseUrl": "https://api.apikey.fan/v1",
"enabled": false,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 11,
"source": "manual",
"createdAt": "2026-10-31T16:36:46.574Z",
"updatedAt": "2026-11-03T12:31:04.656Z"
},
{
"id": "93d0cf6d-4f32-4918-9da8-6f125aa8a6e5",
"name": "apikey",
"brand": "OpenAI",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "supported",
"vision": "unknown",
"audio": "unknown"
},
"streaming": true,
"modelIdentityPolicy": "record",
"modelIdentityAliases": [],
"modelIdentityAliasSource": "https://api.apikey.fan",
"baseUrl": "https://api.apikey.fan/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 1,
"revision": 5,
"source": "manual",
"createdAt": "2026-11-03T12:27:23.484Z",
"updatedAt": "2026-11-03T14:19:18.648Z"
}
],
"pools": [
{
"id": "68e30376-b799-445b-a858-db2dba9920a0",
"name": "高性能",
"members": [
{
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"weight": 1
},
{
"connectionId": "93d0cf6d-4f32-4918-9da8-6f125aa8a6e5",
"weight": 1
}
],
"strategy": "round-robin",
"sticky": true,
"maxAttempts": 3,
"queueTimeoutMs": 15000,
"revision": 5
}
],
"imports": {}
}
}
@@ -0,0 +1,66 @@
{
"project": {
"id": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\node\\expense-project",
"name": "expense-project",
"addedAt": "2026-11-03T14:37:29.107Z"
},
"session": {
"id": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"title": "新任务",
"status": "idle",
"createdAt": "2026-11-03T14:37:29.110Z",
"updatedAt": "2026-11-03T14:37:29.110Z",
"messages": [],
"events": [],
"changes": [],
"approvals": [],
"failure": null,
"lastFailure": null,
"compactions": 0,
"estimatedTokens": 0,
"usage": null,
"archived": false,
"revision": 1,
"eventSeq": 13099,
"inputAttachments": [],
"execution": {
"schemaVersion": 1,
"task": null,
"run": null,
"workspaceIdentity": {
"kind": "local-project",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\node\\expense-project"
},
"workspaces": [],
"runs": [],
"progress": {
"totalTools": 0,
"completedTools": 0,
"requiresVerification": []
},
"artifacts": [],
"checks": [],
"browsingTabs": [],
"browsingActions": [],
"previewPlans": [],
"previewJobs": [],
"mcpJobs": [],
"taskPlans": [],
"taskProofs": [],
"researchTargets": [],
"researchJobs": [],
"engineJobs": [],
"browserPlans": [],
"browserJobs": [],
"contextPlans": [],
"changeSets": [],
"plans": [],
"deliveries": [],
"deliveryPlans": [],
"accountedTaskTokens": 0
}
}
}
@@ -0,0 +1,29 @@
{
"passed": true,
"originalExports": 76,
"originalArtifactFiles": 3608,
"originalRowsExact": [
"sessions",
"records",
"events",
"outbox"
],
"budgetsAndSelectionRestored": true,
"poolsUnchanged": true,
"originalPublicProjectsExact": true,
"originalAttemptsExact": 208,
"rawConfigExceptRevisionExact": true,
"registryExceptDeclaredRevisionTimestampOrderAndIdentityDefaultsExact": true,
"identityDefaultNormalization": {
"modelIdentityPolicy": "record",
"modelIdentityAliases": [],
"modelIdentityAliasSource": ""
},
"otherMetadataRowsExact": true,
"originalCredentialRevision": 1,
"finalCredentialRevision": 1,
"changedOnlyMonotonicRevisionsObservedHealthAndDeclaredIdentityDefaults": true,
"pid": 36552,
"version": "1.24.5",
"noKeyExtractedOrResaved": true
}
@@ -0,0 +1,68 @@
{
"success": false,
"failure": {
"name": "Error",
"message": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"stack": "Error: 模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。\n at file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/.qa/live-delivery-p-node.mjs:120:42\n at process.processTicksAndRejections (node:internal/process/task_queues:104:5)",
"at": "2026-11-03T14:37:40.269Z",
"automaticReplay": false
},
"version": "1.24.5",
"sessionId": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"sourceRoot": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\node\\expense-project",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"requestedModel": "gpt-6.1-sol",
"usage": {
"requests": 1,
"inputTokens": 0,
"outputTokens": 0,
"totalTokens": 0,
"unknownRequests": 1,
"estimatedUnknownTokens": 10141
},
"state": "failed",
"stopReason": null,
"attempts": 1,
"identitiesValid": false,
"captures": [
{
"attemptId": "bb3669eb-a878-4029-92e8-9f9ee1c1ece0",
"kind": "request",
"artifactId": "caddb9bf-0648-4f0e-b928-d630b9df9d62",
"path": "node/captures/bb3669eb-a878-4029-92e8-9f9ee1c1ece0-request.json",
"sha256": "6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3",
"bytes": 23127
}
],
"approvals": [],
"applications": [],
"continuations": [
{
"beforeRequests": 0,
"remainingSteps": 8,
"at": "2026-11-03T14:37:29.121Z"
}
],
"observations": [
{
"status": "running",
"requests": 0,
"tokens": 0,
"checks": [],
"elapsedSeconds": 10
},
{
"status": "failed",
"requests": 1,
"tokens": 0,
"checks": [],
"elapsedSeconds": 20
}
],
"modelImplementationSuppliedBySupervisor": false,
"modelWeightsAuthenticated": false,
"originalPurgeBenefitTested": false,
"elapsedSeconds": 20
}
@@ -0,0 +1,720 @@
{
"id": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"title": "修复这个Node费用报表工程的amount、summar",
"status": "failed",
"createdAt": "2026-11-03T14:37:29.110Z",
"updatedAt": "2026-11-03T14:37:39.945Z",
"messages": [
{
"id": "cbdafe54-21f1-4a86-994f-c7ff8a04203a",
"role": "user",
"content": "修复这个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,请合并独立工具调用并避免重复观察。",
"createdAt": "2026-11-03T14:37:29.290Z"
},
{
"id": "4aeace4a-6cf9-44b4-af8b-844877d121cf",
"role": "system",
"content": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"createdAt": "2026-11-03T14:37:39.933Z"
}
],
"events": [
{
"id": "b1eebbf6-ad23-4e5b-872d-022e3df0283f",
"createdAt": "2026-11-03T14:37:29.315Z",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"kind": "model",
"source": "model_connection",
"label": "模型连接失败",
"phase": "failed",
"startedAt": "2026-11-03T14:37:29.315Z",
"contextPlanId": "ff49f738-f19d-479c-8508-16b845e2047e",
"attempts": 1,
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"modelAttemptId": "bb3669eb-a878-4029-92e8-9f9ee1c1ece0",
"actualModel": "gpt-6.1-sol",
"output": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"diagnostic": {
"id": "4e4ed0df-a715-4a74-8538-2d3f7f01286e",
"source": "model_connection",
"origin": "local",
"stage": "model_request",
"kind": "timeout",
"code": "UND_ERR_CONNECT_TIMEOUT",
"endpoint": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"route": "/chat/completions",
"attempts": 1,
"occurredAt": "2026-11-03T14:37:39.918Z",
"retryable": true,
"failoverAllowed": false,
"outcome": "failed",
"network": {
"stage": "connect",
"replaySafety": "before_model_send",
"responseReceived": false,
"causesComplete": true,
"transport": {
"schemaVersion": 1,
"implementation": "undici-7.30.1",
"autoSelectFamily": true,
"familyAttemptTimeoutMs": 250,
"connectTimeoutMs": 10000,
"httpProxyConfigured": false,
"httpsProxyConfigured": false,
"noProxyConfigured": false
},
"causes": [
{
"code": "UND_ERR_CONNECT_TIMEOUT"
}
]
},
"title": "模型服务连接超时",
"message": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"suggestion": "核对网络、DNS、IPv4/IPv6候选及代理;这是建立连接时超时,增加模型响应等待时限不能修复连接。",
"detail": "模型服务连接超时",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"wireAttemptId": "a1ee34cd-e67b-4bc5-af55-f3e62e8ba03a",
"retryDecision": "attempt_limit",
"remainingWaitBudgetMs": 289396
},
"durationMs": 10604,
"finishedAt": "2026-11-03T14:37:39.918Z"
},
{
"id": "c3a286ca-9d67-4d59-a870-2cfa784b10c9",
"createdAt": "2026-11-03T14:37:39.936Z",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"kind": "error",
"source": "model_connection",
"label": "模型服务连接超时",
"phase": "failed",
"output": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"diagnostic": {
"id": "4e4ed0df-a715-4a74-8538-2d3f7f01286e",
"source": "model_connection",
"origin": "local",
"stage": "model_request",
"kind": "timeout",
"code": "UND_ERR_CONNECT_TIMEOUT",
"endpoint": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"route": "/chat/completions",
"attempts": 1,
"occurredAt": "2026-11-03T14:37:39.918Z",
"retryable": true,
"failoverAllowed": false,
"outcome": "failed",
"network": {
"stage": "connect",
"replaySafety": "before_model_send",
"responseReceived": false,
"causesComplete": true,
"transport": {
"schemaVersion": 1,
"implementation": "undici-7.30.1",
"autoSelectFamily": true,
"familyAttemptTimeoutMs": 250,
"connectTimeoutMs": 10000,
"httpProxyConfigured": false,
"httpsProxyConfigured": false,
"noProxyConfigured": false
},
"causes": [
{
"code": "UND_ERR_CONNECT_TIMEOUT"
}
]
},
"title": "模型服务连接超时",
"message": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"suggestion": "核对网络、DNS、IPv4/IPv6候选及代理;这是建立连接时超时,增加模型响应等待时限不能修复连接。",
"detail": "模型服务连接超时",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"wireAttemptId": "a1ee34cd-e67b-4bc5-af55-f3e62e8ba03a",
"retryDecision": "attempt_limit",
"remainingWaitBudgetMs": 289396,
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96"
}
}
],
"changes": [],
"approvals": [],
"failure": {
"id": "4e4ed0df-a715-4a74-8538-2d3f7f01286e",
"source": "model_connection",
"origin": "local",
"stage": "model_request",
"kind": "timeout",
"code": "UND_ERR_CONNECT_TIMEOUT",
"endpoint": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"route": "/chat/completions",
"attempts": 1,
"occurredAt": "2026-11-03T14:37:39.918Z",
"retryable": true,
"failoverAllowed": false,
"outcome": "failed",
"network": {
"stage": "connect",
"replaySafety": "before_model_send",
"responseReceived": false,
"causesComplete": true,
"transport": {
"schemaVersion": 1,
"implementation": "undici-7.30.1",
"autoSelectFamily": true,
"familyAttemptTimeoutMs": 250,
"connectTimeoutMs": 10000,
"httpProxyConfigured": false,
"httpsProxyConfigured": false,
"noProxyConfigured": false
},
"causes": [
{
"code": "UND_ERR_CONNECT_TIMEOUT"
}
]
},
"title": "模型服务连接超时",
"message": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"suggestion": "核对网络、DNS、IPv4/IPv6候选及代理;这是建立连接时超时,增加模型响应等待时限不能修复连接。",
"detail": "模型服务连接超时",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"wireAttemptId": "a1ee34cd-e67b-4bc5-af55-f3e62e8ba03a",
"retryDecision": "attempt_limit",
"remainingWaitBudgetMs": 289396,
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"messageId": "4aeace4a-6cf9-44b4-af8b-844877d121cf"
},
"lastFailure": {
"id": "4e4ed0df-a715-4a74-8538-2d3f7f01286e",
"source": "model_connection",
"origin": "local",
"stage": "model_request",
"kind": "timeout",
"code": "UND_ERR_CONNECT_TIMEOUT",
"endpoint": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"route": "/chat/completions",
"attempts": 1,
"occurredAt": "2026-11-03T14:37:39.918Z",
"retryable": true,
"failoverAllowed": false,
"outcome": "failed",
"network": {
"stage": "connect",
"replaySafety": "before_model_send",
"responseReceived": false,
"causesComplete": true,
"transport": {
"schemaVersion": 1,
"implementation": "undici-7.30.1",
"autoSelectFamily": true,
"familyAttemptTimeoutMs": 250,
"connectTimeoutMs": 10000,
"httpProxyConfigured": false,
"httpsProxyConfigured": false,
"noProxyConfigured": false
},
"causes": [
{
"code": "UND_ERR_CONNECT_TIMEOUT"
}
]
},
"title": "模型服务连接超时",
"message": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。",
"suggestion": "核对网络、DNS、IPv4/IPv6候选及代理;这是建立连接时超时,增加模型响应等待时限不能修复连接。",
"detail": "模型服务连接超时",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"wireAttemptId": "a1ee34cd-e67b-4bc5-af55-f3e62e8ba03a",
"retryDecision": "attempt_limit",
"remainingWaitBudgetMs": 289396,
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96"
},
"compactions": 0,
"estimatedTokens": 8093,
"usage": null,
"archived": false,
"revision": 17,
"eventSeq": 13115,
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"recoveryNotice": null,
"executionMode": "compatible",
"inputAttachments": [],
"execution": {
"schemaVersion": 1,
"task": {
"schemaVersion": 1,
"id": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"sessionId": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"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,请合并独立工具调用并避免重复观察。",
"instructions": [],
"constraints": [],
"acceptance": [],
"status": "failed",
"previousTaskId": null,
"createdAt": "2026-11-03T14:37:29.288Z",
"updatedAt": "2026-11-03T14:37:39.945Z",
"activeRunId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"usage": {
"requests": 1,
"inputTokens": 0,
"outputTokens": 0,
"totalTokens": 0,
"unknownRequests": 1,
"estimatedUnknownTokens": 10141
},
"budget": {
"maxTokens": 90000
},
"verification": {
"status": "not_configured",
"checkJobId": null
},
"origin": "workbench",
"contract": {
"schemaVersion": 1,
"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,请合并独立工具调用并避免重复观察。",
"kind": "general",
"checks": "required"
},
"workspaceIdentity": {
"kind": "local-project",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\node\\expense-project"
},
"stagnation": null
},
"run": {
"schemaVersion": 1,
"id": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"sessionId": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"engine": "workbench",
"status": "failed",
"startedAt": "2026-11-03T14:37:29.288Z",
"finishedAt": "2026-11-03T14:37:39.945Z",
"resumeOf": null,
"model": {
"mode": "compatible",
"baseUrl": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"contextLimit": 16000,
"maxOutputTokens": 2048,
"configRevision": 63,
"modelResponseTimeoutMs": 300000,
"modelStreamIdleTimeoutMs": 120000,
"protocol": "chat-completions",
"streaming": false,
"nativeParameters": {},
"routing": {
"type": "connection",
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"revision": 4,
"strategy": "round-robin",
"sticky": true,
"maxAttempts": 1,
"queueTimeoutMs": 15000,
"members": [
{
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"name": "jojocode",
"brand": "兼容服务",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
},
"streaming": false,
"modelIdentityPolicy": "require-match",
"modelIdentityAliases": [],
"modelIdentityAliasSource": "",
"baseUrl": "https://jojocode.com/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 4,
"source": "manual",
"createdAt": "2026-10-30T14:36:37.791Z",
"updatedAt": "2026-11-03T14:37:29.114Z",
"weight": 1,
"credentialRevision": 1
}
]
}
},
"budget": {
"maxSteps": 8,
"maxDurationMs": 600000,
"maxTokens": 90000,
"maxTaskTokens": 90000
},
"usage": {
"requests": 1,
"inputTokens": 0,
"outputTokens": 0,
"totalTokens": 0,
"unknownRequests": 1,
"estimatedUnknownTokens": 10141
},
"steps": 1,
"toolCalls": 0,
"stopReason": null,
"checkpoint": {
"stepId": "f21d3594-bc6b-4339-9c8e-f1a17608a581",
"completedToolIds": [],
"pendingToolIds": [],
"requiresVerification": []
},
"origin": "workbench",
"purpose": "execution",
"workspaceIdentity": {
"kind": "local-project",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\node\\expense-project"
},
"currentContextPlanId": "ff49f738-f19d-479c-8508-16b845e2047e",
"consumption": [
{
"attemptId": "bb3669eb-a878-4029-92e8-9f9ee1c1ece0",
"requestId": "ff49f738-f19d-479c-8508-16b845e2047e",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"connectionName": "jojocode",
"model": "gpt-6.1-sol",
"endpoint": "https://jojocode.com/v1",
"protocol": "chat-completions",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"responseUrl": null,
"redirected": false,
"startedAt": "2026-11-03T14:37:29.314Z",
"finishedAt": "2026-11-03T14:37:39.922Z",
"outcome": "failed",
"usageStatus": "unknown",
"usage": null,
"localEstimate": {
"schemaVersion": 1,
"inputTokens": 8093,
"outputTokens": 2048,
"requestSha256": "6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3",
"requestBytes": 23127,
"estimateMethod": "utf8-third-plus-framing-v1"
},
"modelIdentity": {
"schemaVersion": 1,
"requestedModel": "gpt-6.1-sol",
"reportedModels": [],
"status": "incomplete",
"complete": false,
"invalidIdentifiers": false,
"policy": "require-match",
"scope": "Identifiers in the outgoing request and upstream response; neither equal identifiers nor a declared mapping authenticate model weights."
},
"estimatedUnknownTokens": 10141
}
]
},
"workspaceIdentity": {
"kind": "local-project",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\node\\expense-project"
},
"workspaces": [],
"runs": [
{
"id": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"status": "failed",
"startedAt": "2026-11-03T14:37:29.288Z",
"finishedAt": "2026-11-03T14:37:39.945Z",
"steps": 1,
"toolCalls": 0,
"usage": {
"requests": 1,
"inputTokens": 0,
"outputTokens": 0,
"totalTokens": 0,
"unknownRequests": 1,
"estimatedUnknownTokens": 10141
},
"stopReason": null,
"model": {
"mode": "compatible",
"baseUrl": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"contextLimit": 16000,
"maxOutputTokens": 2048,
"configRevision": 63,
"modelResponseTimeoutMs": 300000,
"modelStreamIdleTimeoutMs": 120000,
"protocol": "chat-completions",
"streaming": false,
"nativeParameters": {},
"routing": {
"type": "connection",
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"revision": 4,
"strategy": "round-robin",
"sticky": true,
"maxAttempts": 1,
"queueTimeoutMs": 15000,
"members": [
{
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"name": "jojocode",
"brand": "兼容服务",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
},
"streaming": false,
"modelIdentityPolicy": "require-match",
"modelIdentityAliases": [],
"modelIdentityAliasSource": "",
"baseUrl": "https://jojocode.com/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 4,
"source": "manual",
"createdAt": "2026-10-30T14:36:37.791Z",
"updatedAt": "2026-11-03T14:37:29.114Z",
"weight": 1,
"credentialRevision": 1
}
]
}
},
"budget": {
"maxSteps": 8,
"maxDurationMs": 600000,
"maxTokens": 90000,
"maxTaskTokens": 90000
},
"resumeOf": null,
"purpose": "execution",
"consumption": [
{
"attemptId": "bb3669eb-a878-4029-92e8-9f9ee1c1ece0",
"requestId": "ff49f738-f19d-479c-8508-16b845e2047e",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"connectionName": "jojocode",
"model": "gpt-6.1-sol",
"endpoint": "https://jojocode.com/v1",
"protocol": "chat-completions",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"responseUrl": null,
"redirected": false,
"startedAt": "2026-11-03T14:37:29.314Z",
"finishedAt": "2026-11-03T14:37:39.922Z",
"outcome": "failed",
"usageStatus": "unknown",
"usage": null,
"localEstimate": {
"schemaVersion": 1,
"inputTokens": 8093,
"outputTokens": 2048,
"requestSha256": "6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3",
"requestBytes": 23127,
"estimateMethod": "utf8-third-plus-framing-v1"
},
"modelIdentity": {
"schemaVersion": 1,
"requestedModel": "gpt-6.1-sol",
"reportedModels": [],
"status": "incomplete",
"complete": false,
"invalidIdentifiers": false,
"policy": "require-match",
"scope": "Identifiers in the outgoing request and upstream response; neither equal identifiers nor a declared mapping authenticate model weights."
},
"estimatedUnknownTokens": 10141
}
],
"workspaceIdentity": {
"kind": "local-project",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\node\\expense-project"
}
}
],
"progress": {
"totalTools": 0,
"completedTools": 0,
"requiresVerification": []
},
"artifacts": [
{
"id": "638f2a9e-0f4a-416e-b30f-d90870eed8a3",
"sessionId": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"kind": "model-request",
"mediaType": "application/json",
"sha256": "6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3",
"bytes": 23127,
"relative": "6e/6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3.blob",
"createdAt": "2026-11-03T14:37:29.302Z",
"status": "stored"
},
{
"id": "3e6faf5b-9cd7-4f2b-8924-172182cdc600",
"sessionId": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"kind": "context-plan",
"mediaType": "application/json",
"sha256": "3a43d6473febcf05daa09ef36e46b176232e5b5eb3f1dc52ac89c12f3dcfe40a",
"bytes": 2093,
"relative": "3a/3a43d6473febcf05daa09ef36e46b176232e5b5eb3f1dc52ac89c12f3dcfe40a.blob",
"createdAt": "2026-11-03T14:37:29.305Z",
"status": "stored"
},
{
"id": "caddb9bf-0648-4f0e-b928-d630b9df9d62",
"sessionId": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"kind": "model-attempt-request",
"mediaType": "application/json",
"sha256": "6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3",
"bytes": 23127,
"relative": "6e/6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3.blob",
"createdAt": "2026-11-03T14:37:29.308Z",
"status": "stored"
}
],
"checks": [],
"browsingTabs": [],
"browsingActions": [],
"previewPlans": [],
"previewJobs": [],
"mcpJobs": [],
"taskPlans": [],
"taskProofs": [],
"researchTargets": [],
"researchJobs": [],
"engineJobs": [],
"browserPlans": [],
"browserJobs": [],
"contextPlans": [
{
"schemaVersion": 1,
"id": "ff49f738-f19d-479c-8508-16b845e2047e",
"sessionId": "73cfff62-8e93-4056-b42d-682a37784f7b",
"projectId": "2732b99f-fc5b-47dc-8b07-0b8993b8761c",
"taskId": "01388c5e-0c48-46cb-ba47-7d8e0fbe73b0",
"runId": "24124a57-3886-42e4-be8a-a61ac5e22a96",
"stepId": "f21d3594-bc6b-4339-9c8e-f1a17608a581",
"requestIndex": 1,
"status": "failed",
"createdAt": "2026-11-03T14:37:29.302Z",
"finishedAt": "2026-11-03T14:37:39.931Z",
"requestSha256": "6e6fd8c72d7ad4108cd4d72d9cd2cad6bd2f3d37befe3432fdf357d2821acae3",
"requestBytes": 23127,
"estimatedInputTokens": 8093,
"requestArtifactId": "638f2a9e-0f4a-416e-b30f-d90870eed8a3",
"tokenReservation": {
"schemaVersion": 1,
"method": "observed-route-max-v1",
"overheadTokens": 0,
"reservedTokens": 10141,
"routes": [
{
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"model": "gpt-6.1-sol",
"protocol": "chat-completions",
"endpoint": "https://jojocode.com/v1",
"localInputTokens": 8093,
"outputReservation": 2048,
"inputRatio": 1,
"observedOutputTokens": 2048,
"observedTotalFloor": 0,
"reservedTokens": 10141,
"sources": []
}
]
},
"maxBudgetAttempts": 8,
"estimateMethod": "utf8-third-plus-framing-v1",
"beforeInputTokens": 8093,
"beforeBytes": 23127,
"budget": {
"contextLimit": 16000,
"outputReservation": 2048,
"safetyTokens": 1600,
"inputBudget": 12352,
"targetInputTokens": 12352,
"runRemainingTokens": 90000,
"taskRemainingTokens": 90000,
"limitingReason": "context_limit"
},
"mandatoryInputTokens": 8093,
"nextReadFixedInputTokens": 8093,
"workingRetentionTokens": 0,
"workingRetentionPolicyVersion": 1,
"originalMessages": 1,
"retainedMessages": 1,
"archivedGroups": 0,
"retainedGroups": [
0
],
"historyIndexArtifactId": null,
"historyIndexSha256": null,
"actualUsage": null,
"workingSetArtifactId": null,
"workingSetSha256": null,
"workingSetEntries": 0,
"workingSetViewVersion": 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": 1,
"responseSha256": null,
"source": "workbench",
"artifactId": "3e6faf5b-9cd7-4f2b-8924-172182cdc600",
"error": "模型服务连接超时(UND_ERR_CONNECT_TIMEOUT)。项目文件和已完成的工具记录已保留。"
}
],
"changeSets": [],
"plans": [],
"deliveries": [],
"deliveryPlans": [],
"accountedTaskTokens": 10141
}
}
@@ -0,0 +1 @@
export function amountToCents(value) { return 0; }
@@ -0,0 +1 @@
export function formatReport(groups) { return ''; }
@@ -0,0 +1,2 @@
import { amountToCents } from './amount.mjs';
export function summarize(rows) { return []; }
@@ -0,0 +1,3 @@
dist/
.awb-*
node_modules/
@@ -0,0 +1,2 @@
# Expense report acceptance
Repair the three source modules using the immutable original nine tests; do not edit checks or owner files.
@@ -0,0 +1 @@
Owner working copy differs from staging
@@ -0,0 +1 @@
Owner unstaged change
@@ -0,0 +1 @@
Owner untracked change
@@ -0,0 +1,9 @@
{
"name": "owned-live-expense-report",
"private": true,
"type": "module",
"scripts": {
"test": "node --test test/expense.test.mjs",
"build": "node scripts/build.mjs"
}
}
@@ -0,0 +1,8 @@
import { spawnSync } from 'node:child_process';
import { readFileSync } from 'node:fs';
for (const file of ['src/amount.mjs','src/summary.mjs','src/report.mjs']) {
const result=spawnSync(process.execPath,['--check',file],{encoding:'utf8'});
if(result.status!==0) { process.stderr.write(result.stderr);process.exit(result.status??1); }
if(!readFileSync(file,'utf8').trim()) throw new Error('Empty business module');
}
console.log('All three business modules compile.');
@@ -0,0 +1 @@
export function amountToCents(value) { return 0; }
@@ -0,0 +1 @@
export function formatReport(groups) { return ''; }
@@ -0,0 +1,2 @@
import { amountToCents } from './amount.mjs';
export function summarize(rows) { return []; }
@@ -0,0 +1,37 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { amountToCents } from '../src/amount.mjs';
import { summarize } from '../src/summary.mjs';
import { formatReport } from '../src/report.mjs';
test('decimal strings become exact cents including zero and refunds',()=>{
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);
});
test('finite decimal numbers use the same cents contract',()=>{
for(const [input,expected] of [[0,0],[1.01,101],[2.5,250],[-4.32,-432]]) assert.equal(amountToCents(input),expected);
});
test('malformed overprecision nonfinite and unsafe amounts are rejected',()=>{
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));
});
test('independent currencies are sorted and summed without floating point loss',()=>{
assert.deepEqual(summarize([{currency:'usd',amount:'0.10'},{currency:' CNY ',amount:3},{currency:'USD',amount:'0.20'}]),[
{currency:'CNY',cents:300,count:1},{currency:'USD',cents:30,count:2}]);
});
test('refunds cancel totals while counting every original record',()=>{
assert.deepEqual(summarize([{currency:'eur',amount:'1.20'},{currency:'EUR',amount:'-1.20'}]),[{currency:'EUR',cents:0,count:2}]);
});
test('summarizing retains caller rows and handles an empty list',()=>{
const rows=Object.freeze([Object.freeze({currency:'usd',amount:'2.00'})]);
assert.deepEqual(summarize(rows),[{currency:'USD',cents:200,count:1}]);assert.deepEqual(summarize([]),[]);
});
test('invalid rows currency and unsafe aggregate totals are rejected',()=>{
for(const rows of [null,{},[null],[{currency:'US',amount:'1'}],[{currency:'U1D',amount:'1'}],[{currency:'USD',amount:'1.234'}],
[{currency:'USD',amount:'90071992547409.91'},{currency:'USD',amount:'0.01'}]]) assert.throws(()=>summarize(rows),TypeError);
});
test('reports use two decimals and render negative subunit amounts',()=>{
assert.equal(formatReport([{currency:'CNY',cents:300,count:2},{currency:'USD',cents:-105,count:1}]),'CNY 3.00 (2)\nUSD -1.05 (1)');
assert.equal(formatReport([{currency:'EUR',cents:-5,count:1}]),'EUR -0.05 (1)');assert.equal(formatReport([]),'');
});
test('complete expense flow preserves exact decimal sums',()=>{
assert.equal(formatReport(summarize([{currency:'usd',amount:'0.29'},{currency:'USD',amount:'-0.30'},{currency:'CNY',amount:'10.50'}])),
'CNY 10.50 (1)\nUSD -0.01 (2)');
});
@@ -0,0 +1,18 @@
{
"head": "67c317ce7eebabb182852021953dcf137b9b0a9e",
"status": "MM owner-staged.txt\n M owner-unstaged.txt\n?? owner-untracked.txt\n",
"stagedBefore": "Owner staged change\n",
"files": {
"README.md": "5e35a4dace9537e7c4cc815ce7054f73c171f053f1cccb9ff141f49ecb3c013e",
".gitignore": "cab0bc87cad1b1214d71b023eee742986044093ff4b4331cd6a51098af6bdce6",
"package.json": "6ad63026b2fe9de7513a4f6704c372a86108ee3d018a1f04883dc0a409ea4c24",
"test/expense.test.mjs": "0bcda551dbaeafad9a6e3df8024492ab67d7c09956f4676c393b78249ab44839",
"scripts/build.mjs": "7279bc7c707c0f3ccbae63b14f0abed248ad3755be14f9e37128124ae9267526",
"owner-staged.txt": "56b0dda452eaf9aead80f0e4ad971d7befa3cf152c3553923f8fde46e1fd336a",
"owner-unstaged.txt": "468bfb2956a4ac040508fc5ffd915cf8057fb7420e22c41a3cc2d094785f0d3e",
"owner-untracked.txt": "e32ab29a12ed13d72c2ed603b2360e1b4e35afb0fe4280db2e523ad2c6c5bc8d",
"src/amount.mjs": "84cb647328ec52dad27d288f3a6127ff3e1ad87274ae2d227ad44daa49cbb2ed",
"src/summary.mjs": "48829850c11ca0cd0ab5e86bbac69a0c5f90297292168c1ba6dc338e2eae6ee7",
"src/report.mjs": "ba0a014e6e9df710d66e255a3a6f970f4e1c8af48accc81f33627029dcded7c0"
}
}
@@ -0,0 +1 @@
{"passed":true,"pid":36552,"version":"1.24.5","originalExports":75,"originalArtifacts":3605,"originalRowsExact":["sessions","records","events","outbox"],"otherMetadataExceptAppendedAttemptsExact":true,"originalPublicProjectsExact":true,"originalConfigRegistryAndPoolExact":true,"observedConnectionHealthChange":true,"inspectorClosed":true,"noKeyReadOrResaved":true,"ownedProjectId":"3f4d91e0-e9d4-4338-bece-b3211507888c","ownedSessionId":"60728f43-2ff3-4279-918f-9ad4d1bc83fe"}
@@ -0,0 +1,11 @@
file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/.qa/live-delivery-p-preflight-audit.mjs:15
assert.equal(after.database.tables[table].schemaSha256, before.database.tables[table].schemaSha256);
^
TypeError: Cannot read properties of undefined (reading 'schemaSha256')
at file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/.qa/live-delivery-p-preflight-audit.mjs:15:45
at ModuleJob.run (node:internal/modules/esm/module_job:561:25)
at async node:internal/modules/esm/loader:647:26
at async asyncRunEntryPointWithESMLoader (node:internal/modules/run_main:101:5)
Node.js v24.22.1
@@ -0,0 +1,2 @@
{"stage":"single-GPT-preflight","connectionId":"5b4daed9-b2f7-4de0-b949-573eba70c7b3","model":"gpt-6.1-sol","requestUrl":"https://jojocode.com/v1/chat/completions","maxRequests":1,"toolDefinitions":0}
{"passed":true,"requests":1,"usage":{"prompt_tokens":86,"completion_tokens":26,"total_tokens":112},"reportedModels":["gpt-6.1-sol"],"stopReason":"identity_probe_complete"}
File diff suppressed because one or more lines are too long
@@ -0,0 +1,114 @@
[
{
"id": "b36e9080-e24f-4f22-a04d-ce70240de579",
"requestId": "2ba28fda-8ed2-4ad7-a800-5ea04269f2ad",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"connectionRevision": 3,
"credentialRevision": 1,
"poolId": null,
"poolRevision": 3,
"model": "gpt-6.1-sol",
"protocol": "chat-completions",
"streaming": false,
"endpoint": "https://jojocode.com/v1",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"ordinal": 1,
"status": "completed",
"startedAt": "2026-11-03T14:34:44.887Z",
"requestBytes": 444,
"requirements": [
"text"
],
"rejections": [],
"requestSha256": "ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8",
"usage": {
"prompt_tokens": 86,
"completion_tokens": 26,
"total_tokens": 112
},
"usageStatus": "reported",
"requestArtifactId": "76c93c4f-3442-4d32-ba1a-0fb91588867c",
"wireAttemptId": "264e1d81-3659-446e-aae2-63796a90dde5",
"upstreamResponse": {
"httpStatus": 200,
"requestId": "a246474b-a774-4f9a-b60c-e5c97e5e2f59",
"headers": {
"content-type": "application/json; charset=utf-8",
"date": "Tue, 03 Nov 2026 14:34:51 GMT",
"x-request-id": "a246474b-a774-4f9a-b60c-e5c97e5e2f59"
},
"requestUrl": "https://jojocode.com/v1/chat/completions",
"responseUrl": "https://jojocode.com/v1/chat/completions",
"redirected": false,
"redirectMode": "manual"
},
"modelIdentity": {
"schemaVersion": 1,
"requestedModel": "gpt-6.1-sol",
"reportedModels": [
"gpt-6.1-sol"
],
"status": "matched",
"complete": true,
"invalidIdentifiers": false,
"policy": "require-match",
"scope": "Identifiers in the outgoing request and upstream response; neither equal identifiers nor a declared mapping authenticate model weights.",
"responseSource": {
"artifactId": "3566a31c-4a8f-4058-a937-697fd58fadcc",
"sha256": "c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"scope": "http-body"
}
},
"responseArtifactId": "3566a31c-4a8f-4058-a937-697fd58fadcc",
"responseSha256": "c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f",
"responseRedacted": false,
"upstream": {
"schema": 1,
"scope": "http-body",
"httpStatus": 200,
"code": null,
"type": null,
"message": null,
"param": null,
"reason": null,
"requestId": "a246474b-a774-4f9a-b60c-e5c97e5e2f59",
"responseId": null,
"eventType": null,
"headers": {
"content-type": "application/json; charset=utf-8",
"date": "Tue, 03 Nov 2026 14:34:51 GMT",
"x-request-id": "a246474b-a774-4f9a-b60c-e5c97e5e2f59"
},
"retryAfter": null,
"retryAfterMs": null,
"rawPreview": "{\"id\":\"resp_00ca54d06813d61a016ae9f108f1688194a69f2754e0d64b4c\",\"object\":\"chat.completion\",\"created\":1793716491,\"model\":\"gpt-6.1-sol\",\"choices\":[{\"index\":0,\"message\":{\"role\":\"assistant\",\"content\":\"OK 7d195adc-90dc-4077-9950-c23baa7faad8\"},\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":86,\"completion_tokens\":26,\"total_tokens\":112},\"service_tier\":\"default\"}",
"previewTruncated": false,
"capture": {
"scope": "http-body",
"receivedBytes": 360,
"capturedBytes": 360,
"storedBytes": 360,
"retention": "artifact",
"complete": true,
"truncated": false,
"interrupted": false,
"capturedRange": [
0,
360
],
"redacted": false,
"sha256": "c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f"
},
"artifactId": "3566a31c-4a8f-4058-a937-697fd58fadcc",
"artifactSha256": "c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f",
"artifactScope": "http-body",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe"
},
"finishedAt": "2026-11-03T14:34:55.022Z"
}
]
File diff suppressed because one or more lines are too long
@@ -0,0 +1 @@
{"model":"gpt-6.1-sol","messages":[{"role":"system","content":"This is a connection identity preflight. Reply to the user exactly. No tools are available. Do not perform any project work."},{"role":"user","content":"这是独立GPT连接身份预检,不是工程任务。只回复 OK 7d195adc-90dc-4077-9950-c23baa7faad8,不要调用工具、读写文件或执行命令。"}],"tools":[],"tool_choice":"auto","max_tokens":256,"stream":false}
@@ -0,0 +1 @@
{"id":"resp_00ca54d06813d61a016ae9f108f1688194a69f2754e0d64b4c","object":"chat.completion","created":1793716491,"model":"gpt-6.1-sol","choices":[{"index":0,"message":{"role":"assistant","content":"OK 7d195adc-90dc-4077-9950-c23baa7faad8"},"finish_reason":"stop"}],"usage":{"prompt_tokens":86,"completion_tokens":26,"total_tokens":112},"service_tier":"default"}
@@ -0,0 +1,74 @@
{
"kind": "single-real-GPT-identity-preflight",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"connection": {
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"name": "jojocode",
"brand": "兼容服务",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
},
"streaming": false,
"baseUrl": "https://jojocode.com/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 3,
"source": "manual",
"createdAt": "2026-10-30T14:36:37.791Z",
"updatedAt": "2026-11-02T13:25:07.450Z",
"hasKey": true,
"credentialRevision": 1,
"credentialStorage": "memory",
"savedCredential": {
"storage": "windows-user-dpapi",
"status": "source_changed",
"enabled": true,
"connectionRevision": 2,
"credentialRevision": 1,
"savedAt": "2026-10-31T11:30:08.471Z",
"message": "原保存块无法用于当前连接;重新填写后保存,或删除原保存。"
},
"status": "configured",
"activeRequests": 0,
"health": {
"state": "responded",
"lastSuccessAt": "2026-11-02T13:31:00.976Z",
"cooldownUntil": 0,
"failures": 0
},
"capabilities": {
"text": "protocol_declared",
"tools": "protocol_declared",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
}
},
"version": "1.24.5",
"runtimeRoot": "C:\\Users\\wangy\\AppData\\Local\\Programs\\AgentWorkbench\\versions\\Agent-Workbench-1.24.5-win-x64-20261103133956264",
"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": "这是独立GPT连接身份预检,不是工程任务。只回复 OK 7d195adc-90dc-4077-9950-c23baa7faad8,不要调用工具、读写文件或执行命令。",
"nonce": "7d195adc-90dc-4077-9950-c23baa7faad8",
"originalBaselineSha256": "ab1669d1017329473ca8d4543ce89f93c57467969671a665a4114c78d9d75055"
}
@@ -0,0 +1,608 @@
{
"schemaVersion": 1,
"executionSchemaVersion": 1,
"exportedAt": "2026-11-03T14:34:55.252Z",
"project": {
"id": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\preflight\\identity-only",
"name": "identity-only",
"addedAt": "2026-11-03T14:34:44.745Z"
},
"session": {
"id": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"title": "P · jojocode GPT连接单次预检",
"status": "completed",
"createdAt": "2026-11-03T14:34:44.752Z",
"updatedAt": "2026-11-03T14:34:55.032Z",
"messages": [
{
"id": "82f2b5c6-d2eb-4bae-9dce-ec57e78818d2",
"role": "user",
"content": "这是独立GPT连接身份预检,不是工程任务。只回复 OK 7d195adc-90dc-4077-9950-c23baa7faad8,不要调用工具、读写文件或执行命令。",
"createdAt": "2026-11-03T14:34:44.875Z"
},
{
"id": "b8cde330-e354-432d-9f09-22a35b7b37d1",
"role": "assistant",
"content": "OK 7d195adc-90dc-4077-9950-c23baa7faad8",
"createdAt": "2026-11-03T14:34:55.027Z"
}
],
"providerMessages": [
{
"role": "user",
"content": "这是独立GPT连接身份预检,不是工程任务。只回复 OK 7d195adc-90dc-4077-9950-c23baa7faad8,不要调用工具、读写文件或执行命令。"
},
{
"role": "assistant",
"content": "OK 7d195adc-90dc-4077-9950-c23baa7faad8"
}
],
"events": [
{
"id": "e53a7e1d-e11b-494b-bfff-d1c878c23eac",
"createdAt": "2026-11-03T14:34:44.894Z",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"kind": "model",
"source": "model_connection",
"label": "P · GPT单次身份预检(无工具)",
"phase": "completed",
"contextPlanId": "2ba28fda-8ed2-4ad7-a800-5ea04269f2ad",
"startedAt": "2026-11-03T14:34:44.894Z",
"modelAttemptId": "b36e9080-e24f-4f22-a04d-ce70240de579",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"actualModel": "gpt-6.1-sol",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"modelIdentity": {
"schemaVersion": 1,
"requestedModel": "gpt-6.1-sol",
"reportedModels": [
"gpt-6.1-sol"
],
"status": "matched",
"complete": true,
"invalidIdentifiers": false,
"policy": "require-match",
"scope": "Identifiers in the outgoing request and upstream response; neither equal identifiers nor a declared mapping authenticate model weights.",
"responseSource": {
"artifactId": "3566a31c-4a8f-4058-a937-697fd58fadcc",
"sha256": "c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"scope": "http-body"
}
},
"finishedAt": "2026-11-03T14:34:55.029Z"
}
],
"changes": [],
"approvals": [],
"failure": null,
"lastFailure": null,
"compactions": 0,
"estimatedTokens": 164,
"usage": {
"prompt_tokens": 86,
"completion_tokens": 26,
"total_tokens": 112
},
"archived": false,
"revision": 17,
"eventSeq": 13098,
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0"
},
"execution": {
"schemaVersion": 1,
"task": {
"schemaVersion": 1,
"id": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"goal": "这是独立GPT连接身份预检,不是工程任务。只回复 OK 7d195adc-90dc-4077-9950-c23baa7faad8,不要调用工具、读写文件或执行命令。",
"instructions": [],
"constraints": [],
"acceptance": [],
"status": "completed",
"previousTaskId": null,
"createdAt": "2026-11-03T14:34:44.872Z",
"updatedAt": "2026-11-03T14:34:55.032Z",
"activeRunId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"usage": {
"requests": 1,
"inputTokens": 86,
"outputTokens": 26,
"totalTokens": 112,
"unknownRequests": 0,
"estimatedUnknownTokens": 0
},
"budget": {
"maxTokens": 16000
},
"verification": {
"status": "not_configured",
"checkJobId": null
},
"origin": "workbench",
"contract": {
"schemaVersion": 1,
"goal": "这是独立GPT连接身份预检,不是工程任务。只回复 OK 7d195adc-90dc-4077-9950-c23baa7faad8,不要调用工具、读写文件或执行命令。",
"kind": "general",
"checks": "unspecified"
},
"workspaceIdentity": {
"kind": "local-project",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\preflight\\identity-only"
},
"stagnation": null
},
"run": {
"schemaVersion": 1,
"id": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"engine": "workbench",
"status": "completed",
"startedAt": "2026-11-03T14:34:44.872Z",
"finishedAt": "2026-11-03T14:34:55.032Z",
"resumeOf": null,
"model": {
"mode": "compatible",
"baseUrl": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"contextLimit": 16000,
"maxOutputTokens": 256,
"configRevision": 61,
"modelResponseTimeoutMs": 300000,
"modelStreamIdleTimeoutMs": 120000,
"protocol": "chat-completions",
"streaming": false,
"nativeParameters": {},
"routing": {
"type": "connection",
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"revision": 3,
"strategy": "round-robin",
"sticky": true,
"maxAttempts": 1,
"queueTimeoutMs": 15000,
"members": [
{
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"name": "jojocode",
"brand": "兼容服务",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
},
"streaming": false,
"baseUrl": "https://jojocode.com/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 3,
"source": "manual",
"createdAt": "2026-10-30T14:36:37.791Z",
"updatedAt": "2026-11-02T13:25:07.450Z",
"weight": 1,
"credentialRevision": 1,
"modelIdentityPolicy": "require-match",
"modelIdentityAliases": [],
"modelIdentityAliasSource": ""
}
]
}
},
"budget": {
"maxSteps": 1,
"maxDurationMs": 320000,
"maxTokens": 16000,
"maxTaskTokens": 16000
},
"usage": {
"requests": 1,
"inputTokens": 86,
"outputTokens": 26,
"totalTokens": 112,
"unknownRequests": 0,
"estimatedUnknownTokens": 0
},
"steps": 1,
"toolCalls": 0,
"stopReason": "identity_probe_complete",
"checkpoint": {
"stepId": "656a23fb-a8ec-43fb-9969-913183cbdf85",
"completedToolIds": [],
"pendingToolIds": [],
"requiresVerification": []
},
"origin": "workbench",
"purpose": "execution",
"workspaceIdentity": {
"kind": "local-project",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\preflight\\identity-only"
},
"currentContextPlanId": "2ba28fda-8ed2-4ad7-a800-5ea04269f2ad",
"consumption": [
{
"attemptId": "b36e9080-e24f-4f22-a04d-ce70240de579",
"requestId": "2ba28fda-8ed2-4ad7-a800-5ea04269f2ad",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"connectionName": "jojocode",
"model": "gpt-6.1-sol",
"endpoint": "https://jojocode.com/v1",
"protocol": "chat-completions",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"responseUrl": "https://jojocode.com/v1/chat/completions",
"redirected": false,
"redirectMode": "manual",
"startedAt": "2026-11-03T14:34:44.894Z",
"finishedAt": "2026-11-03T14:34:55.017Z",
"outcome": "completed",
"usageStatus": "reported",
"usage": {
"prompt_tokens": 86,
"completion_tokens": 26,
"total_tokens": 112
},
"localEstimate": {
"schemaVersion": 1,
"inputTokens": 164,
"outputTokens": 256,
"requestSha256": "ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8",
"requestBytes": 444,
"estimateMethod": "utf8-third-plus-framing-v1"
},
"modelIdentity": {
"schemaVersion": 1,
"requestedModel": "gpt-6.1-sol",
"reportedModels": [
"gpt-6.1-sol"
],
"status": "matched",
"complete": true,
"invalidIdentifiers": false,
"policy": "require-match",
"scope": "Identifiers in the outgoing request and upstream response; neither equal identifiers nor a declared mapping authenticate model weights.",
"responseSource": {
"artifactId": "3566a31c-4a8f-4058-a937-697fd58fadcc",
"sha256": "c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"scope": "http-body"
}
},
"estimatedUnknownTokens": 0
}
]
},
"workspaceIdentity": {
"kind": "local-project",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\preflight\\identity-only"
},
"workspaces": [],
"runs": [
{
"id": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"status": "completed",
"startedAt": "2026-11-03T14:34:44.872Z",
"finishedAt": "2026-11-03T14:34:55.032Z",
"steps": 1,
"toolCalls": 0,
"usage": {
"requests": 1,
"inputTokens": 86,
"outputTokens": 26,
"totalTokens": 112,
"unknownRequests": 0,
"estimatedUnknownTokens": 0
},
"stopReason": "identity_probe_complete",
"model": {
"mode": "compatible",
"baseUrl": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"contextLimit": 16000,
"maxOutputTokens": 256,
"configRevision": 61,
"modelResponseTimeoutMs": 300000,
"modelStreamIdleTimeoutMs": 120000,
"protocol": "chat-completions",
"streaming": false,
"nativeParameters": {},
"routing": {
"type": "connection",
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"revision": 3,
"strategy": "round-robin",
"sticky": true,
"maxAttempts": 1,
"queueTimeoutMs": 15000,
"members": [
{
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"name": "jojocode",
"brand": "兼容服务",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
},
"streaming": false,
"baseUrl": "https://jojocode.com/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 3,
"source": "manual",
"createdAt": "2026-10-30T14:36:37.791Z",
"updatedAt": "2026-11-02T13:25:07.450Z",
"weight": 1,
"credentialRevision": 1,
"modelIdentityPolicy": "require-match",
"modelIdentityAliases": [],
"modelIdentityAliasSource": ""
}
]
}
},
"budget": {
"maxSteps": 1,
"maxDurationMs": 320000,
"maxTokens": 16000,
"maxTaskTokens": 16000
},
"resumeOf": null,
"purpose": "execution",
"consumption": [
{
"attemptId": "b36e9080-e24f-4f22-a04d-ce70240de579",
"requestId": "2ba28fda-8ed2-4ad7-a800-5ea04269f2ad",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"connectionName": "jojocode",
"model": "gpt-6.1-sol",
"endpoint": "https://jojocode.com/v1",
"protocol": "chat-completions",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"responseUrl": "https://jojocode.com/v1/chat/completions",
"redirected": false,
"redirectMode": "manual",
"startedAt": "2026-11-03T14:34:44.894Z",
"finishedAt": "2026-11-03T14:34:55.017Z",
"outcome": "completed",
"usageStatus": "reported",
"usage": {
"prompt_tokens": 86,
"completion_tokens": 26,
"total_tokens": 112
},
"localEstimate": {
"schemaVersion": 1,
"inputTokens": 164,
"outputTokens": 256,
"requestSha256": "ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8",
"requestBytes": 444,
"estimateMethod": "utf8-third-plus-framing-v1"
},
"modelIdentity": {
"schemaVersion": 1,
"requestedModel": "gpt-6.1-sol",
"reportedModels": [
"gpt-6.1-sol"
],
"status": "matched",
"complete": true,
"invalidIdentifiers": false,
"policy": "require-match",
"scope": "Identifiers in the outgoing request and upstream response; neither equal identifiers nor a declared mapping authenticate model weights.",
"responseSource": {
"artifactId": "3566a31c-4a8f-4058-a937-697fd58fadcc",
"sha256": "c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"scope": "http-body"
}
},
"estimatedUnknownTokens": 0
}
],
"workspaceIdentity": {
"kind": "local-project",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\preflight\\identity-only"
}
}
],
"progress": {
"totalTools": 0,
"completedTools": 0,
"requiresVerification": []
},
"artifacts": [
{
"id": "842f9bef-ebef-485d-acdc-a4adcc4e5030",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"kind": "model-request",
"mediaType": "application/json",
"sha256": "ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8",
"bytes": 444,
"relative": "ef/ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8.blob",
"createdAt": "2026-11-03T14:34:44.882Z",
"status": "stored"
},
{
"id": "176748ce-9fc1-4f13-a500-7aa6a180a794",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"kind": "context-plan",
"mediaType": "application/json",
"sha256": "37ebe07da991123246b085f0d304950a4ff8eacad41793cb7af057b0baea2fd2",
"bytes": 2077,
"relative": "37/37ebe07da991123246b085f0d304950a4ff8eacad41793cb7af057b0baea2fd2.blob",
"createdAt": "2026-11-03T14:34:44.884Z",
"status": "stored"
},
{
"id": "76c93c4f-3442-4d32-ba1a-0fb91588867c",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"kind": "model-attempt-request",
"mediaType": "application/json",
"sha256": "ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8",
"bytes": 444,
"relative": "ef/ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8.blob",
"createdAt": "2026-11-03T14:34:44.888Z",
"status": "stored"
},
{
"id": "3566a31c-4a8f-4058-a937-697fd58fadcc",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"kind": "model-http-response",
"mediaType": "text/plain",
"sha256": "c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f",
"bytes": 360,
"relative": "c9/c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f.blob",
"createdAt": "2026-11-03T14:34:55.012Z",
"status": "stored"
}
],
"checks": [],
"browsingTabs": [],
"browsingActions": [],
"previewPlans": [],
"previewJobs": [],
"mcpJobs": [],
"taskPlans": [],
"taskProofs": [],
"researchTargets": [],
"researchJobs": [],
"engineJobs": [],
"browserPlans": [],
"browserJobs": [],
"contextPlans": [
{
"schemaVersion": 1,
"id": "2ba28fda-8ed2-4ad7-a800-5ea04269f2ad",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"stepId": "656a23fb-a8ec-43fb-9969-913183cbdf85",
"requestIndex": 1,
"status": "completed",
"createdAt": "2026-11-03T14:34:44.882Z",
"finishedAt": "2026-11-03T14:34:55.025Z",
"requestSha256": "ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8",
"requestBytes": 444,
"estimatedInputTokens": 164,
"requestArtifactId": "842f9bef-ebef-485d-acdc-a4adcc4e5030",
"tokenReservation": {
"schemaVersion": 1,
"method": "observed-route-max-v1",
"overheadTokens": 0,
"reservedTokens": 420,
"routes": [
{
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"model": "gpt-6.1-sol",
"protocol": "chat-completions",
"endpoint": "https://jojocode.com/v1",
"localInputTokens": 164,
"outputReservation": 256,
"inputRatio": 1,
"observedOutputTokens": 256,
"observedTotalFloor": 0,
"reservedTokens": 420,
"sources": []
}
]
},
"maxBudgetAttempts": 8,
"estimateMethod": "utf8-third-plus-framing-v1",
"beforeInputTokens": 164,
"beforeBytes": 444,
"budget": {
"contextLimit": 16000,
"outputReservation": 256,
"safetyTokens": 1600,
"inputBudget": 14144,
"targetInputTokens": 14144,
"runRemainingTokens": 16000,
"taskRemainingTokens": 16000,
"limitingReason": "context_limit"
},
"mandatoryInputTokens": 164,
"nextReadFixedInputTokens": 164,
"workingRetentionTokens": 0,
"workingRetentionPolicyVersion": 1,
"originalMessages": 1,
"retainedMessages": 1,
"archivedGroups": 0,
"retainedGroups": [
0
],
"historyIndexArtifactId": null,
"historyIndexSha256": null,
"actualUsage": {
"prompt_tokens": 86,
"completion_tokens": 26,
"total_tokens": 112
},
"workingSetArtifactId": null,
"workingSetSha256": null,
"workingSetEntries": 0,
"workingSetViewVersion": 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": 1,
"responseSha256": "b8f83a79bf11807ea8ee229e5f8daa621d987f1e4c578ba3a42b383bf107a12f",
"source": "workbench",
"artifactId": "176748ce-9fc1-4f13-a500-7aa6a180a794"
}
],
"changeSets": [],
"plans": [],
"deliveries": [],
"deliveryPlans": [],
"accountedTaskTokens": 112
}
}
@@ -0,0 +1,84 @@
(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.__gptPProbeOnce ??= new Set();
ensure(!globalThis.__gptPProbeOnce.has(input.sessionId), 'This sample cannot be replayed.');
globalThis.__gptPProbeOnce.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: 'P · 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 };
})({"pid":36552,"port":4318,"runtimeRoot":"C:\\Users\\wangy\\AppData\\Local\\Programs\\AgentWorkbench\\versions\\Agent-Workbench-1.24.5-win-x64-20261103133956264","sessionId":"60728f43-2ff3-4279-918f-9ad4d1bc83fe","projectId":"3f4d91e0-e9d4-4338-bece-b3211507888c","connectionId":"5b4daed9-b2f7-4de0-b949-573eba70c7b3","connectionRevision":3,"credentialRevision":1,"baseUrl":"https://jojocode.com/v1","model":"gpt-6.1-sol","title":"P · jojocode GPT连接单次预检","prompt":"这是独立GPT连接身份预检,不是工程任务。只回复 OK 7d195adc-90dc-4077-9950-c23baa7faad8,不要调用工具、读写文件或执行命令。"})
@@ -0,0 +1,26 @@
{
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"status": "completed",
"stopReason": "identity_probe_complete",
"attempts": 1,
"receipts": 1,
"wireStarts": 1,
"actualTools": 0,
"usage": {
"requests": 1,
"inputTokens": 86,
"outputTokens": 26,
"totalTokens": 112,
"unknownRequests": 0,
"estimatedUnknownTokens": 0
},
"contextPlanId": "2ba28fda-8ed2-4ad7-a800-5ea04269f2ad",
"diagnostic": null,
"message": {
"role": "assistant",
"content": "OK 7d195adc-90dc-4077-9950-c23baa7faad8"
}
}
@@ -0,0 +1,14 @@
{
"pid": 36552,
"port": 4318,
"runtimeRoot": "C:\\Users\\wangy\\AppData\\Local\\Programs\\AgentWorkbench\\versions\\Agent-Workbench-1.24.5-win-x64-20261103133956264",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"connectionRevision": 3,
"credentialRevision": 1,
"baseUrl": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"title": "P · jojocode GPT连接单次预检",
"prompt": "这是独立GPT连接身份预检,不是工程任务。只回复 OK 7d195adc-90dc-4077-9950-c23baa7faad8,不要调用工具、读写文件或执行命令。"
}
@@ -0,0 +1,3 @@
{
"closed": true
}
File diff suppressed because one or more lines are too long
@@ -0,0 +1,66 @@
{
"project": {
"id": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\preflight\\identity-only",
"name": "identity-only",
"addedAt": "2026-11-03T14:34:44.745Z"
},
"session": {
"id": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"title": "新任务",
"status": "idle",
"createdAt": "2026-11-03T14:34:44.752Z",
"updatedAt": "2026-11-03T14:34:44.752Z",
"messages": [],
"events": [],
"changes": [],
"approvals": [],
"failure": null,
"lastFailure": null,
"compactions": 0,
"estimatedTokens": 0,
"usage": null,
"archived": false,
"revision": 1,
"eventSeq": 13082,
"inputAttachments": [],
"execution": {
"schemaVersion": 1,
"task": null,
"run": null,
"workspaceIdentity": {
"kind": "local-project",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\preflight\\identity-only"
},
"workspaces": [],
"runs": [],
"progress": {
"totalTools": 0,
"completedTools": 0,
"requiresVerification": []
},
"artifacts": [],
"checks": [],
"browsingTabs": [],
"browsingActions": [],
"previewPlans": [],
"previewJobs": [],
"mcpJobs": [],
"taskPlans": [],
"taskProofs": [],
"researchTargets": [],
"researchJobs": [],
"engineJobs": [],
"browserPlans": [],
"browserJobs": [],
"contextPlans": [],
"changeSets": [],
"plans": [],
"deliveries": [],
"deliveryPlans": [],
"accountedTaskTokens": 0
}
}
}
@@ -0,0 +1,21 @@
{
"passed": true,
"pid": 36552,
"version": "1.24.5",
"originalExports": 75,
"originalArtifacts": 3605,
"originalRowsExact": [
"sessions",
"records",
"events",
"outbox"
],
"otherMetadataExceptAppendedAttemptsExact": true,
"originalPublicProjectsExact": true,
"originalConfigRegistryAndPoolExact": true,
"observedConnectionHealthChange": true,
"inspectorClosed": true,
"noKeyReadOrResaved": true,
"ownedProjectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"ownedSessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe"
}
@@ -0,0 +1,67 @@
{
"passed": true,
"engineeringTestAllowed": true,
"testedAt": "2026-11-03T14:34:55.255Z",
"version": "1.24.5",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"requestedModel": "gpt-6.1-sol",
"reportedModels": [
"gpt-6.1-sol"
],
"identity": {
"schemaVersion": 1,
"requestedModel": "gpt-6.1-sol",
"reportedModels": [
"gpt-6.1-sol"
],
"status": "matched",
"complete": true,
"invalidIdentifiers": false,
"policy": "require-match",
"scope": "Identifiers in the outgoing request and upstream response; neither equal identifiers nor a declared mapping authenticate model weights.",
"responseSource": {
"artifactId": "3566a31c-4a8f-4058-a937-697fd58fadcc",
"sha256": "c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"scope": "http-body"
}
},
"requestUrl": "https://jojocode.com/v1/chat/completions",
"requests": 1,
"usage": {
"prompt_tokens": 86,
"completion_tokens": 26,
"total_tokens": 112
},
"usageStatus": "reported",
"actualTools": 0,
"stopReason": "identity_probe_complete",
"captures": [
{
"attemptId": "b36e9080-e24f-4f22-a04d-ce70240de579",
"kind": "request",
"artifactId": "76c93c4f-3442-4d32-ba1a-0fb91588867c",
"path": "preflight/captures/b36e9080-e24f-4f22-a04d-ce70240de579-request.json",
"sha256": "ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8",
"bytes": 444
},
{
"attemptId": "b36e9080-e24f-4f22-a04d-ce70240de579",
"kind": "response",
"artifactId": "3566a31c-4a8f-4058-a937-697fd58fadcc",
"path": "preflight/captures/b36e9080-e24f-4f22-a04d-ce70240de579-response.txt",
"sha256": "c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f",
"bytes": 360
}
],
"noRetryOrPoolSwitch": true,
"modelWeightsAuthenticated": false,
"engineeringDeliveryTested": false,
"purgeBenefitTested": false,
"defaultSelectionChanged": false,
"connectionConfigChanged": false,
"credentialValuesReadOrSaved": false
}
@@ -0,0 +1,588 @@
{
"id": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"title": "P · jojocode GPT连接单次预检",
"status": "completed",
"createdAt": "2026-11-03T14:34:44.752Z",
"updatedAt": "2026-11-03T14:34:55.032Z",
"messages": [
{
"id": "82f2b5c6-d2eb-4bae-9dce-ec57e78818d2",
"role": "user",
"content": "这是独立GPT连接身份预检,不是工程任务。只回复 OK 7d195adc-90dc-4077-9950-c23baa7faad8,不要调用工具、读写文件或执行命令。",
"createdAt": "2026-11-03T14:34:44.875Z"
},
{
"id": "b8cde330-e354-432d-9f09-22a35b7b37d1",
"role": "assistant",
"content": "OK 7d195adc-90dc-4077-9950-c23baa7faad8",
"createdAt": "2026-11-03T14:34:55.027Z"
}
],
"events": [
{
"id": "e53a7e1d-e11b-494b-bfff-d1c878c23eac",
"createdAt": "2026-11-03T14:34:44.894Z",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"kind": "model",
"source": "model_connection",
"label": "P · GPT单次身份预检(无工具)",
"phase": "completed",
"contextPlanId": "2ba28fda-8ed2-4ad7-a800-5ea04269f2ad",
"startedAt": "2026-11-03T14:34:44.894Z",
"modelAttemptId": "b36e9080-e24f-4f22-a04d-ce70240de579",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"actualModel": "gpt-6.1-sol",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"modelIdentity": {
"schemaVersion": 1,
"requestedModel": "gpt-6.1-sol",
"reportedModels": [
"gpt-6.1-sol"
],
"status": "matched",
"complete": true,
"invalidIdentifiers": false,
"policy": "require-match",
"scope": "Identifiers in the outgoing request and upstream response; neither equal identifiers nor a declared mapping authenticate model weights.",
"responseSource": {
"artifactId": "3566a31c-4a8f-4058-a937-697fd58fadcc",
"sha256": "c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"scope": "http-body"
}
},
"finishedAt": "2026-11-03T14:34:55.029Z"
}
],
"changes": [],
"approvals": [],
"failure": null,
"lastFailure": null,
"compactions": 0,
"estimatedTokens": 164,
"usage": {
"prompt_tokens": 86,
"completion_tokens": 26,
"total_tokens": 112
},
"archived": false,
"revision": 17,
"eventSeq": 13098,
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"inputAttachments": [],
"execution": {
"schemaVersion": 1,
"task": {
"schemaVersion": 1,
"id": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"goal": "这是独立GPT连接身份预检,不是工程任务。只回复 OK 7d195adc-90dc-4077-9950-c23baa7faad8,不要调用工具、读写文件或执行命令。",
"instructions": [],
"constraints": [],
"acceptance": [],
"status": "completed",
"previousTaskId": null,
"createdAt": "2026-11-03T14:34:44.872Z",
"updatedAt": "2026-11-03T14:34:55.032Z",
"activeRunId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"usage": {
"requests": 1,
"inputTokens": 86,
"outputTokens": 26,
"totalTokens": 112,
"unknownRequests": 0,
"estimatedUnknownTokens": 0
},
"budget": {
"maxTokens": 16000
},
"verification": {
"status": "not_configured",
"checkJobId": null
},
"origin": "workbench",
"contract": {
"schemaVersion": 1,
"goal": "这是独立GPT连接身份预检,不是工程任务。只回复 OK 7d195adc-90dc-4077-9950-c23baa7faad8,不要调用工具、读写文件或执行命令。",
"kind": "general",
"checks": "unspecified"
},
"workspaceIdentity": {
"kind": "local-project",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\preflight\\identity-only"
},
"stagnation": null
},
"run": {
"schemaVersion": 1,
"id": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"engine": "workbench",
"status": "completed",
"startedAt": "2026-11-03T14:34:44.872Z",
"finishedAt": "2026-11-03T14:34:55.032Z",
"resumeOf": null,
"model": {
"mode": "compatible",
"baseUrl": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"contextLimit": 16000,
"maxOutputTokens": 256,
"configRevision": 61,
"modelResponseTimeoutMs": 300000,
"modelStreamIdleTimeoutMs": 120000,
"protocol": "chat-completions",
"streaming": false,
"nativeParameters": {},
"routing": {
"type": "connection",
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"revision": 3,
"strategy": "round-robin",
"sticky": true,
"maxAttempts": 1,
"queueTimeoutMs": 15000,
"members": [
{
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"name": "jojocode",
"brand": "兼容服务",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
},
"streaming": false,
"baseUrl": "https://jojocode.com/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 3,
"source": "manual",
"createdAt": "2026-10-30T14:36:37.791Z",
"updatedAt": "2026-11-02T13:25:07.450Z",
"weight": 1,
"credentialRevision": 1,
"modelIdentityPolicy": "require-match",
"modelIdentityAliases": [],
"modelIdentityAliasSource": ""
}
]
}
},
"budget": {
"maxSteps": 1,
"maxDurationMs": 320000,
"maxTokens": 16000,
"maxTaskTokens": 16000
},
"usage": {
"requests": 1,
"inputTokens": 86,
"outputTokens": 26,
"totalTokens": 112,
"unknownRequests": 0,
"estimatedUnknownTokens": 0
},
"steps": 1,
"toolCalls": 0,
"stopReason": "identity_probe_complete",
"checkpoint": {
"stepId": "656a23fb-a8ec-43fb-9969-913183cbdf85",
"completedToolIds": [],
"pendingToolIds": [],
"requiresVerification": []
},
"origin": "workbench",
"purpose": "execution",
"workspaceIdentity": {
"kind": "local-project",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\preflight\\identity-only"
},
"currentContextPlanId": "2ba28fda-8ed2-4ad7-a800-5ea04269f2ad",
"consumption": [
{
"attemptId": "b36e9080-e24f-4f22-a04d-ce70240de579",
"requestId": "2ba28fda-8ed2-4ad7-a800-5ea04269f2ad",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"connectionName": "jojocode",
"model": "gpt-6.1-sol",
"endpoint": "https://jojocode.com/v1",
"protocol": "chat-completions",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"responseUrl": "https://jojocode.com/v1/chat/completions",
"redirected": false,
"redirectMode": "manual",
"startedAt": "2026-11-03T14:34:44.894Z",
"finishedAt": "2026-11-03T14:34:55.017Z",
"outcome": "completed",
"usageStatus": "reported",
"usage": {
"prompt_tokens": 86,
"completion_tokens": 26,
"total_tokens": 112
},
"localEstimate": {
"schemaVersion": 1,
"inputTokens": 164,
"outputTokens": 256,
"requestSha256": "ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8",
"requestBytes": 444,
"estimateMethod": "utf8-third-plus-framing-v1"
},
"modelIdentity": {
"schemaVersion": 1,
"requestedModel": "gpt-6.1-sol",
"reportedModels": [
"gpt-6.1-sol"
],
"status": "matched",
"complete": true,
"invalidIdentifiers": false,
"policy": "require-match",
"scope": "Identifiers in the outgoing request and upstream response; neither equal identifiers nor a declared mapping authenticate model weights.",
"responseSource": {
"artifactId": "3566a31c-4a8f-4058-a937-697fd58fadcc",
"sha256": "c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"scope": "http-body"
}
},
"estimatedUnknownTokens": 0
}
]
},
"workspaceIdentity": {
"kind": "local-project",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\preflight\\identity-only"
},
"workspaces": [],
"runs": [
{
"id": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"status": "completed",
"startedAt": "2026-11-03T14:34:44.872Z",
"finishedAt": "2026-11-03T14:34:55.032Z",
"steps": 1,
"toolCalls": 0,
"usage": {
"requests": 1,
"inputTokens": 86,
"outputTokens": 26,
"totalTokens": 112,
"unknownRequests": 0,
"estimatedUnknownTokens": 0
},
"stopReason": "identity_probe_complete",
"model": {
"mode": "compatible",
"baseUrl": "https://jojocode.com/v1",
"model": "gpt-6.1-sol",
"contextLimit": 16000,
"maxOutputTokens": 256,
"configRevision": 61,
"modelResponseTimeoutMs": 300000,
"modelStreamIdleTimeoutMs": 120000,
"protocol": "chat-completions",
"streaming": false,
"nativeParameters": {},
"routing": {
"type": "connection",
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"revision": 3,
"strategy": "round-robin",
"sticky": true,
"maxAttempts": 1,
"queueTimeoutMs": 15000,
"members": [
{
"id": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"name": "jojocode",
"brand": "兼容服务",
"protocol": "chat-completions",
"model": "gpt-6.1-sol",
"capabilitySchema": 1,
"capabilityDeclarations": {
"text": "supported",
"tools": "supported",
"streaming": "unknown",
"vision": "unknown",
"audio": "unknown"
},
"streaming": false,
"baseUrl": "https://jojocode.com/v1",
"enabled": true,
"requiresKey": true,
"contextLimit": 16000,
"maxOutputTokens": 2048,
"concurrency": 8,
"revision": 3,
"source": "manual",
"createdAt": "2026-10-30T14:36:37.791Z",
"updatedAt": "2026-11-02T13:25:07.450Z",
"weight": 1,
"credentialRevision": 1,
"modelIdentityPolicy": "require-match",
"modelIdentityAliases": [],
"modelIdentityAliasSource": ""
}
]
}
},
"budget": {
"maxSteps": 1,
"maxDurationMs": 320000,
"maxTokens": 16000,
"maxTaskTokens": 16000
},
"resumeOf": null,
"purpose": "execution",
"consumption": [
{
"attemptId": "b36e9080-e24f-4f22-a04d-ce70240de579",
"requestId": "2ba28fda-8ed2-4ad7-a800-5ea04269f2ad",
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"connectionName": "jojocode",
"model": "gpt-6.1-sol",
"endpoint": "https://jojocode.com/v1",
"protocol": "chat-completions",
"requestUrl": "https://jojocode.com/v1/chat/completions",
"responseUrl": "https://jojocode.com/v1/chat/completions",
"redirected": false,
"redirectMode": "manual",
"startedAt": "2026-11-03T14:34:44.894Z",
"finishedAt": "2026-11-03T14:34:55.017Z",
"outcome": "completed",
"usageStatus": "reported",
"usage": {
"prompt_tokens": 86,
"completion_tokens": 26,
"total_tokens": 112
},
"localEstimate": {
"schemaVersion": 1,
"inputTokens": 164,
"outputTokens": 256,
"requestSha256": "ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8",
"requestBytes": 444,
"estimateMethod": "utf8-third-plus-framing-v1"
},
"modelIdentity": {
"schemaVersion": 1,
"requestedModel": "gpt-6.1-sol",
"reportedModels": [
"gpt-6.1-sol"
],
"status": "matched",
"complete": true,
"invalidIdentifiers": false,
"policy": "require-match",
"scope": "Identifiers in the outgoing request and upstream response; neither equal identifiers nor a declared mapping authenticate model weights.",
"responseSource": {
"artifactId": "3566a31c-4a8f-4058-a937-697fd58fadcc",
"sha256": "c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"scope": "http-body"
}
},
"estimatedUnknownTokens": 0
}
],
"workspaceIdentity": {
"kind": "local-project",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"root": "D:\\Ai-project\\REA逆向\\Agent-Workbench\\.qa\\live-delivery-p\\preflight\\identity-only"
}
}
],
"progress": {
"totalTools": 0,
"completedTools": 0,
"requiresVerification": []
},
"artifacts": [
{
"id": "842f9bef-ebef-485d-acdc-a4adcc4e5030",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"kind": "model-request",
"mediaType": "application/json",
"sha256": "ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8",
"bytes": 444,
"relative": "ef/ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8.blob",
"createdAt": "2026-11-03T14:34:44.882Z",
"status": "stored"
},
{
"id": "176748ce-9fc1-4f13-a500-7aa6a180a794",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"kind": "context-plan",
"mediaType": "application/json",
"sha256": "37ebe07da991123246b085f0d304950a4ff8eacad41793cb7af057b0baea2fd2",
"bytes": 2077,
"relative": "37/37ebe07da991123246b085f0d304950a4ff8eacad41793cb7af057b0baea2fd2.blob",
"createdAt": "2026-11-03T14:34:44.884Z",
"status": "stored"
},
{
"id": "76c93c4f-3442-4d32-ba1a-0fb91588867c",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"kind": "model-attempt-request",
"mediaType": "application/json",
"sha256": "ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8",
"bytes": 444,
"relative": "ef/ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8.blob",
"createdAt": "2026-11-03T14:34:44.888Z",
"status": "stored"
},
{
"id": "3566a31c-4a8f-4058-a937-697fd58fadcc",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"kind": "model-http-response",
"mediaType": "text/plain",
"sha256": "c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f",
"bytes": 360,
"relative": "c9/c9d8d13a34fedbc5e408ead25afe9d806b1827fb90b3e7f33d4d0dbe27f05f7f.blob",
"createdAt": "2026-11-03T14:34:55.012Z",
"status": "stored"
}
],
"checks": [],
"browsingTabs": [],
"browsingActions": [],
"previewPlans": [],
"previewJobs": [],
"mcpJobs": [],
"taskPlans": [],
"taskProofs": [],
"researchTargets": [],
"researchJobs": [],
"engineJobs": [],
"browserPlans": [],
"browserJobs": [],
"contextPlans": [
{
"schemaVersion": 1,
"id": "2ba28fda-8ed2-4ad7-a800-5ea04269f2ad",
"sessionId": "60728f43-2ff3-4279-918f-9ad4d1bc83fe",
"projectId": "3f4d91e0-e9d4-4338-bece-b3211507888c",
"taskId": "5ef5734b-7791-460a-ba7d-4d4d2e54a054",
"runId": "9be7dc7f-13d2-4e2e-be0d-888d01ee68d0",
"stepId": "656a23fb-a8ec-43fb-9969-913183cbdf85",
"requestIndex": 1,
"status": "completed",
"createdAt": "2026-11-03T14:34:44.882Z",
"finishedAt": "2026-11-03T14:34:55.025Z",
"requestSha256": "ef7a1b79c9f518fe093dfbd594542b87a8a59ded41a71b7fcc3d5526544957c8",
"requestBytes": 444,
"estimatedInputTokens": 164,
"requestArtifactId": "842f9bef-ebef-485d-acdc-a4adcc4e5030",
"tokenReservation": {
"schemaVersion": 1,
"method": "observed-route-max-v1",
"overheadTokens": 0,
"reservedTokens": 420,
"routes": [
{
"connectionId": "5b4daed9-b2f7-4de0-b949-573eba70c7b3",
"model": "gpt-6.1-sol",
"protocol": "chat-completions",
"endpoint": "https://jojocode.com/v1",
"localInputTokens": 164,
"outputReservation": 256,
"inputRatio": 1,
"observedOutputTokens": 256,
"observedTotalFloor": 0,
"reservedTokens": 420,
"sources": []
}
]
},
"maxBudgetAttempts": 8,
"estimateMethod": "utf8-third-plus-framing-v1",
"beforeInputTokens": 164,
"beforeBytes": 444,
"budget": {
"contextLimit": 16000,
"outputReservation": 256,
"safetyTokens": 1600,
"inputBudget": 14144,
"targetInputTokens": 14144,
"runRemainingTokens": 16000,
"taskRemainingTokens": 16000,
"limitingReason": "context_limit"
},
"mandatoryInputTokens": 164,
"nextReadFixedInputTokens": 164,
"workingRetentionTokens": 0,
"workingRetentionPolicyVersion": 1,
"originalMessages": 1,
"retainedMessages": 1,
"archivedGroups": 0,
"retainedGroups": [
0
],
"historyIndexArtifactId": null,
"historyIndexSha256": null,
"actualUsage": {
"prompt_tokens": 86,
"completion_tokens": 26,
"total_tokens": 112
},
"workingSetArtifactId": null,
"workingSetSha256": null,
"workingSetEntries": 0,
"workingSetViewVersion": 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": 1,
"responseSha256": "b8f83a79bf11807ea8ee229e5f8daa621d987f1e4c578ba3a42b383bf107a12f",
"source": "workbench",
"artifactId": "176748ce-9fc1-4f13-a500-7aa6a180a794"
}
],
"changeSets": [],
"plans": [],
"deliveries": [],
"deliveryPlans": [],
"accountedTaskTokens": 112
}
}
+1
View File
@@ -0,0 +1 @@
{"success":true,"files":75,"bytes":55891232,"manifestSha256":"c2ea37b5c3e34ae76e0e9283c937eb0d4082aaceedae06ecab355c8c6eb5d0aa","requests":2,"reportedTokens":112,"unknownRequests":1,"estimatedUnknownTokens":10141,"nodeDelivered":false,"tlsHandshakes":12,"tlsPassed":11,"tlsTimedOut":1,"originalDataAndDefaultsVerified":true,"productVersion":"1.24.5","originalPurgeBenefitTested":false,"gitIndex":{"passed":true,"files":76,"bytes":55904611,"exactOriginalBytes":true},"scope":"Offline original bytes, frozen configuration, accounting and declared original-state restoration; no network, model or credential access."}
+18
View File
@@ -0,0 +1,18 @@
node:internal/modules/run_main:107
triggerUncaughtException(
^
AssertionError [ERR_ASSERTION]: :docs/live-delivery-p-evidence/run/final-audit-final.log missing
at file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/scripts/verify-live-delivery-p.mjs:121:69
at ModuleJob.run (node:internal/modules/esm/module_job:561:25)
at async node:internal/modules/esm/loader:647:26
at async asyncRunEntryPointWithESMLoader (node:internal/modules/run_main:101:5) {
generatedMessage: false,
code: 'ERR_ASSERTION',
actual: null,
expected: true,
operator: '==',
diff: 'simple'
}
Node.js v24.22.1
+1
View File
@@ -0,0 +1 @@
{"success":true,"files":75,"bytes":55891232,"manifestSha256":"c2ea37b5c3e34ae76e0e9283c937eb0d4082aaceedae06ecab355c8c6eb5d0aa","requests":2,"reportedTokens":112,"unknownRequests":1,"estimatedUnknownTokens":10141,"nodeDelivered":false,"tlsHandshakes":12,"tlsPassed":11,"tlsTimedOut":1,"originalDataAndDefaultsVerified":true,"productVersion":"1.24.5","originalPurgeBenefitTested":false,"scope":"Offline original bytes, frozen configuration, accounting and declared original-state restoration; no network, model or credential access."}
+12
View File
@@ -1,5 +1,17 @@
# 汇总发现
## P:新的固定连接与验收范围
两轮只读DNS/TLS12次握手,11成功/1固定IPv6超时,证书校验始终启用、0HTTP/0模型;默认地址族选择四次均通过,不能据此认定原超时唯一原因或API稳定。最终核对原59公开项目/75导出/3605工件/207原尝试和声明原行保持,当前61项目77会话/6167记录/13115事件与outbox/3610工件。首最终核对误比legacy展示修订61→65,原驱动/日志和冻结快照保留,按全局configRevision精确声明后只读核对通过。75份/55891232字节P材料封存,manifest c2ea37b5c3e34ae76e0e9283c937eb0d4082aaceedae06ecab355c8c6eb5d0aa;独立离线原字节/身份/预算/用量/恢复/Git基线核验通过。无产品源码变化,正式仍1.24.5;具体下一诊断开发见RETROSPECTIVE-LIVE-DELIVERY-P。
新Node已结束:首attempt在10秒连接阶段UND_ERR_CONNECT_TIMEOUT,诊断before_model_send/responseReceived=false,未有HTTP响应或工具;保守记录1未知用量、10141估算预留,不能把0报告tokens当免费或成功。原76导出/3608工件/208完整尝试、原行与配置/池按声明核对通过;连接3→4→5/凭据1,身份缺省值规范化明确保存。不会重试这个Task;转只读DNS/TLS定位,不再发送模型请求。
单次预检已通过:1请求/112报告tokens/0工具,原JSON报告gpt-6.1-sol,局部require-match,9229已关闭。复查新Node驱动发现原jojocode缺省身份字段,partial-update恢复时不能省略,否则会残留require-match;改为显式恢复原record/[]/空串语义,完整保留原raw配置并准确声明三字段规范化,不声称raw字节全同。加入完整提案和Git计划的监督审查等待,不自动应用。预检只读核对脚本首轮误写不存在的artifacts表,零写入失败日志保留;实际工件在records中并另按原文件SHA核对。
正式1.24.5/PID36552当前空闲。现有启用jojocode/5b4daed9为gpt-6.1-sol、https://jojocode.com/v1、Chat非流式JSON、16K/2048、连接3/凭据1,可用于独立预检。原模型连接是legacy,不与这个具名连接混用;旧09b仍停用,新93d保持O恢复后的修订5/record。默认高性能池仍原68e30376,成员不改。
O新Node第二请求HTTP502已封存,不能把等待后续跑旧Task当新实验。P改用另一个已配置连接,以单请求预检先核对实际身份和响应;不直接把过去成功健康状态当作本次可用证明。回顾、原数据保持与未知用量按实际结果独立记录。
## O:当前实验入口与首准备失败
1.24.5/source676103c4已独立发行并正式保留PID36552/Provider升级。原58项目74会话、全部原表行/导出/工件/模型中心在网页和原生回看后再次精确保持。三种编译宿主16K回放、105相关/25升级安装、552源码输入重建22/22、三归档/便携、源码25历史UI、12实际安装及16+9安装文件流程通过。
+12
View File
@@ -1,5 +1,17 @@
# 统一执行进度
## P:新的连接预检与工程闭环
最终Git索引含清单76份/55904611字节与75份封存原件逐SHA一致,离线核验与diff检查通过。全局*.log导致首次索引漏收,本目录精确例外和原字节属性已补齐,首次日志独立保留。报告、回顾、下一诊断开发切片和规划按本轮范围本地保存;没有产品新发行、远端推送或额外模型调用。
P阶段实验、网络定位、原状态核对及75份/55891232字节证据封存完成;独立离线核验通过。原59项目75会话/3605工件/207尝试保持,新增两项目/会话/尝试归属明确。默认池/原预算恢复、身份缺省值规范化明列,PID36552/Provider及1.24.5不动。当前QA-LIVE-DELIVERY-P、回顾和下一连接诊断开发切片已记录,本地Git收尾中;真实Node和Purge未通过不提前记完成。首最终核对legacy展示修订误比的原日志/驱动保留,修正声明后复核未做任何模型调用或配置写入。
新Node首请求UND_ERR_CONNECT_TIMEOUT,1尝试/0报告tokens/1未知预留10141,20秒结束,0工具/审批/应用/检查/交付。所有原76导出/3608工件/208尝试与原公开项目/预算/池已恢复核对;原缺省身份字段显式默认值规范化单列。未重试或切池。下一独立DNS/TLS握手检查0模型请求,不改协议、不把网络失败写成自主交付通过。
预检已完成:jojocode5b4原Provider,GPT/Chat JSON,1请求/112报告tokens/0工具,无重试切池,原请求与响应型号matched。预检和Node驱动均保留原件;Node原缺省身份策略恢复陷阱在发送前修正,显式默认值规范化单独声明。新增人工内容审查门禁。预检首状态核对脚本误用不存在的artifacts表,仅只读失败,原日志保留后按实际schema修正,不重放预检。
用户要求继续全量推进并及时回顾。接续9d549a71,建立test/live-delivery-p-1.24.5;正式服务1.24.5/PID36552空闲、原Provider/Key保持,O原件不修改。已选择现有具名jojocode/5b4daed9进行新独立预检,不用legacy或当前池隐式选线,维持16K/2048与原8请求/90000tokens上限。计划先封存基线和单次预检,按结果推进新Node及可能的定向修复。
## O:正确GPT连接的新实验准备
1.24.5已本地交付,最终冻结676103c4/候选20261103133956264。三归档/便携、552源码输入独立重建22/22、三载荷16K原双回复回放、源码25历史UI、12实际安装及16+9安装文件流程通过。正式保留原PID36552/Provider,58项目74会话和全部原数据/模型中心在网页/原生回看后再次精确保持;原生首启动暂未返回窗口,实际清单确认唯一新窗口后继续,未重启或重复启动。窄屏首验收误等隐藏侧栏而超时,保留首失败,只复验窄屏并回看实际画面;内置浏览器控制不可用,使用独立Edge/原生,不伪称操作了现有页。
+132
View File
@@ -0,0 +1,132 @@
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-p-evidence');
const sha = bytes => createHash('sha256').update(bytes).digest('hex');
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 read = name => JSON.parse(fs.readFileSync(file(name), 'utf8'));
const manifest = read('manifest.json'); assert.equal(manifest.kind, 'owned-live-delivery-p-evidence');
const names = new Set(); let bytes = 0;
for (const row of manifest.files) {
assert.ok(!names.has(row.path)); names.add(row.path);
const content = fs.readFileSync(file(row.path)); assert.equal(content.length, row.bytes); assert.equal(sha(content), row.sha256, row.path); bytes += content.length;
}
const list = (folder = root) => fs.readdirSync(folder, { withFileTypes: true }).flatMap(entry => {
assert.equal(entry.isSymbolicLink(), false); const target = path.join(folder, 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)); 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);
const connectionId = '5b4daed9-b2f7-4de0-b949-573eba70c7b3';
for (const [folder, outcome] of [['preflight', preflight], ['node', node]]) {
const attempts = owned('run/' + folder + '/attempts.json'); assert.equal(attempts.length, 1);
const attempt = attempts[0]; assert.equal(attempt.connectionId, connectionId); 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.credentialRevision, 1);
assert.equal(attempt.modelIdentity.policy, 'require-match');
const request = outcome.captures.find(value => value.kind === 'request'); assert.ok(request);
assert.equal(request.attemptId, attempt.id); assert.ok(names.has('run/' + request.path));
const requestBytes = fs.readFileSync(file('run/' + request.path));
assert.equal(sha(requestBytes), request.sha256); assert.equal(request.sha256, attempt.requestSha256); assert.equal(requestBytes.length, attempt.requestBytes);
const body = JSON.parse(requestBytes); assert.equal(body.model, 'gpt-6.1-sol'); assert.notEqual(body.stream, true);
const restoration = owned('run/' + folder + '/restoration.json'); assert.equal(restoration.passed, true);
if (folder === 'preflight') {
assert.equal(preflight.passed, true); assert.equal(body.tools?.length ?? 0, 0); assert.equal(body.max_tokens, 256);
assert.equal(preflight.actualTools, 0); assert.equal(attempt.status, 'completed'); assert.equal(attempt.usageStatus, 'reported');
assert.equal(attempt.modelIdentity.status, 'matched'); assert.equal(attempt.modelIdentity.complete, true);
const response = preflight.captures.find(value => value.kind === 'response'); assert.ok(response);
const responseBytes = fs.readFileSync(file('run/' + response.path)); assert.equal(sha(responseBytes), response.sha256);
assert.equal(response.sha256, attempt.responseSha256); assert.equal(response.sha256, preflight.identity.responseSource.sha256);
const original = JSON.parse(responseBytes); assert.equal(original.model, 'gpt-6.1-sol'); assert.deepEqual(original.usage, attempt.usage);
assert.equal(original.usage.total_tokens, 112); assert.deepEqual(preflight.usage, original.usage);
assert.equal(original.choices[0].message.tool_calls?.length ?? 0, 0);
assert.ok(original.choices[0].message.content.includes(owned('run/preflight/contract.json').nonce));
assert.equal(restoration.originalConfigRegistryAndPoolExact, true); assert.equal(restoration.inspectorClosed, true);
} else {
assert.equal(body.max_tokens, 2048); assert.ok(body.tools.length > 0); assert.equal(node.success, false);
assert.equal(attempt.status, 'failed'); assert.equal(attempt.httpStatus, null); assert.equal(attempt.usage, null); assert.equal(attempt.usageStatus, 'unknown');
assert.equal(attempt.responseArtifactId, undefined); assert.equal(node.captures.length, 1);
assert.equal(attempt.modelIdentity.complete, false); assert.equal(attempt.diagnostic.code, 'UND_ERR_CONNECT_TIMEOUT');
assert.equal(attempt.diagnostic.network.stage, 'connect'); assert.equal(attempt.diagnostic.network.replaySafety, 'before_model_send');
assert.equal(attempt.diagnostic.network.responseReceived, false); assert.equal(attempt.diagnostic.retryDecision, 'attempt_limit');
assert.equal(attempt.diagnostic.network.transport.connectTimeoutMs, 10000);
assert.equal(node.usage.requests, 1); assert.equal(node.usage.totalTokens, 0); assert.equal(node.usage.unknownRequests, 1); assert.equal(node.usage.estimatedUnknownTokens, 10141);
const session = owned('run/node/session.json'), plan = session.execution.contextPlans[0];
assert.equal(plan.tokenReservation.reservedTokens, node.usage.estimatedUnknownTokens);
assert.equal(plan.budget.contextLimit, 16000); assert.equal(plan.budget.outputReservation, 2048); assert.equal(plan.budget.safetyTokens, 1600);
assert.equal(session.execution.run.budget.maxSteps, 8); assert.equal(session.execution.run.budget.maxTokens, 90000);
assert.equal(session.execution.run.toolCalls, 0); assert.deepEqual(session.execution.checks, []); assert.deepEqual(session.changes, []);
assert.deepEqual(node.approvals, []); assert.deepEqual(node.applications, []); assert.equal(node.modelImplementationSuppliedBySupervisor, false);
assert.equal(restoration.budgetsAndSelectionRestored, true); assert.equal(restoration.poolsUnchanged, true);
assert.equal(restoration.originalCredentialRevision, 1); assert.equal(restoration.finalCredentialRevision, 1);
assert.equal(restoration.registryExceptDeclaredRevisionTimestampOrderAndIdentityDefaultsExact, true);
assert.deepEqual(restoration.identityDefaultNormalization, { modelIdentityPolicy: 'record', modelIdentityAliases: [], modelIdentityAliasSource: '' });
}
}
assert.equal(network.realModelRequests, 0); assert.equal(network.httpRequests, 0); assert.equal(network.keyValuesReadOrSent, false);
assert.equal(network.tlsCertificateValidationEnabled, true); assert.equal(network.productConfigurationChanged, false);
assert.equal(network.results.length, 4);
const trials = network.results.flatMap(value => value.trials); assert.equal(trials.length, 12); assert.equal(trials.filter(value => value.success).length, 11);
const failure = trials.find(value => !value.success); assert.equal(failure.mode, 'ipv6-only-diagnostic'); assert.equal(failure.code, 'QA_TLS_TIMEOUT');
assert.ok(trials.filter(value => value.success).every(value => value.certificateAuthorized === true));
assert.equal(final.passed, true); assert.equal(final.pid, 36552); assert.equal(final.version, '1.24.5');
assert.equal(final.originalProjects, 59); assert.equal(final.originalSessions, 75); assert.equal(final.originalArtifacts, 3605); assert.equal(final.originalAttempts, 207);
assert.equal(final.finalProjects, 61); assert.equal(final.finalSessions, 77); assert.equal(final.addedAttempts, 2);
assert.equal(final.originalBudgetsSelectionAndPoolRestored, true); assert.equal(final.originalSessionExportsRowsAndArtifactsExact, true);
assert.equal(final.exactSinceNodeRestoration, true); assert.equal(final.inspectorClosed, true); assert.equal(final.keyReadOrResaved, false);
const snapshot = owned('run/final/snapshot.json');
for (const row of initial.baseline.exports) assert.deepEqual(snapshot.exports.find(value => value.id === row.id), row);
for (const table of ['sessions', 'records', 'events', 'outbox']) {
const rows = new Map(snapshot.database.tables[table].rows.map(value => [value.id, value]));
for (const row of initial.baseline.database.tables[table].rows) assert.deepEqual(rows.get(row.id), row);
}
const artifacts = new Map(snapshot.persistent.artifacts.map(value => [value.path, value]));
for (const row of initial.baseline.persistent.artifacts) assert.deepEqual(artifacts.get(row.path), row);
assert.deepEqual(snapshot.modelCenter.selected, initial.center.selected); assert.deepEqual(snapshot.modelCenter.pools, initial.center.pools);
assert.deepEqual(final.connectionRevision, [3, 5]); assert.deepEqual(final.legacyDisplayRevisionFollowsGlobalConfigurationRevision, [61, 65]);
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 beforeMeta = owned('run/node/original-public-metadata.json'), afterMeta = owned('run/node/final-public-metadata.json');
assert.deepEqual({ ...afterMeta.config, configRevision: beforeMeta.config.configRevision }, beforeMeta.config);
const registry = structuredClone(afterMeta.registry); registry.revision = beforeMeta.registry.revision;
const currentConnection = registry.connections.find(value => value.id === connectionId), oldConnection = beforeMeta.registry.connections.find(value => value.id === connectionId);
assert.equal(currentConnection.revision, oldConnection.revision + 2);
currentConnection.revision = oldConnection.revision; currentConnection.updatedAt = oldConnection.updatedAt;
const expected = structuredClone(beforeMeta.registry); Object.assign(expected.connections.find(value => value.id === connectionId), {
modelIdentityPolicy: 'record', modelIdentityAliases: [], modelIdentityAliasSource: '' });
for (const value of [expected, registry]) value.connections.sort((a, b) => a.id.localeCompare(b.id));
assert.deepEqual(canonical(registry), canonical(expected));
for (const name of ['src/amount.mjs', 'src/summary.mjs', 'src/report.mjs']) assert.deepEqual(fs.readFileSync(file('run/node/source-before/' + name)), fs.readFileSync(file('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.stagedAfter, baseline.stagedBefore); assert.equal(git.status, baseline.status); assert.equal(git.diff, '');
assert.equal(manifest.releaseSourceCommit, owned('provenance/release-1.24.5.json').sourceCommit);
assert.equal(final.productSourceChanged, false); assert.equal(final.nodeDelivered, false); assert.equal(final.purgeBenefitTested, false);
let gitIndex;
if (process.argv.includes('--index')) {
const evidenceRoot = path.relative(process.cwd(), root).replaceAll('\\', '/');
const manifestBytes = fs.readFileSync(file('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 => ':' + evidenceRoot + '/' + row.path).join('\n') + '\n',
maxBuffer: 100 * 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');
const match = header.match(/^[a-f0-9]{40} blob (\d+)$/); assert.ok(match, header);
const size = Number(match[1]); offset = end + 1;
const content = output.subarray(offset, offset + size); offset += size;
assert.equal(output[offset++], 10); assert.equal(size, entry.bytes, entry.path); assert.equal(sha(content), 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, manifestSha256: sha(fs.readFileSync(file('manifest.json'))),
requests: 2, reportedTokens: 112, unknownRequests: 1, estimatedUnknownTokens: 10141, nodeDelivered: false,
tlsHandshakes: trials.length, tlsPassed: 11, tlsTimedOut: 1, originalDataAndDefaultsVerified: true, productVersion: '1.24.5',
originalPurgeBenefitTested: false, ...(gitIndex ? { gitIndex } : {}),
scope: 'Offline original bytes, frozen configuration, accounting and declared original-state restoration; no network, model or credential access.' }));
+10
View File
@@ -1,5 +1,15 @@
# Agent Workbench:核心代理能力研究与产品计划
## 当前 P:另一已配置连接的独立真实交付验收
用户已明确继续全量推进并回顾总结。接续9d549a71,不委派子代理;保持正式1.24.5/PID36552/Provider与凭据、当前高性能池和旧09b停用。O的两次Node失败封存不续跑。本轮固定现有启用jojocode/5b4daed9(GPT/Chat JSON、16K/2048、凭据1、连接3),先新单次严格身份预检,再新Node原九测试。预检最多1请求/16000tokens/256输出;Node最多8请求/90000tokens、16K/2048,监督不提供实现,不在失败后补预算或自动切池。
1. [complete] 正式1.24.5/PID36552/Provider,固定jojocode5b4/Chat JSON/16K/2048/连接3/凭据1,新原状态基线已封存,无Key访问。
2. [complete] 新单次预检1请求/112报告tokens/0工具/strict matched,无重试切池;原75导出/3605工件、全部原会话记录事件、公开原项目/配置/registry/池与原尝试保持,9229关闭。首只读验收器误用不存在的artifacts表,日志保留。
3. [complete] 新Node首连接10秒超时UND_ERR_CONNECT_TIMEOUT,1尝试/0报告tokens/1未知预留10141,未取得原响应、0工具/修改/检查/交付。未重试/切池/续跑;原76导出/3608工件/208尝试及声明原状态恢复通过,凭据1/连接3→4→5,原缺省身份三字段显式record/[]/空串规范化另列。
4. [complete] 独立0HTTP/0模型DNS/TLS两轮12次,11成功/1固定IPv6超时,不能认定唯一根因;不改正确协议,不新增产品发行。下一所属连接诊断开发与本地失败场景/入口验收明确记录,Node后才React/Python及Purge。
5. [complete] 原59项目75导出/3605工件/207尝试和原行/预算/池按声明保持,当前61项目77会话。75份/55891232字节证据及原失败已封存,离线与含清单76份/55904611字节Git索引逐SHA核对通过,报告/回顾/下一诊断切片记录并按本轮范围本地保存,不推送。首次索引漏收被全局忽略的日志已补精确例外,原失败日志保留。更新性能单列,1.25保持计划。
## 当前 O:正确GPT连接的真实交付实测
接续a77bc981,用户已要求继续按计划推进。沿用planning-with-files,不委派子代理。保持旧apikey/09b停用、原宿主/Provider和Key;使用用户已启用的新apikey/93d,仅在新建自有工程和会话实验,不续跑J/E/H/M。预检最多1请求/16000tokens/256输出,Node最多8请求/90000tokens;先冻结实际连接容量,不暗改16K上限。