@danceiny/gotry 0.0.1-rc.9 → 0.2.0-rc.28

package/dist/scripts/persona-surface-guard-tests.js

@@ -0,0 +1,49 @@
+/**
+ * persona 表层护栏测试(issue #192/#2/#194 回归锚;2026-09-11 契约瘦身改锚,
+ * 全离线,只读仓根 patch):
+ *  1. (10) 域边界含表层规则句——gotry 能力一律是工具调用,绝不把 gotry_* 传给
+ *     skill 加载器(dsh skill 面名合法域 ^[a-z0-9]+(-[a-z0-9]+)*$,下划线必抛
+ *     invalid skill name,rc18 真实用户踩坑);
+ *  2. 行为契约 13 条编号完整(2026-09-11 瘦身 23→13,防后续编辑吞条目;窄域
+ *     细则归位工具描述/路由卡,persona 只留跨场景行为契约);
+ *  3. skill 失败后的行为指引存在(改回 tool call,不换名重试 skill);
+ *  4. (4) 候选时段示例枚举绑定锚点卡——澄清卡/访谈/选项不列已过节日
+ *     (#2 rc18 真实复发:卡把已过的春节/清明/五一当「想用的时候」示例);
+ *  5. (13) 后台协作——子任务等待纪律(#194 rc19 实踩:子代理回执 id 不是
+ *     job id,job_output 轮询子代理 = unknown job 硬错误)+ 永不宣称「工具
+ *     预算已耗尽」(ADR-24 v2:唯一边界是运行时时间闸);
+ *  6. 动态变量注入面完整——current_date/time_anchor_card/motivation_brief/
+ *     channel_routing_card 四个引用缺一不可(瘦身不得吞注入面)。
+ *
+ * 运行: cd ts && npx tsx scripts/persona-surface-guard-tests.ts
+ */
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const patch = readFileSync(join(process.cwd(), '..', 'cordis.gotry-patch.yml'), 'utf-8');
+// 1. 表层规则句存在且仅一次
+const guard = '表层规则:gotry 的全部能力一律是【工具调用】';
+assert.equal((patch.match(new RegExp(guard, 'g')) ?? []).length, 1, '表层规则句应恰好出现一次');
+assert.ok(patch.includes('绝不把 gotry_* 名字传给 skill 加载器'), '应显式禁止 gotry_* 进 skill 加载器');
+// 2. 行为契约 13 条编号完整(2026-09-11 瘦身 23→13)
+const markers = new Set([...patch.matchAll(/\((\d{1,2})\)/g)].map((m) => Number(m[1])));
+for (let i = 1; i <= 13; i += 1) {
+    assert.ok(markers.has(i), `行为契约 (${i}) 应存在`);
+}
+assert.equal(markers.size, 13, `契约条目应恰为 13 条,实际 ${markers.size}`);
+// 3. skill 用错面后的行为指引
+assert.ok(patch.includes('改回 tool call'), '应指引失败后改回 tool call');
+// 4. #2 复发回归锚:澄清卡示例枚举同样过锚点卡(契约 (4) 内部澄清)
+assert.ok(patch.includes('候选时段示例'), '#2 回归:候选时段示例条款应存在');
+assert.ok(patch.includes('已过的节日不进示例枚举'), '应禁止已过节日进澄清卡示例枚举');
+// 5. #194 回归锚:子任务等待纪律((13) 后台协作)
+assert.ok(patch.includes('(13)后台协作'), '#194 回归:后台协作条款应存在');
+assert.ok(patch.includes('对子代理绝不调用 job_output/job_kill'), '应禁止对子代理调用 job_output/job_kill');
+assert.ok(patch.includes('job_output/job_kill 只用于'), '应限定 job_output/job_kill 的适用面');
+// ADR-24 v2:工具循环唯一边界是运行时时间闸
+assert.ok(patch.includes('工具预算已耗尽'), 'ADR-24 v2:永不宣称工具预算耗尽的指引应存在');
+// 6. 动态变量注入面完整(瘦身不得吞注入面)
+for (const v of ['{{current_date}}', '{{time_anchor_card}}', '{{motivation_brief}}', '{{channel_routing_card}}']) {
+    assert.ok(patch.includes(v), `persona 应保留动态变量引用 ${v}`);
+}
+console.log('PERSONA SURFACE GUARD TESTS: 6/6 OK(表层规则句 / 13 条契约完整 / skill 失败行为指引 / 澄清卡示例过锚点卡 / 子任务等待纪律+预算话术 / 动态变量注入面)');

package/dist/scripts/pnpm-dsh-closure-proof.js

