@danceiny/gotry 0.2.0-rc.31 → 0.2.0-rc.33

package/dist/scripts/effect-tests.js

@@ -22,518 +22,616 @@ 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;
+// Every FlyAI test resolves only synthetic configuration, never the user's key.
+const flyaiTestHome = await mkdtemp(join(tmpdir(), 'effect-flyai-home-'));
+const originalFlyaiEnv = Object.fromEntries(['HOME', 'FLYAI_API_KEY', 'DEBUG_FLYAI_API_KEY', 'DEBUG_FLYAI_MCP_URL'].map(name => [name, process.env[name]]));
+process.env.HOME = flyaiTestHome;
+process.env.FLYAI_API_KEY = 'effect-fixture-key';
+delete process.env.DEBUG_FLYAI_API_KEY;
+process.env.DEBUG_FLYAI_MCP_URL = 'https://flyai-fixture.invalid/mcp';
 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' };
+    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');
+    // A valid injected clock can start at epoch zero; opening must not depend on
+    // a truthy timestamp, and remaining cooldown must stay bounded if time rolls back.
+    let zeroClock = 0;
+    const epochBreaker = new CircuitBreaker({ failureThreshold: 1, openMs: 60_000, now: () => zeroClock });
+    epochBreaker.onFailure();
+    assert.equal(epochBreaker.canAttempt().allowed, false, 'failure at epoch zero must open the breaker');
+    assert.equal(epochBreaker.canAttempt().retryAfterMs, 60_000);
+    zeroClock = -1_000;
+    assert.equal(epochBreaker.canAttempt().retryAfterMs, 60_000, 'clock rollback cannot exceed the configured cooldown');
+    zeroClock = 60_000;
+    assert.equal(epochBreaker.canAttempt().allowed, true, 'exact cooldown boundary admits a single probe');
+    assert.equal(epochBreaker.canAttempt().retryAfterMs, undefined, 'in-flight probe has no invented completion estimate');
+    // 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 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 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:不重试,但连续失败计入熔断
+    // ---------------------------------------------------------------------------
+    // A failure observation is not evidence of an outage. Business/auth/input/
+    // malformed failures stay visible without opening or retrying the breaker.
+    for (const result of [
+        { verdict: 'error', error: 'upstream business status 1001', upstreamHealth: 'unknown' },
+        { verdict: 'auth-error', upstreamHealth: 'unknown' },
+        { verdict: 'forbidden', upstreamHealth: 'unknown' },
+        { verdict: 'needs-setup', upstreamHealth: 'unknown' },
+        { verdict: 'cancelled', localTermination: 'signal', upstreamHealth: 'unknown' },
+        { verdict: 'error', error: 'malformed itemList', upstreamHealth: 'unknown' },
+        { verdict: 'error', error: 'invalid argument', upstreamHealth: 'unknown' },
+        { verdict: 'error', error: 'unclassified legacy failure' },
+    ]) {
+        let calls = 0;
+        const neutral = makeProductionInterpreter({
+            breakers: new Map(), sleep: sleep0,
+            handlers: { FLYAI_SEARCH: async () => { calls += 1; return { ok: false, via: 'flyai-error', kind: 'flight', latencyMs: 1, evidence: 'fixture failure', retryable: false, ...result }; } },
+        });
+        for (let attempt = 0; attempt < 4; attempt += 1) {
+            const out = await neutral({ effect: 'FLYAI_SEARCH', params: { kind: 'flight', origin: '北京' } });
+            assert.equal(out.trace.declined, undefined, `${result.verdict}/${result.error ?? ''} must not open breaker`);
+            assert.equal(out.trace.attempts, 1, 'neutral failure must not retry');
+            assert.equal(out.result.ok, false, 'neutral failure stays a visible failure');
+        }
+        assert.equal(calls, 4, 'all neutral requests reach the adapter');
+    }
+    console.log('5a. FlyAI business/auth/setup/input/malformed/cancelled failures are breaker-neutral OK');
+    const streakResults = [
+        { ok: false, upstreamHealth: 'unhealthy', retryable: false },
+        { ok: false, upstreamHealth: 'unknown', retryable: false },
+        { ok: false, upstreamHealth: 'unhealthy', retryable: false },
+        { ok: false, upstreamHealth: 'unhealthy', retryable: false },
+    ];
+    const streakInterpreter = makeProductionInterpreter({
+        breakers: new Map(), sleep: sleep0,
+        handlers: { FLYAI_SEARCH: async () => streakResults.shift() },
+    });
+    for (let i = 0; i < 4; i += 1)
+        await streakInterpreter({ effect: 'FLYAI_SEARCH', params: { kind: 'flight' } });
+    const streakBlocked = await streakInterpreter({ effect: 'FLYAI_SEARCH', params: { kind: 'flight' } });
+    assert.equal(streakBlocked.trace.declined, 'circuit-open', 'neutral failure cannot falsely reset consecutive upstream faults');
+    const sentinelResult = {
+        ok: false, via: 'flyai-error', verdict: 'error', kind: 'flight', latencyMs: 5,
+        upstreamHealth: 'unhealthy', retryable: false,
+        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, '熔断后不再打上游');
+    assert.equal(itp4th.trace.retryAfterMs, 60_000, 'open rejection exposes bounded remaining cooldown');
+    clock += 1_000;
+    const cooling = await ipS({ effect: 'FLYAI_SEARCH', params: q });
+    assert.equal(cooling.trace.retryAfterMs, 59_000, 'cooldown decreases with elapsed time');
+    const coolingObservation = declinedObservation('FLYAI_SEARCH', cooling.trace);
+    assert.equal(coolingObservation.retryAfterMs, 59_000, 'flat failure preserves actionable cooldown');
+    assert.match(coolingObservation.summary, /59/, 'user feedback includes remaining seconds');
+    assert.doesNotMatch(coolingObservation.summary, /不支持|unsupported|无航班/, 'outage is not route/inventory evidence');
+    const hotelIndependent = await ipS({ effect: 'FLYAI_SEARCH', params: { kind: 'hotel', destName: '北京' } });
+    assert.equal(hotelIndependent.trace.attempts, 1, 'flight breaker cannot disable hotel searches');
+    process.env.FLYAI_API_KEY = 'corrected-fixture-key';
+    const correctedKey = await ipS({ effect: 'FLYAI_SEARCH', params: q });
+    assert.equal(correctedKey.trace.attempts, 1, 'corrected key starts an independent breaker');
+    process.env.FLYAI_API_KEY = 'effect-fixture-key';
+    process.env.DEBUG_FLYAI_MCP_URL = 'https://flyai-fixture.invalid/mcp?token=changed-secret';
+    const changedEndpoint = await ipS({ effect: 'FLYAI_SEARCH', params: q });
+    assert.equal(changedEndpoint.trace.attempts, 1, 'endpoint query changes start an independent breaker');
+    const scopeText = JSON.stringify([...flyaiBreakers.keys()]) + JSON.stringify(changedEndpoint.trace);
+    assert.doesNotMatch(scopeText, /effect-fixture-key|corrected-fixture-key|changed-secret|https:/, 'breaker keys and traces contain no credential/endpoint plaintext');
+    process.env.DEBUG_FLYAI_MCP_URL = 'https://flyai-fixture.invalid/mcp';
+    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 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, upstreamHealth: 'unhealthy', kind: 'flight', latencyMs: 1, evidence: 'HTTP 500' }
+                    : { ok: true, via: 'flyai', verdict: 'miss', upstreamHealth: 'healthy', 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 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 neutralProbe = makeProductionInterpreter({
+        sleep: sleep0, breakers: flyaiBreakers, now,
+        handlers: { FLYAI_SEARCH: async () => ({ ok: false, verdict: 'error', upstreamHealth: 'unknown', retryable: false, evidence: 'unknown business failure' }) },
+    });
+    const neutralProbeOutcome = await neutralProbe({ effect: 'FLYAI_SEARCH', params: q });
+    assert.equal(neutralProbeOutcome.trace.breaker, 'half-open', 'neutral probe cannot claim upstream recovery');
+    const ipOk = makeProductionInterpreter({
+        sleep: sleep0, breakers: flyaiBreakers, now, // 复用同一断路器 Map——状态在 Map 里存活
+        handlers: { FLYAI_SEARCH: async () => ({ ok: true, via: 'flyai', verdict: 'miss', upstreamHealth: 'healthy', 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);
+    assert.equal(itp6.result.verdict, 'miss', 'valid empty response recovers the breaker without inventing inventory');
+    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' };
+    });
+    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' }),
         },
-        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 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 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} 成功单次执行`);
+    });
+    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 六渠道入表,纯离线)');
 }
-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)`);
+finally {
+    for (const [name, value] of Object.entries(originalFlyaiEnv)) {
+        if (value === undefined)
+            delete process.env[name];
+        else
+            process.env[name] = value;
+    }
+    await rm(flyaiTestHome, { recursive: true, force: true });
 }
-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 六渠道入表,纯离线)');