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

package/dist/scripts/effect-tests.js

@@ -0,0 +1,539 @@
+/**
+ * 效应解译器测试(effect_interpreter.v1,issue #16 采纳,ADR-18;纯离线零网络):
+ *  1. 注册表封闭性:未登记效应 → 结构化拒绝面(不抛错,declined=unknown-effect)
+ *  2. 指数退避 withRetry:500→1000→2000 封顶链;累计记账;非瞬时失败不重试
+ *  3. 断路器三态:closed→(连续失败达阈)→open→(冷却)→half-open 单探测→成功回 closed/失败再开
+ *  4. 生产解译器×瞬时失败:重试后成功(trace.attempts/backoff 记账,evidence 行)
+ *  5. FlyAI×Sentinel:上游说不永不重试(attempts=1);连续失败计入熔断,熔断后零执行成本
+ *  6. 断路拒绝面:不执行、不抛错、平铺失败观察;冷却后 half-open 单探测成功 → closed
+ *  7. mock 解译器:夹具回放确定性;未登记夹具=结构化拒绝
+ *  8. SESSION 通道策略:永不重试、不熔断(风控红线),verdict 原样透传
+ *  9. 真实 handler 离线冒烟:hbcli 不可达 → 静态包降级(永不抛错,证据链非空)
+ * 11. HBCLI×timeout(2026-09-02 迪拜 session:冷启动建后端 session 超 30s):
+ *     timeout 类失败重试 1 次即恢复;ENOENT/退码类仍永不重试(切换不是重试)
+ *
+ * 运行: cd ts && npx tsx scripts/effect-tests.ts
+ */
+import assert from 'node:assert/strict';
+import { getEventListeners } from 'node:events';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { backoffDelayMs, CircuitBreaker, withRetry } from '../capabilities/resilience.js';
+import { declinedObservation, makeMockInterpreter, makeProductionInterpreter, __resetEffectBreakersForTest, } from '../capabilities/effect.js';
+const sleep0 = async () => { }; // 回退即时放行(确定性,不真睡)
+let clock = 1_000_000;
+const now = () => clock;
+// ---------------------------------------------------------------------------
+// 1. 注册表封闭性:未登记效应 → 结构化拒绝(不抛错)
+// ---------------------------------------------------------------------------
+const interp = makeProductionInterpreter({ sleep: sleep0, now });
+const badItp = await interp({ effect: 'CTRIP_DIRECT_QUERY', params: {} });
+assert.equal(badItp.result, null, '未登记效应 result=null');
+assert.equal(badItp.trace.declined, 'unknown-effect');
+assert.equal(badItp.trace.attempts, 0, '未登记效应零执行');
+const badObs = declinedObservation('CTRIP_DIRECT_QUERY', badItp.trace);
+assert.equal(badObs.ok, false);
+assert.match(badObs.summary, /未登记效应/, '拒绝面人话 summary');
+assert.match(badObs.evidence, /\[效应:CTRIP_DIRECT_QUERY@/, '拒绝面带证据链');
+console.log('1. 注册表封闭性:未登记效应 → 结构化拒绝面(不抛错)OK');
+// Host cancellation is an explicit outcome, not an unregistered-effect diagnosis.
+const preCancelled = new AbortController();
+preCancelled.abort();
+let cancelledDispatches = 0;
+const cancelledInterpreter = makeProductionInterpreter({
+    breakers: new Map(),
+    handlers: { ANYTHING_SEARCH: async () => { cancelledDispatches++; return { ok: true }; } },
+});
+const cancelled = await cancelledInterpreter({ effect: 'ANYTHING_SEARCH', params: { signal: preCancelled.signal } });
+assert.equal(cancelled.result, null);
+assert.equal(cancelled.trace.declined, 'aborted');
+assert.equal(cancelled.trace.attempts, 0);
+assert.equal(cancelledDispatches, 0);
+const cancelledObservation = declinedObservation('ANYTHING_SEARCH', cancelled.trace);
+assert.equal(cancelledObservation.ok, false);
+assert.match(cancelledObservation.summary, /已取消/);
+assert.doesNotMatch(cancelledObservation.summary, /未登记|断路器/);
+assert.match(cancelledObservation.evidence, /@abort@/);
+console.log('1b. 宿主取消明确呈现已取消，零派发、不误报未登记效应 OK');
+// ---------------------------------------------------------------------------
+// 2. 指数退避:500→1000→2000 封顶;累计记账;非瞬时失败不重试
+// ---------------------------------------------------------------------------
+assert.equal(backoffDelayMs({ baseDelayMs: 500, maxDelayMs: 8000 }, 1), 500);
+assert.equal(backoffDelayMs({ baseDelayMs: 500, maxDelayMs: 8000 }, 2), 1000);
+assert.equal(backoffDelayMs({ baseDelayMs: 500, maxDelayMs: 8000 }, 4), 4000);
+assert.equal(backoffDelayMs({ baseDelayMs: 500, maxDelayMs: 2000 }, 6), 2000, '封顶');
+const retried = [];
+const rt = await withRetry(async () => ({ ok: false }), { maxAttempts: 4, baseDelayMs: 500, maxDelayMs: 2000, isRetryable: () => true, sleep: sleep0 }, (_failN, delayMs) => retried.push(delayMs));
+assert.deepEqual(retried, [500, 1000, 2000], '退避序列 500/1000/2000');
+assert.equal(rt.attempts, 4, '重试到上限');
+assert.equal(rt.backoffMs, 3500, '累计回退记账');
+const noRetry = await withRetry(async () => ({ ok: false, verdict: 'error', error: '{"message":"SentinelBlockException"}' }), { maxAttempts: 3, baseDelayMs: 500, maxDelayMs: 2000, isRetryable: () => false, sleep: sleep0 });
+assert.equal(noRetry.attempts, 1, '瞬时判定说不重试就 1 次');
+// 2a. 退避等待生命周期：正常 timer、取消与注入 sleep 都移除 abort listener。
+const normalBackoffController = new AbortController();
+let normalBackoffCalls = 0;
+const normalBackoff = await withRetry(async () => ({ ok: ++normalBackoffCalls > 1 }), { maxAttempts: 2, baseDelayMs: 5, maxDelayMs: 5, signal: normalBackoffController.signal });
+assert.equal(normalBackoff.attempts, 2, '真实 timer 等待后继续下一次尝试');
+assert.equal(normalBackoff.aborted, false, '正常等待不是取消');
+assert.equal(getEventListeners(normalBackoffController.signal, 'abort').length, 0, '正常 timer 完成后移除 abort listener');
+const cancelledBackoffController = new AbortController();
+let cancelledBackoffCalls = 0;
+let cancelTimer;
+let cancelledBackoff;
+try {
+    cancelledBackoff = await withRetry(async () => { cancelledBackoffCalls += 1; return { ok: false }; }, { maxAttempts: 2, baseDelayMs: 100, maxDelayMs: 100, signal: cancelledBackoffController.signal }, () => { cancelTimer = setTimeout(() => cancelledBackoffController.abort(), 1); });
+}
+finally {
+    if (cancelTimer !== undefined)
+        clearTimeout(cancelTimer);
+}
+assert.equal(cancelledBackoff.attempts, 1, 'backoff 取消不派发下一次尝试');
+assert.equal(cancelledBackoff.aborted, true, 'backoff 取消返回 aborted');
+assert.equal(cancelledBackoffCalls, 1, '取消不是第二次失败');
+assert.equal(getEventListeners(cancelledBackoffController.signal, 'abort').length, 0, '取消后移除 abort listener');
+const injectedSleepController = new AbortController();
+let injectedSleepCalls = 0;
+const injectedSleep = await withRetry(async () => ({ ok: false }), {
+    maxAttempts: 2,
+    baseDelayMs: 1,
+    maxDelayMs: 1,
+    signal: injectedSleepController.signal,
+    sleep: async () => { injectedSleepCalls += 1; injectedSleepController.abort(); },
+});
+assert.equal(injectedSleepCalls, 1, '退避使用注入 sleep');
+assert.equal(injectedSleep.aborted, true, '注入 sleep 中取消仍终止重试');
+assert.equal(injectedSleep.attempts, 1, '注入 sleep 取消不派发下一次尝试');
+assert.equal(getEventListeners(injectedSleepController.signal, 'abort').length, 0, '注入 sleep 取消后移除 abort listener');
+const rejectedSleepController = new AbortController();
+const sleepFailure = new Error('synthetic sleep failure');
+await assert.rejects(withRetry(async () => ({ ok: false }), {
+    maxAttempts: 2,
+    baseDelayMs: 1,
+    maxDelayMs: 1,
+    signal: rejectedSleepController.signal,
+    sleep: async () => { throw sleepFailure; },
+}), (error) => error === sleepFailure, '注入 sleep rejection 保持原异常约定');
+assert.equal(getEventListeners(rejectedSleepController.signal, 'abort').length, 0, '注入 sleep rejection 后移除 abort listener');
+console.log('2. 指数退避(封顶链/累计记账/非瞬时止步)OK');
+// ---------------------------------------------------------------------------
+// 3. 断路器三态(时钟注入确定性)
+// ---------------------------------------------------------------------------
+const br = new CircuitBreaker({ failureThreshold: 2, openMs: 60_000, now });
+assert.equal(br.canAttempt().state, 'closed');
+br.onFailure();
+br.onFailure();
+assert.equal(br.state(), 'open', '连续 2 失败 → open');
+assert.equal(br.canAttempt().allowed, false, 'open 中拒绝');
+clock += 61_000;
+assert.equal(br.state(), 'half-open', '冷却满 → half-open');
+const gate = br.canAttempt();
+assert.equal(gate.allowed, true, 'half-open 放行单探测');
+assert.equal(br.canAttempt().allowed, false, '探测在途拒并发');
+br.onSuccess();
+assert.equal(br.state(), 'closed', '探测成功 → closed');
+br.onFailure();
+br.onFailure();
+clock += 61_000;
+assert.equal(br.state(), 'half-open');
+assert.equal(br.canAttempt().allowed, true);
+br.onFailure();
+assert.equal(br.state(), 'open', '探测失败 → 重新 open(冷却重启)');
+console.log('3. 断路器三态(closed→open→half-open 单探测→双向收敛)OK');
+// 3a. 半开探测所有权：旧 closed 调用的取消/完成不能释放或修改新一代探测。
+const raceClock = { value: 100 };
+const raceNow = () => raceClock.value;
+let resolveOldClosed;
+let resolveOldClosedCompletion;
+let resolveHalfOpenProbe;
+let oldClosedStarted;
+let oldClosedCompletionStarted;
+let halfOpenProbeStarted;
+const oldClosedReady = new Promise((resolve) => { oldClosedStarted = resolve; });
+const oldClosedCompletionReady = new Promise((resolve) => { oldClosedCompletionStarted = resolve; });
+const halfOpenProbeReady = new Promise((resolve) => { halfOpenProbeStarted = resolve; });
+let secondProbeCalled = false;
+const raceInterpreter = makeProductionInterpreter({
+    sleep: sleep0,
+    now: raceNow,
+    breakers: new Map(),
+    handlers: {
+        HBCLI_HOTEL_SEARCH: async (params) => {
+            if (params.testCase === 'old-closed') {
+                oldClosedStarted();
+                return new Promise((resolve) => { resolveOldClosed = resolve; });
+            }
+            if (params.testCase === 'old-closed-completion') {
+                oldClosedCompletionStarted();
+                return new Promise((resolve) => { resolveOldClosedCompletion = resolve; });
+            }
+            if (params.testCase === 'half-open-probe') {
+                halfOpenProbeStarted();
+                return new Promise((resolve) => { resolveHalfOpenProbe = resolve; });
+            }
+            if (params.testCase === 'second-probe') {
+                secondProbeCalled = true;
+                return { via: 'hbcli-realtime' };
+            }
+            return { via: 'hbcli-error', error: 'synthetic permanent failure' };
+        },
+    },
+});
+const oldClosedController = new AbortController();
+const oldClosed = raceInterpreter({ effect: 'HBCLI_HOTEL_SEARCH', params: { testCase: 'old-closed', signal: oldClosedController.signal } });
+await oldClosedReady;
+const oldClosedCompletion = raceInterpreter({ effect: 'HBCLI_HOTEL_SEARCH', params: { testCase: 'old-closed-completion' } });
+await oldClosedCompletionReady;
+for (let i = 0; i < 3; i++)
+    await raceInterpreter({ effect: 'HBCLI_HOTEL_SEARCH', params: { testCase: `failure-${i}` } });
+const raceBlocked = await raceInterpreter({ effect: 'HBCLI_HOTEL_SEARCH', params: { testCase: 'blocked' } });
+assert.equal(raceBlocked.trace.declined, 'circuit-open', '旧请求在途时仍可进入 open');
+raceClock.value = 100_000;
+const halfOpenProbe = raceInterpreter({ effect: 'HBCLI_HOTEL_SEARCH', params: { testCase: 'half-open-probe' } });
+await halfOpenProbeReady;
+oldClosedController.abort();
+resolveOldClosed({ via: 'hbcli-error', error: 'aborted by host signal' });
+const cancelledOldClosed = await oldClosed;
+assert.equal(cancelledOldClosed.trace.attempts, 1, '旧 closed 请求取消仍只执行一次');
+assert.equal(cancelledOldClosed.trace.declined, 'aborted');
+assert.match(declinedObservation('HBCLI_HOTEL_SEARCH', cancelledOldClosed.trace).summary, /已取消/);
+resolveOldClosedCompletion({ via: 'hbcli-realtime' });
+const completedOldClosed = await oldClosedCompletion;
+assert.equal(completedOldClosed.trace.breaker, 'half-open', '旧 closed 请求完成不能修改新半开探测');
+const secondProbe = await raceInterpreter({ effect: 'HBCLI_HOTEL_SEARCH', params: { testCase: 'second-probe' } });
+assert.equal(secondProbe.trace.declined, 'circuit-open', '旧 closed 请求取消不能释放新一代半开探测');
+assert.equal(secondProbeCalled, false, '新一代探测仍由原探测独占');
+resolveHalfOpenProbe({ via: 'hbcli-realtime' });
+const settledHalfOpenProbe = await halfOpenProbe;
+assert.equal(settledHalfOpenProbe.trace.breaker, 'closed', '自身半开探测成功后恢复 closed');
+// 3b. 探测令牌必须跨 generation 隔离：旧令牌不能释放新探测；失败仍保持 open。
+const ownershipClock = { value: 1_000 };
+const ownership = new CircuitBreaker({ failureThreshold: 1, openMs: 10, now: () => ownershipClock.value });
+ownership.onFailure();
+ownershipClock.value += 10;
+const firstProbe = ownership.canAttempt();
+assert.equal(firstProbe.allowed, true);
+ownership.releaseProbe(firstProbe.token);
+const secondGenerationProbe = ownership.canAttempt();
+assert.equal(secondGenerationProbe.allowed, true, '自身取消释放后允许下一代探测');
+ownership.releaseProbe(firstProbe.token);
+assert.equal(ownership.canAttempt().allowed, false, '旧 generation 令牌不能释放新探测');
+ownership.onFailure(secondGenerationProbe.token);
+assert.equal(ownership.state(), 'open', '真实半开失败重新熔断');
+assert.equal(ownership.canAttempt().allowed, false, '真实半开失败后仍拒绝并发探测');
+console.log('3a/3b. 半开探测所有权(旧 closed 取消隔离/取消可重试/跨 generation/失败再熔断)OK');
+// ---------------------------------------------------------------------------
+// 4. 生产解译器×瞬时失败:重试后成功,trace 记账(WEATHER 免费源策略 2 次上限)
+// ---------------------------------------------------------------------------
+let flaky = 0;
+const ip = makeProductionInterpreter({
+    sleep: sleep0,
+    breakers: new Map(),
+    handlers: {
+        WEATHER_FORECAST: async () => {
+            flaky += 1;
+            return flaky < 2
+                ? { ok: false, via: 'open-meteo-error', evidence: '[实时API:open-meteo@error]', latencyMs: 1, error: 'socket hang up' }
+                : { ok: true, via: 'open-meteo', evidence: '[实时API:open-meteo@ts]', latencyMs: 2, daily: [] };
+        },
+    },
+});
+const itp4 = await ip({ effect: 'WEATHER_FORECAST', params: { latitude: 25.6, longitude: 100.2 } });
+assert.equal(itp4.trace.attempts, 2, '瞬时失败重试第 2 次成功(免费源上限 2)');
+assert.equal(itp4.trace.backoffMs, 400, '回退按 API 策略记账');
+assert.ok(itp4.result.ok, '成功 observation 原样透传');
+assert.match(itp4.trace.evidence[0] ?? '', /attempts=2 backoff=400ms breaker=closed/, 'trace 证据行');
+console.log('4. 生产解译器×瞬时失败:重试后成功 + trace 记账 OK');
+// ---------------------------------------------------------------------------
+// 5. FlyAI×Sentinel:不重试,但连续失败计入熔断
+// ---------------------------------------------------------------------------
+const sentinelResult = {
+    ok: false, via: 'flyai-error', verdict: 'error', kind: 'flight', latencyMs: 5,
+    evidence: '[实时API:flyai@error@ts] parse failed(SentinelBlockException)',
+    error: 'failed to parse flyai output as JSON (incomplete FlyAI JSON object): {"message":"SentinelBlockException"}',
+};
+let sentinelCalls = 0;
+const flyaiBreakers = new Map();
+const ipS = makeProductionInterpreter({
+    sleep: sleep0,
+    breakers: flyaiBreakers,
+    now,
+    handlers: { FLYAI_SEARCH: async () => { sentinelCalls += 1; return structuredClone(sentinelResult); } },
+});
+const q = { kind: 'flight', origin: '上海', destination: '丽江', depDate: '2026-10-01' };
+await ipS({ effect: 'FLYAI_SEARCH', params: q });
+await ipS({ effect: 'FLYAI_SEARCH', params: q });
+assert.equal(sentinelCalls, 2, '每次调用只打一次上游(Sentinel 不重试)');
+const itp3 = await ipS({ effect: 'FLYAI_SEARCH', params: q });
+assert.equal(itp3.trace.attempts, 1);
+assert.equal(itp3.trace.breaker, 'open', '连续 3 次失败(FlyAI 阈值 3)→ 断路器开启');
+assert.equal(sentinelCalls, 3);
+const itp4th = await ipS({ effect: 'FLYAI_SEARCH', params: q });
+assert.equal(itp4th.trace.declined, 'circuit-open', '第 4 次:熔断中零执行成本拒绝');
+assert.equal(itp4th.result, null);
+assert.equal(sentinelCalls, 3, '熔断后不再打上游');
+console.log('5. FlyAI×Sentinel:永不重试 + 连环失败触发熔断保护配额 OK');
+// #517: adapter-owned local termination is explicit terminal state. The
+// effect policy must honor retryable=false even when a stale timeout verdict is
+// present, while a classified transient result still receives one retry.
+let localDeadlineCalls = 0;
+const localDeadline = makeProductionInterpreter({
+    breakers: new Map(), sleep: sleep0,
+    handlers: {
+        FLYAI_SEARCH: async () => {
+            localDeadlineCalls += 1;
+            return { ok: false, via: 'flyai-error', verdict: 'timeout', localTermination: 'deadline', retryable: false, kind: 'flight', latencyMs: 1, evidence: 'local deadline' };
+        },
+    },
+});
+const localDeadlineOutcome = await localDeadline({ effect: 'FLYAI_SEARCH', params: q });
+assert.equal(localDeadlineOutcome.trace.attempts, 1, 'local deadline 明确 terminal 只能一次');
+assert.equal(localDeadlineCalls, 1);
+let classifiedTransientCalls = 0;
+const classifiedTransient = makeProductionInterpreter({
+    breakers: new Map(), sleep: sleep0,
+    handlers: {
+        FLYAI_SEARCH: async () => {
+            classifiedTransientCalls += 1;
+            return classifiedTransientCalls === 1
+                ? { ok: false, via: 'flyai-error', verdict: 'error', retryable: true, kind: 'flight', latencyMs: 1, evidence: 'HTTP 500' }
+                : { ok: true, via: 'flyai', verdict: 'miss', kind: 'flight', latencyMs: 1, evidence: 'empty itemList', options: [] };
+        },
+    },
+});
+const classifiedTransientOutcome = await classifiedTransient({ effect: 'FLYAI_SEARCH', params: q });
+assert.equal(classifiedTransientOutcome.trace.attempts, 2, 'HTTP500 retryable=true 应重试一次');
+assert.equal(classifiedTransientCalls, 2);
+console.log('5b. FlyAI retry policy 只接受显式 retryable=true，本地终止/timeout=false 单次 OK');
+// ---------------------------------------------------------------------------
+// 6. 断路拒绝面 + 冷却后 half-open 单探测成功恢复 closed
+// ---------------------------------------------------------------------------
+const declined = declinedObservation('FLYAI_SEARCH', itp4th.trace);
+assert.equal(declined.ok, false);
+assert.match(declined.summary, /断路器开启/, '拒绝面指引「不要立即重试」,不伪装成 miss');
+clock += 120_000; // 冷却满(FlyAI 60s)→ half-open
+const ipOk = makeProductionInterpreter({
+    sleep: sleep0, breakers: flyaiBreakers, now, // 复用同一断路器 Map——状态在 Map 里存活
+    handlers: { FLYAI_SEARCH: async () => ({ ok: true, via: 'flyai', verdict: 'hit', kind: 'flight', latencyMs: 1, evidence: 'e', options: [] }) },
+});
+const itp6 = await ipOk({ effect: 'FLYAI_SEARCH', params: { kind: 'flight' } });
+assert.equal(itp6.trace.breaker, 'closed', 'half-open 单探测成功 → closed 恢复');
+assert.ok(itp6.result != null && !itp6.trace.declined);
+console.log('6. 断路拒绝面(结构化/零执行)+ 冷却后单探测恢复 closed OK');
+// ---------------------------------------------------------------------------
+// 7. mock 解译器:夹具回放确定性(CI 无网)
+// ---------------------------------------------------------------------------
+const mock = makeMockInterpreter({
+    FLYAI_SEARCH: { ok: true, via: 'flyai', verdict: 'hit', kind: 'flight', latencyMs: 0, evidence: '[实时API:flyai@2026-08-29T00:00:00Z] 2/2 flight options', options: [{ no: '9C6617', name: '吉祥航空', depDateTime: '2026-10-01 07:55', arrDateTime: '2026-10-01 11:20', depStation: '浦东T2', arrStation: '丽江三义', durationMin: 205, price: 580 }] },
+});
+const mockFx = { effect: 'FLYAI_SEARCH', params: { kind: 'flight', origin: '上海', destination: '丽江', depDate: '2026-10-01' } };
+const mockA = await mock(mockFx);
+const mockB = await mock(mockFx);
+assert.deepEqual(mockA.result, mockB.result, '同一夹具两次回放同值');
+assert.equal(mockA.result.verdict, 'hit');
+assert.match(mockA.trace.evidence[0] ?? '', /\[效应:mock@.*夹具回放/, 'mock trace 标注');
+const mockMiss = await mock({ effect: 'WEATHER_FORECAST', params: {} });
+assert.equal(mockMiss.trace.declined, 'unknown-effect', 'mock 未登记夹具 = 拒绝面');
+console.log('7. mock 解译器(夹具回放/未登记拒绝/确定性)OK');
+// ---------------------------------------------------------------------------
+// 8. SESSION 通道策略:永不重试、不熔断(风控红线),一次调用一次透传
+// ---------------------------------------------------------------------------
+let sessionCalls = 0;
+const ipSess = makeProductionInterpreter({
+    sleep: sleep0,
+    breakers: new Map(),
+    handlers: {
+        SESSION_FLIGHT_SEARCH: async () => {
+            sessionCalls += 1;
+            return { ok: false, via: 'session-ctrip-flight-error', verdict: 'challenged', evidence: '[会话:ctrip-flight@error@ts] 风控命中', latencyMs: 9, error: 'challenge' };
+        },
+    },
+});
+const sessQ = { from: '上海', to: '丽江', date: '2026-10-01' };
+const itp8 = await ipSess({ effect: 'SESSION_FLIGHT_SEARCH', params: sessQ });
+assert.equal(itp8.result.verdict, 'challenged', '渠道 verdict 原样透传');
+assert.equal(itp8.trace.attempts, 1, 'SESSION 永不重试(挑战=红线)');
+assert.equal(itp8.trace.breaker, 'off', 'SESSION 不参与断路器');
+for (let i = 0; i < 5; i++)
+    await ipSess({ effect: 'SESSION_FLIGHT_SEARCH', params: sessQ });
+const itp8z = await ipSess({ effect: 'SESSION_FLIGHT_SEARCH', params: sessQ });
+assert.ok(itp8z.trace.breaker === 'off' && !itp8z.trace.declined, 'SESSION 无断路拒绝(治理在节律闸与授权闸)');
+assert.equal(sessionCalls, 7);
+console.log('8. SESSION 通道策略(永不重试/不熔断/verdict 透传)OK');
+// ---------------------------------------------------------------------------
+// 9. 真实 handler 离线冒烟:hbcli 显式不可达 → 静态包降级(永不抛错,零网络)
+// ---------------------------------------------------------------------------
+__resetEffectBreakersForTest();
+const tmp = await mkdtemp(join(tmpdir(), 'effect-test-'));
+const itp9 = await interp({
+    effect: 'HBCLI_HOTEL_SEARCH',
+    // 显式不存在的自定义 bin:hbcliBinCandidates 对自定义名不回退已知安装位 → ENOENT → 静态包降级
+    params: { destination: '大理', hbcliBin: join(tmp, 'no-such-hbcli'), fallbackPath: join(import.meta.dirname, '..', '..', 'data', 'hotels_2026.json') },
+});
+const hb9 = itp9.result;
+assert.ok(hb9 != null, '真实 handler 降级仍返回 observation');
+assert.ok(typeof hb9.summary === 'string' && hb9.summary.length > 0, '降级带人话 summary');
+assert.ok(itp9.trace.evidence[0]?.startsWith('[效应:HBCLI_HOTEL_SEARCH@'), '解译层证据行');
+await rm(tmp, { recursive: true, force: true });
+console.log(`9. 真实 handler 离线冒烟(HBCLI 静态包降级,summary=${(hb9.summary ?? '').slice(0, 40)}…)OK`);
+// ---------------------------------------------------------------------------
+// 10. M0 预订链读效应:HBCLI_HOTEL_RATES / HBCLI_CHECK_AVAIL
+//     (注入 handler 验策略面;真实 handler 离线冒烟验价格面 fail-closed;mock 夹具)
+// ---------------------------------------------------------------------------
+// 10a. 注册进生产解译器:注入 handler 派发 / 永不重试 / 失败计熔断 / 三连错开闸
+let ratesDispatches = 0;
+const ipM0 = makeProductionInterpreter({
+    sleep: sleep0,
+    breakers: new Map(),
+    handlers: {
+        HBCLI_HOTEL_RATES: async () => {
+            ratesDispatches += 1;
+            return { via: 'hbcli-realtime', exitCode: 0, result: { rooms: [] }, evidence: '[实时API:hbcli@ts]', latencyMs: 1, rates: { rooms: [] }, summary: 'ok' };
+        },
+        HBCLI_CHECK_AVAIL: async () => ({ via: 'hbcli-error', exitCode: 1, result: null, evidence: '[实时API:hbcli@error@ts]', latencyMs: 1, error: 'boom', avail: null, summary: 'err' }),
+    },
+});
+const itp10 = await ipM0({ effect: 'HBCLI_HOTEL_RATES', params: { hotelId: '900000001', checkIn: '2026-09-05', checkOut: '2026-09-07', adults: 2 } });
+assert.equal(itp10.trace.attempts, 1, 'RATES 永不重试(候选路径切换不是重试)');
+assert.ok(itp10.result != null && !itp10.trace.declined, 'RATES 命中注入 handler,observation 透传');
+assert.ok(itp10.trace.evidence[0]?.startsWith('[效应:HBCLI_HOTEL_RATES@'), '解译层证据行');
+const itp10b = await ipM0({ effect: 'HBCLI_CHECK_AVAIL', params: { ratePkgId: 'rp-1' } });
+assert.equal(itp10b.result?.via, 'hbcli-error', '渠道失败观察原样透传(平铺失败面,isFailure 计熔断)');
+await ipM0({ effect: 'HBCLI_CHECK_AVAIL', params: { ratePkgId: 'rp-2' } });
+await ipM0({ effect: 'HBCLI_CHECK_AVAIL', params: { ratePkgId: 'rp-3' } });
+const itp10c = await ipM0({ effect: 'HBCLI_CHECK_AVAIL', params: { ratePkgId: 'rp-4' } });
+assert.equal(itp10c.trace.declined, 'circuit-open', '3 连错熔断保护(同 HBCLI 族策略)');
+assert.equal(ratesDispatches, 1, '成功通道不受失败通道熔断影响(per-effect 隔离)');
+console.log('10a. 预订链读效应注册(派发/永不重试/熔断族/per-effect 隔离)OK');
+// 10b. 真实 handler 离线冒烟:不可达 bin → 诚实失败,价格面无静态降级(fail-closed)
+__resetEffectBreakersForTest();
+const tmp10 = await mkdtemp(join(tmpdir(), 'effect-m0-'));
+const itp10d = await interp({
+    effect: 'HBCLI_HOTEL_RATES',
+    // 自定义不存在的 bin:候选路径不回退已知安装位 → ENOENT → 诚实失败(hotel-list 才有静态包降级)
+    params: { hotelId: '900000001', hbcliBin: join(tmp10, 'no-such-hbcli') },
+});
+const hr10 = itp10d.result;
+assert.ok(hr10 != null, '不可达仍返回 observation(永不抛错)');
+assert.equal(hr10.via, 'hbcli-error', '未伪装成功');
+assert.match(hr10.summary ?? '', /不可用/, 'summary 明示不可用');
+assert.ok(!/静态包/.test(hr10.summary ?? '') || /无静态降级/.test(hr10.summary ?? ''), '价格面不降级到静态包');
+const itp10e = await interp({ effect: 'HBCLI_CHECK_AVAIL', params: { ratePkgId: 'rp-x', hbcliBin: join(tmp10, 'no-such-hbcli') } });
+assert.equal(itp10e.result?.via, 'hbcli-error', 'check-avail 同口径诚实失败');
+await rm(tmp10, { recursive: true, force: true });
+console.log('10b. 真实 handler 离线冒烟(价格面 fail-closed,无静态降级)OK');
+// 10c. mock 解译器夹具回放(预订链 CI 形态;录制形态 = 渠道 observation 原样)
+const mock10 = makeMockInterpreter({
+    HBCLI_HOTEL_RATES: { via: 'hbcli-realtime', exitCode: 0, result: { rooms: [{ ratePkgId: 'rp-fx-1', roomTypeName: 'Deluxe King' }] }, evidence: '[实时API:hbcli@2026-08-30T00:00:00Z]', latencyMs: 1800, rates: { rooms: [{ ratePkgId: 'rp-fx-1', roomTypeName: 'Deluxe King' }] }, summary: 'hotel 900000001:hbcli 实时报价(2026-09-05 → 2026-09-07)' },
+    HBCLI_CHECK_AVAIL: { via: 'hbcli-realtime', exitCode: 0, result: { ratePkgId: 'rp-fx-1', avail: true }, evidence: '[实时API:hbcli@2026-08-30T00:00:01Z]', latencyMs: 900, avail: { ratePkgId: 'rp-fx-1', avail: true }, summary: 'ratePkg rp-fx-1:hbcli 实时验价(库存与价格以后端为准)' },
+});
+const m10a = await mock10({ effect: 'HBCLI_HOTEL_RATES', params: { hotelId: '900000001' } });
+const m10b = await mock10({ effect: 'HBCLI_CHECK_AVAIL', params: { ratePkgId: 'rp-fx-1' } });
+assert.equal(m10a.result.rates?.rooms?.length, 1, 'RATES 夹具回放');
+assert.equal(m10b.result.avail?.avail, true, 'CHECK_AVAIL 夹具回放');
+assert.match(m10a.trace.evidence[0] ?? '', /\[效应:mock@.*夹具回放/, 'mock trace 标注');
+console.log('10c. mock 解译器夹具回放(预订链 CI 形态)OK');
+// ---------------------------------------------------------------------------
+// 11. HBCLI×timeout 冷启动重试(2026-09-02 迪拜 session 复盘:hotel-list 首调
+//     30s 超时,LLM 手动立即重试即成功——上游建后端 session 可超时;策略改为
+//     「仅 timeout 类重试 1 次」,ENOENT/退码类维持「切换不是重试」)
+// ---------------------------------------------------------------------------
+__resetEffectBreakersForTest();
+let flakyCalls = 0;
+const ipTimeout = makeProductionInterpreter({
+    sleep: sleep0,
+    breakers: new Map(),
+    handlers: {
+        HBCLI_HOTEL_SEARCH: async () => {
+            flakyCalls += 1;
+            if (flakyCalls === 1)
+                return { via: 'hbcli-error', exitCode: -1, result: null, evidence: '[实时API:hbcli@timeout@ts]', latencyMs: 1, error: 'timeout after 30000ms' };
+            return { via: 'hbcli-realtime', exitCode: 0, result: { hotels: [] }, evidence: '[实时API:hbcli@ts]', latencyMs: 1 };
+        },
+    },
+});
+const itp11 = await ipTimeout({ effect: 'HBCLI_HOTEL_SEARCH', params: { destination: '迪拜' } });
+assert.equal(itp11.trace.attempts, 2, `timeout 重试一次(attempts=2),实际 ${itp11.trace.attempts}`);
+assert.equal(itp11.result?.via, 'hbcli-realtime', '重试后恢复实时');
+assert.equal(itp11.trace.breaker, 'closed', '恢复即成功,断路不计数');
+let hardCalls = 0;
+const ipEnoent = makeProductionInterpreter({
+    sleep: sleep0,
+    breakers: new Map(),
+    handlers: {
+        HBCLI_HOTEL_SEARCH: async () => {
+            hardCalls += 1;
+            return { via: 'hbcli-error', exitCode: -1, result: null, evidence: '[实时API:hbcli@spawn_error@ts]', latencyMs: 1, error: 'spawn hbcli ENOENT' };
+        },
+    },
+});
+const itp11b = await ipEnoent({ effect: 'HBCLI_HOTEL_SEARCH', params: { destination: '迪拜' } });
+assert.equal(itp11b.trace.attempts, 1, 'ENOENT 类永不重试(切换不是重试契约不变)');
+console.log('11. HBCLI×timeout 冷启动重试(timeout→attempts=2 恢复实时;ENOENT→attempts=1)OK');
+// ---------------------------------------------------------------------------
+// 12. D-23 收尾(issue #115):六渠道入注册表——策略表行存在 + 横切语义正确
+//     (anything/web/github/video/agent_reach/session_login;没有策略表行就没有效应)
+// ---------------------------------------------------------------------------
+__resetEffectBreakersForTest();
+// 12a. 六效应注册在案:handler 注入 → 原样透传,trace.channel 与策略表一致
+const sixChannels = [
+    ['ANYTHING_SEARCH', 'cli', { ok: true, via: 'hbcli-anything', verdict: 'hit', evidence: 'e', latencyMs: 1 }],
+    ['WEB_READ', 'api', { ok: true, via: 'r.jina.ai', evidence: 'e', latencyMs: 1 }],
+    ['GITHUB_SEARCH', 'cli', { ok: true, verdict: 'found', evidence: 'e', latencyMs: 1 }],
+    ['VIDEO_SUBTITLE', 'cli', { ok: true, verdict: 'found', evidence: 'e', latencyMs: 1 }],
+    ['AGENT_REACH', 'cli', { ok: true, verdict: 'found', channel: 'v2ex', method: 'read', evidence: 'e', latencyMs: 1 }],
+    ['SESSION_LOGIN', 'browser', { ok: true, via: 'session-login', verdict: 'pending', evidence: 'e', latencyMs: 1 }],
+];
+for (const [fx, channel, obs] of sixChannels) {
+    const ip = makeProductionInterpreter({ sleep: sleep0, breakers: new Map(), handlers: { [fx]: async () => obs } });
+    const out = await ip({ effect: fx, params: {} });
+    assert.equal(out.result, obs, `${fx} 透传原样`);
+    assert.equal(out.trace.channel, channel, `${fx} trace.channel=${channel}(策略表行在案)`);
+    assert.equal(out.trace.attempts, 1, `${fx} 成功单次执行`);
+}
+console.log('12a. 六渠道入表(透传 + trace.channel 与策略表一致)OK');
+// 12b. 永不重试族:AGENT_REACH / SESSION_LOGIN handler 恒抛错 → attempts=1(透传面不放大上游消耗)
+for (const fx of ['AGENT_REACH', 'SESSION_LOGIN']) {
+    const ip = makeProductionInterpreter({ sleep: sleep0, breakers: new Map(), handlers: { [fx]: async () => { throw new Error('upstream says no'); } } });
+    const out = await ip({ effect: fx, params: {} });
+    assert.equal(out.result, null, `${fx} 抛错 → result=null`);
+    assert.equal(out.trace.attempts, 1, `${fx} 永不重试(attempts=1)`);
+}
+console.log('12b. AGENT_REACH/SESSION_LOGIN 永不重试(反射桥透传/浏览器风控红线)OK');
+// 12c. WEB_READ 瞬时抖动重试 1 次(throw → 成功,attempts=2);GITHUB timeout 重试 / not-installed 不重试
+__resetEffectBreakersForTest();
+let webCalls = 0;
+const ipWeb = makeProductionInterpreter({
+    sleep: sleep0, breakers: new Map(),
+    handlers: { WEB_READ: async () => { webCalls += 1; if (webCalls === 1)
+            throw new Error('socket hang up'); return { ok: true, via: 'r.jina.ai', evidence: 'e', latencyMs: 1 }; } },
+});
+const outWeb = await ipWeb({ effect: 'WEB_READ', params: { url: 'https://example.com' } });
+assert.equal(outWeb.trace.attempts, 2, `WEB_READ 瞬时抖动重试 1 次,实际 ${outWeb.trace.attempts}`);
+let ghTimeoutCalls = 0;
+const ipGhTimeout = makeProductionInterpreter({
+    sleep: sleep0, breakers: new Map(),
+    handlers: { GITHUB_SEARCH: async () => { ghTimeoutCalls += 1; if (ghTimeoutCalls === 1)
+            return { ok: false, verdict: 'timeout', evidence: 'e', latencyMs: 1, stdout: '', stderr: '' }; return { ok: true, verdict: 'found', evidence: 'e', latencyMs: 1 }; } },
+});
+const outGhT = await ipGhTimeout({ effect: 'GITHUB_SEARCH', params: { query: 'x' } });
+assert.equal(outGhT.trace.attempts, 2, 'GITHUB timeout 类重试 1 次(冷启动同 HBCLI 实况)');
+let ghNiCalls = 0;
+const ipGhNi = makeProductionInterpreter({
+    sleep: sleep0, breakers: new Map(),
+    handlers: { GITHUB_SEARCH: async () => { ghNiCalls += 1; return { ok: false, verdict: 'not-installed', evidence: 'e', latencyMs: 0 }; } },
+});
+const outGhNi = await ipGhNi({ effect: 'GITHUB_SEARCH', params: { query: 'x' } });
+assert.equal(outGhNi.trace.attempts, 1, 'not-installed 是配置态(needs-setup 族)不重试');
+console.log('12c. WEB_READ/GITHUB/VIDEO 策略行(timeout 重试/配置态不重试)OK');
+// 12d. mock 面:新效应夹具回放 + 未登记夹具结构化拒绝(与既有效应同语义)
+__resetEffectBreakersForTest();
+const mockIp = makeMockInterpreter({ ANYTHING_SEARCH: { ok: true, via: 'hbcli-anything', verdict: 'hit', evidence: '[实时API:hbcli-anything@ts]', latencyMs: 1 } });
+const outMock = await mockIp({ effect: 'ANYTHING_SEARCH', params: { keyword: '大理' } });
+assert.equal(outMock.result.verdict, 'hit', 'mock 夹具回放原样');
+assert.equal(outMock.trace.channel, 'mock', 'mock 通道标注');
+const outMockBad = await mockIp({ effect: 'SESSION_LOGIN', params: {} });
+assert.equal(outMockBad.result, null, '未登记夹具 → result=null');
+assert.equal(outMockBad.trace.declined, 'unknown-effect', '未登记夹具 → 结构化拒绝');
+console.log('12d. mock 夹具回放/未登记拒绝(新效应同语义)OK');
+console.log('EFFECT INTERPRETER TESTS: 12/12 OK(effect_interpreter.v1:注册表封闭/退避链/断路三态/Sentinel 不重试/mock 夹具/SESSION 红线/真实降级/M0 预订链读效应/HBCLI timeout 重试/D-23 六渠道入表,纯离线)');

package/dist/scripts/engine-run.js

@@ -1,3 +1,4 @@
+// TS 引擎直接跑洱海金标准用例,打印与 Python 相同结构的结果
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { parseCandidate, parseRequest } from '../src/model.js';
@@ -9,6 +10,3 @@ const t0 = Date.now();
 const result = await solve(req, candidates);
 console.log(`(TS 引擎总耗时含 WASM init: ${Date.now() - t0}ms, recommended=${result['recommended']})\n`);
 console.log(result['answer_md']);
-
-
-//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/engine-run.ts

package/dist/scripts/engine-tests.js

@@ -1,3 +1,7 @@
+/**
+ * TS 引擎金标准断言(与 py/tests/test_engine.py 同一套洱海用例)。
+ * 运行(在 ts/ 下):npx tsx scripts/engine-tests.ts
+ */
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -7,39 +11,41 @@ const payload = JSON.parse(await readFile(join('..', 'data', 'golden_erhai.json'
 const req = parseRequest(payload['request']);
 const candidates = payload['candidates'].map(parseCandidate);
 const result = await solve(req, candidates);
-const verdicts = Object.fromEntries(result.verdicts.map((v)=>[
-        v['candidate_id'],
-        v
-    ]));
+const verdicts = Object.fromEntries(result.verdicts.map(v => [v['candidate_id'], v]));
+// 1. 洱海在周末窗口不可行,unsat core 必须点名 duration
 assert.equal(verdicts['dali']['feasible'], false);
 assert.ok(verdicts['dali']['unsat_core'].includes('duration'));
+// 2. 憧憬不被拒绝:进 wish pool,带成行条件
 const wp = verdicts['dali']['wish_pool'];
 assert.ok(wp, 'dali wish pool exists');
 assert.ok(wp['conditions']['days'] >= 5);
 assert.ok('budget_cny' in wp['conditions']);
 assert.ok(wp['conditions']['best_months'].length > 0);
+// 3. 最小修改建议必须写明代价
 assert.ok(verdicts['dali']['suggestions'].length > 0);
-assert.ok(verdicts['dali']['suggestions'].some((s)=>s['text'].includes('天')));
+assert.ok(verdicts['dali']['suggestions'].some((s) => s['text'].includes('天')));
+// 4. 千岛湖可行且被推荐
 assert.equal(verdicts['qiandao']['feasible'], true);
 assert.equal(result.recommended, 'qiandao');
+// 5. 全成本六要素齐全
 const t = verdicts['qiandao']['true_cost'];
 assert.ok(t['money_cny'] <= 3000);
 assert.ok(Number(String(t['wake']).replace(':', '')) >= 630);
 assert.ok(t['energy_arrival_pct'] >= 40);
 assert.ok(t['usable_hours'] >= requiredUsableHours(req.motivation));
+// 6. 太湖也可行且更便宜(同一可行口径内)
 assert.equal(verdicts['taihu']['feasible'], true);
 assert.ok(verdicts['taihu']['true_cost']['money_cny'] <= verdicts['qiandao']['true_cost']['money_cny']);
+// 7. 回答不空手而归
 assert.ok(result.answer_md.includes('千岛湖'));
 assert.ok(result.answer_md.includes('下一次出发'));
 assert.ok(result.answer_md.includes('待你决定的两个问题'));
+// 8. 预算差一口气的场景:报告差额而非拒绝
 const tight = structuredClone(payload);
 tight['request']['budget_cny'] = 900;
 const tightReq = parseRequest(tight['request']);
-const v = await solveCandidate(candidates.find((c)=>c.id === 'qiandao'), tightReq);
+const v = await solveCandidate(candidates.find(c => c.id === 'qiandao'), tightReq);
 assert.equal(v.feasible, false);
 assert.ok(v.unsatCore.includes('budget'));
-assert.ok(v.suggestions.some((s)=>s.text.includes('预算提高到')));
+assert.ok(v.suggestions.some(s => s.text.includes('预算提高到')));
 console.log('TS ENGINE TESTS: 8/8 OK');
-
-
-//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/engine-tests.ts