@@ -0,0 +1,17 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { REQUIRED_BENCHMARK_DSH_VERSION } from '../../bin/gotry-runtime-resolution.js';
+import { parsePnpmDshLock, REQUIRED_DSH_RUNTIME_PACKAGE_COUNT, validateDshRuntimeClosure, } from './dsh-runtime-closure.js';
+const consumerRoot = process.argv[2];
+assert.ok(consumerRoot, 'usage: pnpm-dsh-closure-proof.ts <clean-consumer-root>');
+const installedPackage = JSON.parse(readFileSync(resolve(consumerRoot, 'node_modules/@danceiny/gotry/package.json'), 'utf8'));
+const lockPackages = parsePnpmDshLock(readFileSync(resolve(consumerRoot, 'pnpm-lock.yaml'), 'utf8'));
+const closure = validateDshRuntimeClosure({
+    dependencies: installedPackage.dependencies ?? {},
+    lockPackages,
+    runtimeVersion: REQUIRED_BENCHMARK_DSH_VERSION,
+    expectedPackageCount: REQUIRED_DSH_RUNTIME_PACKAGE_COUNT,
+});
+assert.equal(closure.names.length, REQUIRED_DSH_RUNTIME_PACKAGE_COUNT, 'clean pnpm consumer must resolve the complete Round 5 DSH closure');
+console.log(`PNPM DSH CLOSURE PROOF: ${closure.names.length} packages at ${closure.version}`);

package/dist/scripts/policy-anchor-359-registered-e2e.js

