chore(qa): freeze independent apikey sample Y after X connection guard

This commit is contained in:
Agent Workbench Dev
2026-11-04 23:04:19 +08:00
parent 0667458321
commit af89f019dd
16 changed files with 692 additions and 1 deletions
+2
View File
@@ -1,5 +1,7 @@
# Agent Workbench项目执行规范
最新真实实验选择:X在预冻结时发现原jojocode被外部停用(revision12),在创建样本目录/诊断/模型之前拒绝,0请求。用户明确改用当前启用的apikey并“另冻新实验,不沿用X”,执行docs/LIVE-DELIVERY-Y-PLAN.md及scripts/live-y。连接93d0cf6d/Chat SSE/gpt-6.1-sol/凭据修订1,保留原身份来源https://api.apikey.fan;目标/8请求90000tokens/16K2048保持,不启用jojocode、不续跑X或旧样本。下面“下一X”按历史计划理解。
1.25.2已完成独立本地发行、真实隔离安装和保留原PID36552/instance/Provider的正式升级,产品来源d510cb7049aea9ca61ddc4cf2c2e21dfc0153f1d、候选20261104134035379;正式耗时289669ms,旧1.25.1的156369ms和1.25.0的774098ms保持。67项目83会话6477记录13663事件/outbox及3773原工件、全部原行/导出/公开配置在网页两视口及实际原生回看后再次exact,窗口0/9229关闭、hasKey=true。617冻结输入、源码ZIP622输入独立重建22/22、三归档、便携八套50组及文件9/结果16/读取10、实际安装12组和安装副本十套75组通过。最终完整测试898/899:重启用例在重启前首次审批8秒等待超时;相同源码/原断言/原期限精确补验1/1通过,不宣称整轮全绿。旧TLS/浏览器失败、两次并发背景Harness启动超时与迟到ready均保留;唯一超时根因/高负载稳定性仍未知。1339份126224544字节证据离线通过,见docs/QA-RELIABILITY-1.25.2.md、docs/RETROSPECTIVE-RELIABILITY-1.25.2.md及发行身份。下一按X计划只新冻一次诊断/身份预检/Node,不续跑旧样本;Node闭环后才React/Python及独立原版Purge。真实自主交付、网络间歇根因、真实异常剔除收益和Purge仍未验证。不委派、不推送、不读取/复制/解密/重存Key,不重启正式Provider。以下“验收中/正式1.25.1”等按历史时点理解。
当前1.25.2可靠性修复已开发并分阶段本地提交,正在独立发行验收;正式仍以实际1.25.1状态为准,不把源码修复当正式已升级。用户已在独立复核后全盘授权继续修复/开发/验证/本地提交及修复后新冻有界样本X,计划docs/RELIABILITY-1.25.2.md和docs/LIVE-DELIVERY-X-PLAN.md。预留v3原账本顺序/输出上界、安装扫描后文件检查、升级兼容、明确不检查约定、混合进展停止与纯读取批次吞吐已修;原W的“纯属模型、产品无缺陷”归因被证据纠正:末轮有468新字符且shadow为evidence_growth,原停止和0交付保持。旧v1/v2/原失败不改写,网络间歇根因/真实自主交付/Purge仍各自待验。不委派、不推送、不提取/复制/解密/重存Key,不重启正式Provider;X只新建样本,不续跑W/V/T/R/P/O。以下均按历史时点理解。
+2
View File
@@ -1,5 +1,7 @@
# X:可靠性修复后的新有界真实样本
最新状态:正式1.25.2发行完成后,X的initial在任何样本目录/诊断/模型/工程之前发现原jojocode已被外部停用(revision12),按原守卫拒绝,真实请求0。用户明确选择改用当前启用的apikey并另冻新实验,转入[LIVE-DELIVERY-Y-PLAN](LIVE-DELIVERY-Y-PLAN.md);X不续跑、不改选线,也不启用jojocode。首拒绝原日志见[LIVE-DELIVERY-X-PREFREEZE-REFUSAL](LIVE-DELIVERY-X-PREFREEZE-REFUSAL.txt)。以下原冻结设计保持。
用户在独立复核后授权持续修复、验证与本地提交。X另建工程/Task,不续跑或改写W/R/T/P/O;W六次只读、混合进展停止和0交付保留。先完成1.25.2独立发行与正式保留状态升级;本计划不是成功保证。
## 固定因素
@@ -0,0 +1,19 @@
node:internal/modules/run_main:107
triggerUncaughtException(
^
AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
false !== true
at file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/scripts/live-x/initial.mjs:15:8
at process.processTicksAndRejections (node:internal/process/task_queues:104:5) {
generatedMessage: true,
code: 'ERR_ASSERTION',
actual: false,
expected: true,
operator: 'strictEqual',
diff: 'simple'
}
Node.js v24.22.1
+19
View File
@@ -0,0 +1,19 @@
# Y:使用当前启用的 apikey 的新有界样本
用户明确选择“改用当前启用的apikey,另冻新实验,不沿用X”。正式1.25.2独立发行及保留状态升级已完成(产品来源d510cb7049aea9ca61ddc4cf2c2e21dfc0153f1d,候选20261104134035379)。X在预冻结第15行发现jojocode已停用(revision12),在创建样本目录、诊断、模型或工程之前拒绝;0请求且不重放,不启用该连接。Y是另一个样本,不能与W/X合并为同条件收益比较。
## 冻结因素与限额
使用当前已启用的apikey连接93d0cf6d-4f32-4918-9da8-6f125aa8a6e5:https://api.apikey.fan/v1、Chat Completions、gpt-6.1-sol、streaming=true、revision5、credentialRevision1、16K上下文/2048输出/单并发。保留它的流式设置及原身份record/空别名/来源https://api.apikey.fan;在新预检快照及Node临时策略中严格require-match、无别名,随后精确恢复。原Provider内存连接直接使用,不读取/复制/解密/重存Key。默认高性能池及其成员保持,工程阶段只临时选中本连接,恢复原选择;不切池、换线或自动重试。
scripts/live-y独立复制已审查X驱动;完整工程目标、原三模块/九测试/build/11文件、owner staged/unstaged/untracked保护和人工边界均不改。Y与W相同目标SHA应为ea3eaee0a94112085b6e41f528397f32fb2640a963a40add9bd3549b9eb642e0;实际冻结后再次核对。Node8请求/90000报告tokens/600000ms,16K/2048/1600,不增加预算、实现提示或催写。
只执行一次:initial实际安装清单与来源冻结→network所属DNS/TCP/TLS(0HTTP/模型,仅观察不阻断)→preflight单次无工具身份请求(最多256输出/16000tokens/单请求,报告型号严格匹配)→预检通过才Node。预检失败即封存,网络/未知消费无自动重试或切换。工程只由模型实现,监督仅批准原test/build、审查应用模型完整三文件变更集和确认模型Git计划;审查续接仍属于原8请求预算。部分提案、不完整批次、身份不符、失败/无进展/预算停止均保留原结果,不代写或追加指导。
成功需要模型三文件提案和封存批次、实际应用、原九测试9/9和build、当前输入证明、owner改动原字节/原暂存保持、模型Git计划及本地已确认交付。读取、模型口头完成、基线build和连接成功不计工程交付。每次实际请求/响应/上游用量、已读范围、单轮事实和停止原因保存;matched只表示上游字段符合,非模型权重认证。
## 状态与后续
正式PID36552/instance/Provider保持,9229只为所属单次身份预检临时打开并finally关闭。样本前后逐项对账原表/导出/工件/原modelAttempts/公开配置;只允许新自有样本记录、观察健康与明确的单调修订。apikey身份来源精确恢复为原https://api.apikey.fan,凭据修订1保持;jojocode停用、其它连接/默认池及用户新连接保持。预算、选择、身份都恢复后封存.qa/live-delivery-y/MANIFEST.json,离线核对并本地提交报告,不推送、不委派。
Node闭环后才另冻React/Python,再独立原版Purge AB/BA。Y更换了供应商和流式设置,不能单独归因1.25.2读取/预留收益。原W/T/R/V/P/O及X预冻结拒绝保留;网络间歇根因、真实异常剔除收益、高负载启动稳定性和Purge仍待独立验证。
+14
View File
@@ -0,0 +1,14 @@
{
"passed": true,
"goalSourceExactWithXAndW": true,
"syntaxFiles": 9,
"productSource": "d510cb7049aea9ca61ddc4cf2c2e21dfc0153f1d",
"apikeyConnection": "93d0cf6d-4f32-4918-9da8-6f125aa8a6e5",
"streaming": true,
"protocol": "chat-completions",
"nodeRequests": 8,
"nodeTokens": 90000,
"nodeDurationMs": 600000,
"realModelRequests": 0,
"scope": "Driver-only review; no product build or model call"
}
+2
View File
@@ -2,6 +2,8 @@
## 1.25.2 可靠性闭环
- 发行证据及原字节索引核对后提交06674583,树干净。X initial第15行发现jojocode enabled=false/revision12,任何样本/请求前拒绝。用户明确选择当前启用apikey,另冻Y,不沿用X;Y使用93d连接/Chat SSE/原身份来源,原工程目标和预算保持。驱动/新计划先语法、同目标与预算复核提交,再实际冻结;不启用jojocode,不碰Key。
- 正式1.25.2已保留PID36552/instance/Provider升级,操作289669ms;网页1440/390及真实原生回看后窗口0、9229关闭、全部67项目83会话原状态/6477记录13663事件和3773工件exact。新候选独立622输入/22编译、便携、安装12组+75UI通过。
- 最终完整898/899,唯一api.test:101首次审批原8秒超时;原断言同源单项1/1通过。严格899控制器拒绝记录和补验全部保留,未修改期限/断言;高负载稳定性仍未知。封存首次不能解析失败的多行JSON,原partial移入.qa保留后补解析;新封存1339份126224544字节离线通过,未重复正式安装。下一先完成本地发行证据提交再X。
+57
View File
@@ -0,0 +1,57 @@
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';
// New bounded real sample Y on formal 1.25.2. Same fixed expense-report task,
// same apikey GPT Chat streaming connection, same 16K/2048/8-request/90000-token caps.
// Never reads, copies, decrypts or re-stores the real key; uses the formal
// Provider's in-memory connection only. Never replays a sealed sample.
export const root = path.resolve('.qa/live-delivery-y');
export const origin = 'http://127.0.0.1:4318';
export const connectionId = '93d0cf6d-4f32-4918-9da8-6f125aa8a6e5';
export const sha = value => createHash('sha256').update(value).digest('hex');
export const readRoot = () => JSON.parse(fs.readFileSync(path.join(root, 'current.json')));
export const dataRoot = () => readRoot().host.identity.dataRoot;
export const save = (relative, value) => {
const file = path.join(root, relative); fs.mkdirSync(path.dirname(file), { recursive: true });
fs.writeFileSync(file, typeof value === 'string' || Buffer.isBuffer(value) ? value : JSON.stringify(value, null, 2) + '\n', { flag: 'wx' });
};
export function meta(name) {
assert.ok(['config', 'modelRegistry', 'modelAttempts', 'modelNetworkDiagnostics'].includes(name));
const db = new DatabaseSync(path.join(dataRoot(), 'workbench.sqlite'), { readOnly: true });
try { const row = db.prepare('SELECT value FROM metadata WHERE key=?').get(name); return row ? JSON.parse(row.value) : null; }
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;
}
+37
View File
@@ -0,0 +1,37 @@
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 './state.mjs';
import { root, origin, connectionId, sha } from './common.mjs';
// Read-only freeze of the formal 1.25.2 state before sample Y. 0 model requests.
assert.equal(fs.existsSync(root), false, 'Sample Y is frozen once; never overwrite.');
assert.equal(execFileSync('git', ['status', '--porcelain'], { encoding: 'utf8', windowsHide: true }).trim(), '', 'Freeze from a committed tree.');
const 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 === connectionId);
assert.equal(boot.version, '1.25.2'); assert.equal(host.identity.pid, 36552); assert.equal(host.activity.active, false);
assert.equal(host.desktopWindows.count, 0);
assert.equal(connection.enabled, true); assert.equal(connection.hasKey, true); assert.equal(connection.credentialRevision, 1);
assert.equal(connection.model, 'gpt-6.1-sol'); assert.equal(connection.protocol, 'chat-completions'); assert.equal(connection.streaming, true);
assert.equal(connection.contextLimit, 16000); assert.equal(connection.maxOutputTokens, 2048);
assert.equal(connection.modelIdentityPolicy ?? 'record', 'record');
assert.equal(connection.baseUrl, 'https://api.apikey.fan/v1');
assert.equal(connection.modelIdentityAliasSource, 'https://api.apikey.fan');
assert.equal(center.connections.find(c => c.id === '5b4daed9-b2f7-4de0-b949-573eba70c7b3').enabled, false);
assert.equal(center.connections.find(c => c.id === '09b0293b-faad-45c3-832d-7c8b615813aa').enabled, false);
assert.deepEqual(center.selected, { type: 'pool', id: '68e30376-b799-445b-a858-db2dba9920a0' });
const baseline = await publicSnapshot(origin, host.identity.dataRoot); assert.deepEqual(baseline.active, []);
const candidate = JSON.parse(fs.readFileSync('releases/latest.json', 'utf8'));
const runtimeManifest = fs.readFileSync(path.join(boot.runtimeRoot, 'MANIFEST.json'));
assert.equal(JSON.parse(runtimeManifest).version, '1.25.2');
assert.equal(sha(runtimeManifest), sha(fs.readFileSync(path.join(candidate.portableRoot, 'MANIFEST.json'))), 'Freeze the actual accepted installed candidate.');
const sourceCommit = candidate.documentation.sourceCommit;
assert.match(sourceCommit, /^[a-f0-9]{40}$/);
const reviewedHead = execFileSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf8', windowsHide: true }).trim();
fs.mkdirSync(root, { recursive: true });
fs.writeFileSync(path.join(root, 'current.json'), JSON.stringify({ host, config: boot.config, projects: boot.projects, center, baseline,
connectionRevision: connection.revision, sourceCommit, reviewedHead, runtimeManifestSha256: sha(runtimeManifest),
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, connectionRevision: connection.revision, modelRequests: 0 }));
+58
View File
@@ -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 './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();
}
}
+63
View File
@@ -0,0 +1,63 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { setTimeout as delay } from 'node:timers/promises';
import { publicSnapshot, canonical } from './state.mjs';
import { root, origin, dataRoot, connectionId, save, meta, client, readRoot } from './common.mjs';
// One bounded DNS/TCP/TLS observation of the same connection. Recorded, but per
// the new design a diagnostic result does not block the preflight. 0 HTTP/model.
assert.equal(fs.existsSync(path.join(root, 'network')), false, 'One diagnostic only; never overwrite or replay.');
const original = readRoot();
const { api, boot, close } = await client();
let jobId;
try {
const host = await api('/host/status');
assert.equal(host.identity.pid, 36552); assert.equal(boot.version, '1.25.2'); assert.equal(host.activity.active, false);
const before = await publicSnapshot(origin, dataRoot()); save('network/before.json', before);
assert.deepEqual(canonical(before.database.tables), canonical(original.baseline.database.tables));
assert.deepEqual(before.exports, original.baseline.exports); assert.deepEqual(before.persistent, original.baseline.persistent);
const history = await api('/model-center/network-diagnostics'); save('network/history-before.json', history);
const connection = before.modelCenter.connections.find(row => row.id === connectionId);
assert.equal(connection.revision, original.connectionRevision); assert.equal(connection.credentialRevision, 1);
save('network/contract.json', { connectionId, revision: connection.revision, target: connection.baseUrl,
maxJobs: 1, recordedNonBlocking: true, credentialAccess: false, httpRequests: 0, modelRequests: 0,
directEndpointOnly: true, modelApiRouteVerified: false, defaultOrTransportChanges: false });
const started = await api('/model-center/network-diagnostics', { id: connectionId, revision: connection.revision });
save('network/start.json', started); jobId = started.job.id;
const deadline = Date.now() + 20000;
let current;
do {
current = await api('/model-center/network-diagnostics');
if (!current.active) break;
assert.ok(Date.now() < deadline, 'Diagnostic exceeded its bounded deadline.'); await delay(200);
} while (true);
const job = current.jobs.find(row => row.id === jobId);
assert.ok(job.finishedAt);
assert.equal(job.connectionId, connectionId); assert.equal(job.connectionRevision, original.connectionRevision);
assert.equal(job.httpRequests, 0); assert.equal(job.modelRequests, 0); assert.equal(job.credentialAccess, false);
assert.equal(job.route.kind, 'direct-endpoint-only'); assert.equal(job.route.modelApiRouteVerified, false);
save('network/history-after.json', current); save('network/job.json', job);
const after = await publicSnapshot(origin, dataRoot()); save('network/after.json', after);
for (const field of ['pid', 'version', 'hasKey', 'configSha256', 'projectsSha256', 'sessionsSha256', 'eventCursor', 'modelCenterSha256']) assert.deepEqual(after[field], before[field], field);
assert.deepEqual(after.exports, before.exports); assert.deepEqual(after.persistent.artifacts, before.persistent.artifacts);
assert.deepEqual(after.persistent.files, before.persistent.files);
for (const table of Object.keys(before.database.tables)) {
assert.equal(after.database.tables[table].schemaSha256, before.database.tables[table].schemaSha256);
const nextRows = after.database.tables[table].rows.filter(row => table !== 'metadata' || row.id !== 'modelNetworkDiagnostics');
const previousRows = before.database.tables[table].rows.filter(row => table !== 'metadata' || row.id !== 'modelNetworkDiagnostics');
assert.deepEqual(nextRows, previousRows, table + ': only diagnostic history may change');
}
const result = { passed: true, recordedNonBlocking: true, jobId, diagnosticStatus: job.status, elapsedMs: job.elapsedMs,
dns: job.stages?.dns, trials: (job.trials ?? []).map(row => ({ mode: row.mode, family: row.family, status: row.status, code: row.code })),
route: job.route, originalStateExactExceptNewDiagnosticHistory: true, credentialAccess: false, httpRequests: 0, modelRequests: 0 };
save('network/restoration.json', result); console.log(JSON.stringify(result));
} catch (error) {
save('network/driver-error.json', { name: error.name, message: error.message, stack: error.stack, jobId, automaticReplay: false });
throw error;
} finally {
if (jobId) {
const state = await api('/model-center/network-diagnostics');
if (state.active && ['pending', 'running'].includes(state.jobs.find(row => row.id === jobId)?.status)) save('network/stop.json', await api('/model-center/network-diagnostics/' + jobId + '/stop', {}));
}
await close();
}
+239
View File
@@ -0,0 +1,239 @@
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 './state.mjs';
import { root, origin, dataRoot, connectionId, save, meta, client, sha, captureAttempts, readRoot } from './common.mjs';
// Bounded real Node engineering with supervisor-in-the-loop review. Model
// implements the three allowed modules autonomously; supervisor only approves
// the original checks, reviews/applies the allowed change set and confirms Git.
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 original = readRoot();
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.25.2');
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, original.connectionRevision);
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: 'https://api.apikey.fan' });
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三个模块。金额用精确分单位处理,接受测试约定的十进制字符串、有限数字、退款、及空白;拒绝格式错误、超精度和不安全金额。按独立币种规范化、排序汇总并保留原数组,计数准确、安全求和,报表两位小数含负分金额。以原九项测试为完整奥约。'
+ '先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 }));
+86
View File
@@ -0,0 +1,86 @@
// One-shot QA adapter. Runs inside the existing formal host via the inspector;
// never reads a credential value. Mirrors the sealed R preflight payload.
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.__gptYProbeOnce ??= new Set();
ensure(!globalThis.__gptYProbeOnce.has(input.sessionId), 'This sample cannot be replayed.');
globalThis.__gptYProbeOnce.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: 'Y · 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 };
}
+70
View File
@@ -0,0 +1,70 @@
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 './state.mjs';
import { invokeGptProbe, inspectorClosed } from './inspector.mjs';
import { root, origin, dataRoot, connectionId, save, meta, client, captureAttempts, readRoot } from './common.mjs';
// Single no-tool GPT identity preflight. One request max, strict identity, stop on failure.
assert.equal(fs.existsSync(path.join(root, 'preflight')), false, 'Never replay or overwrite a real sample.');
const original = readRoot();
const { api, boot, close } = await client();
let fatal;
try {
await inspectorClosed();
assert.equal(boot.version, '1.25.2');
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, original.connectionRevision);
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'), '# Y 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: 'Y · apikey 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);
+20
View File
@@ -0,0 +1,20 @@
import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import {createHash} from 'node:crypto';
const root=path.resolve('.qa/live-delivery-y'),manifestFile=path.join(root,'MANIFEST.json');
assert.equal(fs.existsSync(manifestFile),false,'Never overwrite sealed experiment evidence.');
const files=[];
const walk=relative=>{for(const entry of fs.readdirSync(path.join(root,relative),{withFileTypes:true})){
const name=path.posix.join(relative,entry.name),file=path.join(root,name),stat=fs.lstatSync(file);
assert.equal(stat.isSymbolicLink(),false);assert.equal(stat.nlink,1);
if(entry.isDirectory()){walk(name);continue;}
assert.equal(entry.isFile(),true);const bytes=fs.readFileSync(file);
files.push({path:name,bytes:bytes.length,sha256:createHash('sha256').update(bytes).digest('hex')});
}};
walk('');files.sort((a,b)=>a.path.localeCompare(b.path));
const manifest={schemaVersion:1,sample:'Y',files,filesCount:files.length,totalBytes:files.reduce((sum,row)=>sum+row.bytes,0),
note:'Lengths and hashes of original files, excluding this manifest. Completeness is not a delivery-success claim.'};
fs.writeFileSync(manifestFile,JSON.stringify(manifest,null,2)+'\n',{flag:'wx'});
for(const row of files){const bytes=fs.readFileSync(path.join(root,row.path));assert.equal(bytes.length,row.bytes);assert.equal(createHash('sha256').update(bytes).digest('hex'),row.sha256);}
console.log(JSON.stringify({success:true,files:files.length,bytes:manifest.totalBytes,manifestFile,realModelRequests:0}));
+3
View File
@@ -0,0 +1,3 @@
// Reuse the committed, reviewed retained-host-state helpers so the Y sample
// hashes and compares original state exactly as the formal release driver does.
export { hash, canonical, digest, databaseSnapshot, publicSnapshot, compareOriginalState } from '../retained-host-state.mjs';
+1 -1
View File
@@ -8,7 +8,7 @@
2. [complete] inventory恢复每文件treeFile检查,扫描后新增硬链接被拒,原身份/字节一致;12/12安装通过,关联11项通过与升级3/3复验。10971文件只读ABBA全校验旧8.15–8.45s、新9.96–11.08s,未恢复逐文件祖先遍历。
3. [complete] 混合进展按同轮实际新增区间结算,独立无变化保护保持;新v3读取批次释放小来源剩余预算给文件/日志、变更操作原序不动。联合43/43、补强2/2及吞吐最终38/38与构建通过,首失败保留。
4. [complete] 1.25.2/source d510不可变独立重建22/22、便携/隔离安装12组+75UI、正式保留PID36552升级及网页/原生后全部原状态exact。完整898/899+原断言1/1,原超时保留;1339份证据离线通过,阶段回顾及限定本地提交。
5. [pending] 新冻结单次诊断/身份预检/有界Node;通过后才React/Python及Purge AB/BA,分别报告失败、成本和因果边界,不循环重试求通过。
5. [in_progress] X预冻结因原jojocode外部停用而拒绝(0请求);用户明确改用已启用apikey、另冻Y。先按Y计划单次诊断/身份预检/有界Node,通过后才React/Python及Purge AB/BA;不改提示/预算筛成功。
细节和阶段回顾见docs/RELIABILITY-1.25.2.md。开始时session-catchup无待同步输出;计划文件首次补丁因findings标题上下文不符被拒且无文件变化,已按原标题修正。以下按历史时点理解。