@@ -0,0 +1,214 @@
+/**
+ * Issue #359 — 政策锚点全字段内容指纹(注册 `gotry_fact_gate` 路径 E2E)。
+ *
+ * 真实执行面:在临时 stateRoot 下装载 gotry-tools 插件,通过 `apply(ctx, config)`
+ * 装载注册定义,捕获 `gotry_fact_gate` 的 execute 函数,以 markdown 直接调用——
+ * 经注册的 tool definition 走完 `loadFactRegistry(stateRoot)` → `gateArtifact`
+ * → `itinerary.trip_start` 桥接(issue #359 finding 2),完整覆盖公开闸侧路径。
+ * 不启动 dsh 宿主、不调用真实 ToolRuntime、不触碰供应商 / browser / policy
+ * service / 共享状态。
+ *
+ * 运行(在 ts/ 下):
+ *   PATH=/opt/homebrew/opt/node@24/bin:$PATH GOTRY_SESSION_LIVE=0 \
+ *     npx tsx scripts/policy-anchor-359-registered-e2e.ts
+ */
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { apply } from '../src/index.js';
+import { BOOKABLE_FACT_SCHEMA, makeFactId, renderPolicyFact, } from '../src/bookable-facts.js';
+import { appendFacts } from '../capabilities/fact-log.js';
+const FETCHED = '2026-09-10T00:00:00.000Z';
+async function main() {
+    const home = mkdtempSync(join(tmpdir(), 'gotry-policy-359-registered-'));
+    const stateRoot = join(home, 'state');
+    const cwd = join(home, 'workspace');
+    mkdirSync(stateRoot, { recursive: true });
+    mkdirSync(cwd, { recursive: true });
+    const policy = {
+        schema: BOOKABLE_FACT_SCHEMA,
+        fact_id: makeFactId(['policy-359', 'reg', '泰国免签']),
+        kind: 'policy',
+        subject: '泰国入境(中国护照)',
+        statement: '免签停留(口径以泰方公告为准);UAE 居民返程应优先校验 residence visa / Emirates ID 而非游客免签口径',
+        source: 'web:official',
+        query_id: 'web:policy:泰国免签',
+        fetched_at: FETCHED,
+        as_of: '2026-08-29',
+    };
+    // 走真实事实日志路径(append-only JSONL),与产品 gotry_flyai_search /
+    // gotry_session_search 同款事实落账接口;闸侧 loadFactRegistry 直接读这里。
+    await appendFacts(stateRoot, [policy]);
+    // 装载 gotry-tools 插件 → 捕获 gotry_fact_gate 的真实 execute。
+    const registered = [];
+    const ctx = {
+        tools: { register: (t) => registered.push(t) },
+        systemPrompt: { section: () => undefined, variable: () => undefined },
+        on: () => () => undefined,
+    };
+    apply(ctx, {
+        stateRoot,
+        timeoutMs: 30_000,
+        hbcliBin: 'hbcli-not-on-path',
+        sessionAccess: 'off',
+    });
+    const factGate = registered.find(t => t.name === 'gotry_fact_gate');
+    if (!factGate)
+        throw new Error(`FAIL: 注册定义列表缺少 gotry_fact_gate,实际注册: ${registered.map(t => t.name).join(',')}`);
+    const exec = { agent: { session: { header: { cwd } } } };
+    // Case 1:canonical no-reminder 行经真实 gotry_fact_gate → pass。
+    const canonicalLine = renderPolicyFact(policy);
+    const c1Artifact = ['## 政策', canonicalLine].join('\n');
+    const r1 = await factGate.execute({ markdown: c1Artifact }, exec);
+    assert.equal(r1.verdict, 'pass', `canonical no-reminder 经注册闸应 pass,实际: ${JSON.stringify({ verdict: r1.verdict, summary: r1.summary })}`);
+    assert.equal(r1.traceable, 1);
+    console.log(`  ok - 注册 gotry_fact_gate canonical no-reminder → pass`);
+    // Case 2:legitimate review_by(事实自带)— 无 trip_start,canonical body 已含复核提醒。
+    const reviewByPolicy = { ...policy, fact_id: makeFactId(['policy-359', 'reg', 'review-by']), review_by: '2027-06-16' };
+    await appendFacts(stateRoot, [reviewByPolicy]);
+    const reviewByLine = renderPolicyFact(reviewByPolicy);
+    const r2 = await factGate.execute({ markdown: ['## 政策', reviewByLine].join('\n') }, exec);
+    assert.equal(r2.verdict, 'pass', `legitimate review_by 经注册闸应 pass,实际: ${JSON.stringify({ verdict: r2.verdict, summary: r2.summary })}`);
+    console.log(`  ok - 注册 gotry_fact_gate legitimate review_by → pass`);
+    // Case 3:legitimate tripStart-derived reminder — 通过已加载 itinerary.trip_start 桥接
+    // (不要求调用方额外传 opts.tripStart;闸侧自动从 itinerary 派)。
+    // itinerary 必须保持自身不变量合法(nights/legs),否则闸会被 itineraryInvariants
+    // 单独阻断,影响 policy 收口的可读性。这里给一个合法的同日往返零夜行程。
+    const tripStart = '2027-07-16';
+    const tripStartLine = renderPolicyFact(policy, tripStart);
+    const r3 = await factGate.execute({
+        markdown: ['## 政策', tripStartLine].join('\n'),
+        itinerary: {
+            trip_start: tripStart,
+            trip_end: tripStart,
+            stays: [],
+            onboard_nights: 0,
+            od_segments: [],
+            budget_items: [],
+        },
+    }, exec);
+    assert.equal(r3.verdict, 'pass', `legitimate tripStart-derived reminder 经注册闸应 pass,实际: ${JSON.stringify({ verdict: r3.verdict, summary: r3.summary })}`);
+    console.log(`  ok - 注册 gotry_fact_gate legitimate tripStart reminder(经 itinerary.trip_start 桥接)→ pass`);
+    // Case 4:trailing-after-anchor 攻击:合法 fact_id + 锚点后追加相反政策正文 → blocked。
+    const trailingLine = `${canonicalLine} 反而是落地签,需提前办签证`;
+    const r4 = await factGate.execute({ markdown: ['## 政策', trailingLine].join('\n') }, exec);
+    assert.equal(r4.verdict, 'blocked', `trailing-after-anchor 经注册闸应 blocked,实际: ${JSON.stringify({ verdict: r4.verdict, summary: r4.summary })}`);
+    assert.ok(r4.violations?.some(v => v.kind === 'fact_anchor_unknown'), `trailing-after-anchor 应有 fact_anchor_unknown 违例,实际: ${JSON.stringify(r4.violations?.map(v => v.kind))}`);
+    console.log(`  ok - 注册 gotry_fact_gate trailing-after-anchor 攻击 → blocked/fact_anchor_unknown`);
+    // Case 5:subject 篡改(原 main 静默 pass 的反例)。
+    const tamperedSubject = canonicalLine.replace('泰国入境(中国护照)', '另一对象的政策');
+    const r5 = await factGate.execute({ markdown: ['## 政策', tamperedSubject].join('\n') }, exec);
+    assert.equal(r5.verdict, 'blocked', `subject 篡改经注册闸应 blocked,实际: ${JSON.stringify({ verdict: r5.verdict, summary: r5.summary })}`);
+    assert.ok(r5.violations?.some(v => v.kind === 'fact_anchor_unknown'), `subject 篡改应有 fact_anchor_unknown 违例,实际: ${JSON.stringify(r5.violations?.map(v => v.kind))}`);
+    console.log(`  ok - 注册 gotry_fact_gate subject 篡改 → blocked/fact_anchor_unknown`);
+    // Case 6:opposite statement 篡改 — 现实威胁:沿用合法 fact_id + 锚点改写 statement 方向。
+    const oppositeStatement = canonicalLine.replace('免签停留', '不免签,需提前办签证');
+    const r6 = await factGate.execute({ markdown: ['## 政策', oppositeStatement].join('\n') }, exec);
+    assert.equal(r6.verdict, 'blocked', `opposite statement 篡改经注册闸应 blocked,实际: ${JSON.stringify({ verdict: r6.verdict, summary: r6.summary })}`);
+    assert.ok(r6.violations?.some(v => v.kind === 'fact_anchor_unknown'), `opposite statement 应有 fact_anchor_unknown 违例,实际: ${JSON.stringify(r6.violations?.map(v => v.kind))}`);
+    console.log(`  ok - 注册 gotry_fact_gate opposite statement 篡改 → blocked/fact_anchor_unknown`);
+    // Case 7:provenance 篡改(source / fetched_at / query_id 任一)→ blocked。
+    const tamperedProv = canonicalLine
+        .replace('[web:official@', '[synthetic:official@')
+        .replace(FETCHED, '2026-09-01T00:00:00.000Z')
+        .replace('#web:policy:泰国免签', '#synthetic:policy:泰国免签');
+    const r7 = await factGate.execute({ markdown: ['## 政策', tamperedProv].join('\n') }, exec);
+    assert.equal(r7.verdict, 'blocked', `provenance 篡改经注册闸应 blocked,实际: ${JSON.stringify({ verdict: r7.verdict, summary: r7.summary })}`);
+    assert.ok(r7.violations?.some(v => v.kind === 'fact_anchor_unknown'), `provenance 篡改应有 fact_anchor_unknown 违例,实际: ${JSON.stringify(r7.violations?.map(v => v.kind))}`);
+    console.log(`  ok - 注册 gotry_fact_gate provenance(source/fetched_at/query_id)篡改 → blocked/fact_anchor_unknown`);
+    // Compatibility(issue #359 final repair):注册闸侧既不传 itinerary、调用方也不显式
+    // opts.tripStart 时,renderer 给的两类合法 canonical form 必须经真实 gotry_fact_gate
+    // pass;否则(伪 reminder 日期、body 篡改、review_by 改写、trailing-after-anchor)
+    // 必须仍走 fact_anchor_unknown。证明兼容性回退收敛于 renderer 自身的输出空间,
+    // 不引入新公共 API,也不放行任意政策文本。
+    const compatExec = exec;
+    // Case 8:context-free canonical no-reminder 经注册闸 → pass
+    //   (renderer 不接 tripStart,policy 也无 review_by → 不应出现 reminder 段)
+    const r8 = await factGate.execute({ markdown: ['## 政策', canonicalLine].join('\n') }, compatExec);
+    assert.equal(r8.verdict, 'pass', `context-free no-reminder 经注册闸应 pass,实际: ${JSON.stringify({ verdict: r8.verdict, summary: r8.summary })}`);
+    assert.equal(r8.traceable, 1);
+    console.log(`  ok - 注册 gotry_fact_gate context-free canonical no-reminder → pass`);
+    // Case 9:context-free canonical reminder(renderer 默认 defaultReviewBy(as_of))→ pass
+    //   这是 issue #273 已有的历史形态,最终修复必须恢复。
+    const compatTripStart = '2027-08-01';
+    const compatTripStartLine = renderPolicyFact(policy, compatTripStart);
+    const r9 = await factGate.execute({ markdown: ['## 政策', compatTripStartLine].join('\n') }, compatExec);
+    assert.equal(r9.verdict, 'pass', `context-free derived reminder(无 itinerary 桥接)经注册闸应 pass,实际: ${JSON.stringify({ verdict: r9.verdict, summary: r9.summary })}`);
+    assert.equal(r9.traceable, 1);
+    console.log(`  ok - 注册 gotry_fact_gate context-free canonical derived reminder(无 itinerary 桥接)→ pass`);
+    // Case 10:context-free canonical reminder(review_by 已知)→ pass
+    //   reviewByPolicy 已在 Case 2 装载;这里只重复调用同一锚定行,证明无 itinerary 仍合法
+    const r10 = await factGate.execute({ markdown: ['## 政策', reviewByLine].join('\n') }, compatExec);
+    assert.equal(r10.verdict, 'pass', `context-free canonical reminder(review_by 已知)经注册闸应 pass,实际: ${JSON.stringify({ verdict: r10.verdict, summary: r10.summary })}`);
+    assert.equal(r10.traceable, 1);
+    console.log(`  ok - 注册 gotry_fact_gate context-free canonical reminder(review_by 已知)→ pass`);
+    // Case 11:context-free reminder 错位(把 reminder 段追加到 provenance 之后,而不是
+    //   renderer 固定位置 `[provenance]` 之前)→ 重建 `renderPolicyFact({...f, review_by: '1999-01-01'})`
+    //   与原行不匹配 → fail-closed。日期 '1999-01-01' 本身合法 ISO 阳历日;此例证伪在于
+    //   reminder 位置错配,不在日期本身。
+    const compatBadDateLine = `${canonicalLine};远期政策须复核——到 1999-01-01 再核验一次 <!-- fact:${policy.fact_id} -->`;
+    const r11 = await factGate.execute({ markdown: ['## 政策', compatBadDateLine].join('\n') }, compatExec);
+    assert.equal(r11.verdict, 'blocked', `reminder 错位经注册闸应 blocked,实际: ${JSON.stringify({ verdict: r11.verdict, summary: r11.summary })}`);
+    assert.ok(r11.violations?.some(v => v.kind === 'fact_anchor_unknown'), `reminder 错位应有 fact_anchor_unknown 违例,实际: ${JSON.stringify(r11.violations?.map(v => v.kind))}`);
+    console.log(`  ok - 注册 gotry_fact_gate context-free reminder 错位 → blocked/fact_anchor_unknown`);
+    // Case 12:context-free body 篡改(免签停留 → 不免签停留,保留 fact_id 锚点)→ blocked
+    const compatBadBodyLine = canonicalLine.replace('免签停留', '不免签停留');
+    const r12 = await factGate.execute({ markdown: ['## 政策', compatBadBodyLine].join('\n') }, compatExec);
+    assert.equal(r12.verdict, 'blocked', `body 篡改经注册闸应 blocked,实际: ${JSON.stringify({ verdict: r12.verdict, summary: r12.summary })}`);
+    assert.ok(r12.violations?.some(v => v.kind === 'fact_anchor_unknown'), `body 篡改应有 fact_anchor_unknown 违例,实际: ${JSON.stringify(r12.violations?.map(v => v.kind))}`);
+    console.log(`  ok - 注册 gotry_fact_gate context-free body 篡改 → blocked/fact_anchor_unknown`);
+    // Case 13:context-free review_by 篡改(事实带 review_by,改 reminder 日期)→ blocked
+    //   根 contract 第 2 条:若事实自带 review_by,renderer 优先级 review_by > tripStart,
+    //   reminder 日期必须 == f.review_by;改了就是伪造。这里注册的是带 review_by 的事实。
+    const fReviewBy = { ...policy, fact_id: makeFactId(['policy-359', 'reg', 'review-by-tamper']), review_by: '2027-06-16' };
+    await appendFacts(stateRoot, [fReviewBy]);
+    const compatReviewByTamperedLine = renderPolicyFact(fReviewBy).replace('2027-06-16', '2027-12-31');
+    const r13 = await factGate.execute({ markdown: ['## 政策', compatReviewByTamperedLine].join('\n') }, compatExec);
+    assert.equal(r13.verdict, 'blocked', `事实带 review_by 时改 reminder 日期经注册闸应 blocked,实际: ${JSON.stringify({ verdict: r13.verdict, summary: r13.summary })}`);
+    assert.ok(r13.violations?.some(v => v.kind === 'fact_anchor_unknown'), `事实带 review_by 时改 reminder 日期应有 fact_anchor_unknown 违例,实际: ${JSON.stringify(r13.violations?.map(v => v.kind))}`);
+    console.log(`  ok - 注册 gotry_fact_gate 事实带 review_by 改 reminder 日期 → blocked/fact_anchor_unknown`);
+    // Case 14:context-free trailing-after-anchor(锚点后追加非空)→ blocked
+    const compatTrailingLine = `${canonicalLine} 反而是落地签`;
+    const r14 = await factGate.execute({ markdown: ['## 政策', compatTrailingLine].join('\n') }, compatExec);
+    assert.equal(r14.verdict, 'blocked', `trailing-after-anchor 经注册闸应 blocked,实际: ${JSON.stringify({ verdict: r14.verdict, summary: r14.summary })}`);
+    assert.ok(r14.violations?.some(v => v.kind === 'fact_anchor_unknown'), `trailing-after-anchor 应有 fact_anchor_unknown 违例,实际: ${JSON.stringify(r14.violations?.map(v => v.kind))}`);
+    console.log(`  ok - 注册 gotry_fact_gate context-free trailing-after-anchor → blocked/fact_anchor_unknown`);
+    // Case 15:itinerary.trip_start 与 renderer reminder 不一致 → blocked
+    //   闸侧走 itinerary 派发后不再回退兼容,renderer 给的是 2027-08-01 而 itinerary
+    //   给的是 2027-08-15 → 必 fail-closed。
+    const r15 = await factGate.execute({
+        markdown: ['## 政策', compatTripStartLine].join('\n'),
+        itinerary: {
+            trip_start: '2027-08-15',
+            trip_end: '2027-08-15',
+            stays: [],
+            onboard_nights: 0,
+            od_segments: [],
+            budget_items: [],
+        },
+    }, compatExec);
+    assert.equal(r15.verdict, 'blocked', `itinerary 与 reminder 不一致经注册闸应 blocked,实际: ${JSON.stringify({ verdict: r15.verdict, summary: r15.summary })}`);
+    assert.ok(r15.violations?.some(v => v.kind === 'fact_anchor_unknown'), `itinerary 与 reminder 不一致应有 fact_anchor_unknown 违例,实际: ${JSON.stringify(r15.violations?.map(v => v.kind))}`);
+    console.log(`  ok - 注册 gotry_fact_gate itinerary 与 reminder 不一致 → blocked/fact_anchor_unknown`);
+    // Case 16:itinerary.trip_start 存在时 canonical no-reminder 仍合法 → pass
+    //   renderer 没接 tripStart 时,policy 文本里没有 reminder 段,与 itinerary 共存
+    //   仍是合法的 canonical body。
+    const r16 = await factGate.execute({
+        markdown: ['## 政策', canonicalLine].join('\n'),
+        itinerary: {
+            trip_start: '2027-08-15',
+            trip_end: '2027-08-15',
+            stays: [],
+            onboard_nights: 0,
+            od_segments: [],
+            budget_items: [],
+        },
+    }, compatExec);
+    assert.equal(r16.verdict, 'pass', `itinerary 存在时 canonical no-reminder 经注册闸应 pass,实际: ${JSON.stringify({ verdict: r16.verdict, summary: r16.summary })}`);
+    assert.equal(r16.traceable, 1);
+    console.log(`  ok - 注册 gotry_fact_gate itinerary 存在时 canonical no-reminder → pass`);
+    rmSync(home, { recursive: true, force: true });
+    console.log('\nPOLICY ANCHOR #359 REGISTERED E2E: pass (deterministic synthetic, isolated stateRoot, registered gotry_fact_gate execute())');
+}
+await main();

package/dist/scripts/price-drift-tests.js

@@ -0,0 +1,340 @@
+/**
+ * 价格漂移监测合同测试(issue #49 长效机制,run-all §41)。
+ * 全确定性、零网络:
+ *   - diff 算法守门:baseline 改/新/删均被检出;
+ *   - offline 模式:无 baseline → skipped_no_baseline;有 baseline → unchanged(reason 提示 --fetch);
+ *   - fetch 模式:fetch 失败 → skipped_no_network;parse 失败 → skipped_parse_error;baseline 不存在 →
+ *     fetched_no_table_entry 且写 fixture;baseline 存在 + 完全相同 → unchanged;存在 + 不同 → drift;
+ *   - 写入 baseline fixture 的 schema_version 守门;
+ *   - PR 段落渲染:drift 含 model/field/from/to/direction 表格 + 纪律注脚。
+ *   - diff 细节:字段 up/down/new/removed 四个方向全检。
+ *
+ * 网络例一律走注入的 fetcher / providers 路径,不真联网(真联网在 founder 手动 / CI 心跳)。
+ */
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { runPriceDriftWatch, parseOpenaiHtml, } from './price-drift-watch.js';
+let passed = 0;
+function ok(label) {
+    passed += 1;
+    console.log(`  ok ${label}`);
+}
+function tmpRoot() {
+    return mkdtempSync(join(tmpdir(), 'drift-'));
+}
+function makeBaseline(rows, asOf = '2026-08-30T00:00:00.000Z') {
+    return JSON.stringify({ schema_version: 'gotry_llm_price_baseline_v1', as_of: asOf, source_url: 'mock://test', rows });
+}
+/** 测试用注入 provider:baseline_path 指向 tmp 文件,parser 接受 mock HTML 字符串。 */
+function makeMockProvider(id, baselinePath, _fetchReturn) {
+    const parser = (html) => {
+        const rows = [];
+        for (const seg of html.split(';')) {
+            const [model, nums] = seg.split(':');
+            if (!model || !nums)
+                continue;
+            const [miss, hit, out] = nums.split(',').map(Number);
+            if (!Number.isFinite(miss) || !Number.isFinite(out))
+                continue;
+            rows.push({ model: model.trim(), input_cache_miss_usd_per_1m: miss, input_cache_hit_usd_per_1m: Number.isFinite(hit) ? hit : null, output_usd_per_1m: out });
+        }
+        return rows;
+    };
+    return [{
+            id,
+            source_url: `mock://${id}`,
+            baseline_path: baselinePath,
+            parse: parser,
+        }];
+}
+function fetcherFromMap(map) {
+    return async (url) => {
+        const v = map[url];
+        if (v instanceof Error)
+            throw v;
+        if (typeof v === 'string')
+            return v;
+        throw new Error(`no mock for ${url}`);
+    };
+}
+// ---- 1. offline 无 baseline → skipped_no_baseline ----
+async function testOfflineNoBaseline() {
+    const root = tmpRoot();
+    try {
+        const report = await runPriceDriftWatch({
+            mode: 'offline',
+            observedAt: () => new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', join(root, 'no-such-file.json'), ''),
+        });
+        assert.equal(report.schema_version, 'gotry_llm_price_drift_v1');
+        assert.equal(report.providers['mockprov'].status, 'skipped_no_baseline');
+        ok('offline 无 baseline → skipped_no_baseline');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+// ---- 2. offline 有 baseline → unchanged(reason 提示 --fetch) ----
+async function testOfflineWithBaseline() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        writeFileSync(bp, makeBaseline([
+            { model: 'm1', input_cache_miss_usd_per_1m: 1.0, input_cache_hit_usd_per_1m: 0.1, output_usd_per_1m: 3.0 },
+        ]));
+        const report = await runPriceDriftWatch({
+            mode: 'offline',
+            observedAt: () => new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', bp, ''),
+        });
+        assert.equal(report.providers['mockprov'].status, 'unchanged');
+        assert.match(report.providers['mockprov'].reason ?? '', /--fetch/, 'offline reason 应提示 --fetch');
+        ok('offline 有 baseline → unchanged + reason 提示 --fetch');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+// ---- 3. fetch 模式:fet 失败 → skipped_no_network ----
+async function testFetchFailure() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        writeFileSync(bp, makeBaseline([
+            { model: 'm1', input_cache_miss_usd_per_1m: 1.0, input_cache_hit_usd_per_1m: 0.1, output_usd_per_1m: 3.0 },
+        ]));
+        const report = await runPriceDriftWatch({
+            mode: 'fetch',
+            observedAt: () => new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', bp, ''),
+            fetcher: fetcherFromMap({ 'mock://mockprov': new Error('ECONNREFUSED') }),
+        });
+        assert.equal(report.providers['mockprov'].status, 'skipped_no_network');
+        assert.match(report.providers['mockprov'].reason ?? '', /ECONNREFUSED/);
+        ok('fetch 失败 → skipped_no_network');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+// ---- 4. fetch 模式:首次 fetch 无 baseline → fetched_no_table_entry 且写 fixture ----
+async function testFetchFirstTimeWritesBaseline() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        const report = await runPriceDriftWatch({
+            mode: 'fetch',
+            observedAt: () => new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', bp, ''),
+            fetcher: fetcherFromMap({ 'mock://mockprov': 'm1:1.0,0.1,3.0;m2:2.0,0.2,5.0' }),
+        });
+        assert.equal(report.providers['mockprov'].status, 'fetched_no_table_entry');
+        // 必须有 fixture 文件
+        const { existsSync, readFileSync } = await import('node:fs');
+        assert.ok(existsSync(bp), 'baseline fixture 必须被写');
+        const written = JSON.parse(readFileSync(bp, 'utf8'));
+        assert.equal(written['schema_version'], 'gotry_llm_price_baseline_v1');
+        assert.ok(Array.isArray(written['rows']));
+        assert.equal(written['rows'].length, 2);
+        ok('fetch 首次 → fetched_no_table_entry + 写 fixture');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+// ---- 5. fetch 模式:baseline + current 完全相同 → unchanged ----
+async function testFetchUnchanged() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        writeFileSync(bp, makeBaseline([
+            { model: 'm1', input_cache_miss_usd_per_1m: 1.0, input_cache_hit_usd_per_1m: 0.1, output_usd_per_1m: 3.0 },
+        ]));
+        const report = await runPriceDriftWatch({
+            mode: 'fetch',
+            observedAt: () => new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', bp, ''),
+            fetcher: fetcherFromMap({ 'mock://mockprov': 'm1:1.0,0.1,3.0' }),
+        });
+        assert.equal(report.providers['mockprov'].status, 'unchanged');
+        ok('fetch 模式:baseline + current 同 → unchanged');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+// ---- 6. fetch 模式:baseline + current 不同 → drift + 字段方向 ----
+async function testFetchDrift() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        writeFileSync(bp, makeBaseline([
+            { model: 'm-keep', input_cache_miss_usd_per_1m: 1.0, input_cache_hit_usd_per_1m: 0.1, output_usd_per_1m: 3.0 },
+            { model: 'm-up', input_cache_miss_usd_per_1m: 1.0, input_cache_hit_usd_per_1m: 0.1, output_usd_per_1m: 3.0 },
+            { model: 'm-down', input_cache_miss_usd_per_1m: 1.0, input_cache_hit_usd_per_1m: 0.1, output_usd_per_1m: 3.0 },
+            { model: 'm-removed', input_cache_miss_usd_per_1m: 1.0, input_cache_hit_usd_per_1m: 0.1, output_usd_per_1m: 3.0 },
+        ]));
+        const report = await runPriceDriftWatch({
+            mode: 'fetch',
+            observedAt: () => new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', bp, ''),
+            fetcher: fetcherFromMap({
+                'mock://mockprov': [
+                    'm-keep:1.0,0.1,3.0',
+                    'm-up:1.5,0.1,3.0', // miss 1.0→1.5 up
+                    'm-down:0.8,0.1,3.0', // miss 1.0→0.8 down
+                    'm-new:2.0,0.2,4.0', // 全 new
+                    // m-removed 不在 current,标记 removed
+                ].join(';'),
+            }),
+        });
+        const r = report.providers['mockprov'];
+        assert.equal(r.status, 'drift');
+        const drift = r.drift ?? [];
+        // 期望:m-up input_cache_miss up, m-down input_cache_miss down, m-new input_cache_miss new, m-removed input_cache_miss removed
+        const fields = drift.map(d => `${d.model}|${d.field}|${d.direction}`).sort();
+        assert.deepEqual(fields, [
+            'm-down|input_cache_miss_usd_per_1m|down',
+            'm-new|input_cache_miss_usd_per_1m|new',
+            'm-removed|input_cache_miss_usd_per_1m|removed',
+            'm-up|input_cache_miss_usd_per_1m|up',
+        ], 'drift 字段方向必须逐项正确');
+        ok('fetch drift:up/down/new/removed 四向全检');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+// ---- 7. PR 段落渲染:drift 时含表格 + 纪律注脚 ----
+async function testPrParagraph() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        writeFileSync(bp, makeBaseline([
+            { model: 'deepseek-v4-flash', input_cache_miss_usd_per_1m: 1.32, input_cache_hit_usd_per_1m: 0.014, output_usd_per_1m: 3.0 },
+        ]));
+        const report = await runPriceDriftWatch({
+            mode: 'fetch',
+            observedAt: () => new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', bp, ''),
+            fetcher: fetcherFromMap({ 'mock://mockprov': 'deepseek-v4-flash:1.32,0.014,3.0' }),
+        });
+        assert.equal(report.providers['mockprov'].status, 'unchanged');
+        assert.match(report.suggested_pr_paragraph, /价格漂移监测/);
+        assert.match(report.suggested_pr_paragraph, /mockprov/);
+        assert.match(report.suggested_pr_paragraph, /人工 PR/);
+        ok('PR 段落含监测标题 + provider 变动 + 纪律注脚');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+// ---- 8. baseline schema_version 守门:不匹配 schema 视为不存在(loader 容错) ----
+async function testBadBaseline() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        writeFileSync(bp, JSON.stringify({ schema_version: 'gotry_llm_price_baseline_v99', rows: [] }));
+        // 离线模式:坏 baseline 视为不存在 → skipped_no_baseline
+        const report = await runPriceDriftWatch({
+            mode: 'offline',
+            observedAt: () => new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', bp, ''),
+        });
+        assert.equal(report.providers['mockprov'].status, 'skipped_no_baseline', '坏 baseline schema_version 视为不存在,offline 标 SKIP');
+        ok('坏 baseline schema_version → offline 视为不存在(SKIP)');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+await testOfflineNoBaseline();
+await testOfflineWithBaseline();
+await testFetchFailure();
+await testFetchFirstTimeWritesBaseline();
+await testFetchUnchanged();
+await testFetchDrift();
+await testPrParagraph();
+await testBadBaseline();
+// ---- 9. snapshot 路径:parser 解析 __NEXT_DATA__ 内嵌 JSON dump,fallback 解析段落文字 ----
+async function testSnapshotNextDataParser() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        const sp = join(root, 'snapshot.html');
+        writeFileSync(bp, makeBaseline([
+            { model: 'gpt-4o', input_cache_miss_usd_per_1m: 2.5, input_cache_hit_usd_per_1m: 1.25, output_usd_per_1m: 10.0 },
+        ]));
+        // 真实 snapshot 文件模拟 __NEXT_DATA__ 形态
+        const html = `<html><script id="__NEXT_DATA__" type="application/json">${JSON.stringify({
+            props: { pageProps: { models: [
+                        { name: 'gpt-4o', input_cost_per_token: 0.0000025, output_cost_per_token: 0.00001, cached_input_cost_per_token: 0.00000125 },
+                    ] } },
+        })}</script></html>`;
+        writeFileSync(sp, html);
+        const report = await runPriceDriftWatch({
+            mode: 'offline',
+            observedAt: () => new Date('2026-08-30T12:00:00Z'),
+            providers: [{ id: 'mockprov', source_url: 'mock://mockprov', baseline_path: bp, snapshot_path: sp, parse: parseOpenaiHtml }],
+        });
+        assert.equal(report.providers['mockprov'].status, 'unchanged', 'snapshot 与 baseline 同价 → unchanged(offline)');
+        ok('snapshot 路径:__NEXT_DATA__ 内嵌 JSON dump 解析成功 + 与 baseline 同 → unchanged');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+// ---- 10. snapshot 路径:parser fallback 段落文字;baseline 不一致 → drift ----
+async function testSnapshotFallbackDrift() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        const sp = join(root, 'snapshot.html');
+        writeFileSync(bp, makeBaseline([
+            { model: 'gpt-4o', input_cache_miss_usd_per_1m: 2.5, input_cache_hit_usd_per_1m: 1.25, output_usd_per_1m: 10.0 },
+        ]));
+        // __NEXT_DATA__ 解析失败(空 props),parser fallback 走段落文字
+        const html = '<html><body><p>gpt-4o … $5.00 / 1M input … $20.00 / 1M output</p></body></html>';
+        writeFileSync(sp, html);
+        const report = await runPriceDriftWatch({
+            mode: 'offline',
+            observedAt: () => new Date('2026-08-30T12:00:00Z'),
+            providers: [{ id: 'mockprov', source_url: 'mock://mockprov', baseline_path: bp, snapshot_path: sp, parse: parseOpenaiHtml }],
+        });
+        const r = report.providers['mockprov'];
+        assert.equal(r.status, 'drift', 'snapshot fallback 解析 + baseline 不一致 → drift');
+        const drift = r.drift ?? [];
+        assert.ok(drift.some(d => d.field === 'input_cache_miss_usd_per_1m' && d.from === 2.5 && d.to === 5.0 && d.direction === 'up'), 'miss 字段 up drift');
+        assert.ok(drift.some(d => d.field === 'output_usd_per_1m' && d.from === 10.0 && d.to === 20.0 && d.direction === 'up'), 'output 字段 up drift');
+        ok('snapshot fallback:段落文字解析 + 与 baseline 不同 → drift(含 up/down/new/removed)');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+// ---- 11. snapshot 缺失守门:有 baseline 但无 snapshot → skipped_no_snapshot ----
+async function testSnapshotMissing() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        writeFileSync(bp, makeBaseline([
+            { model: 'gpt-4o', input_cache_miss_usd_per_1m: 2.5, input_cache_hit_usd_per_1m: 1.25, output_usd_per_1m: 10.0 },
+        ]));
+        const report = await runPriceDriftWatch({
+            mode: 'offline',
+            observedAt: () => new Date('2026-08-30T12:00:00Z'),
+            providers: [{ id: 'mockprov', source_url: 'mock://mockprov', baseline_path: bp, snapshot_path: join(root, 'no-such-snapshot.html'), parse: parseOpenaiHtml }],
+        });
+        assert.equal(report.providers['mockprov'].status, 'skipped_no_snapshot', 'snapshot 缺失 → SKIP');
+        ok('snapshot 缺失 → skipped_no_snapshot(offline)');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+await testSnapshotNextDataParser();
+await testSnapshotFallbackDrift();
+await testSnapshotMissing();
+console.log(`price-drift-watch tests: ${passed} 组断言全绿(offline,fetch 模式手动/CI 心跳)`);