fix(trigger): 收 codex #776 四轮 2 P1（requestHash 全量绑定 + 布尔 scope-gate 严格化）

前 6 crash-atomicity blocker 已 held；四轮发现 2 个新 surface P1：

A. requestHash 只 hash model/reasoningEffort/suppressFinalOutput，但 prompt 由整个
   req.options+source+envelope+instruction+presentation 渲染。options.status
   firing→resolved（及 dedupKey 等）改 prompt 不改 hash → 同键静默复用而非文档承诺的 409
   （codex 实测 prompt differs=true hash same=true）。修：requestHash 覆盖 instruction/
   envelope/source/presentation + **整个 options 去掉 idempotencyKey**（key 是查找键非
   payload；无 daemon 生成 id 混入，跨重试稳定）。

B. boolean scope-gate 与运行时不一致：validator 用 ===true 派生 async/wait，
   triggerSessionTurn 用 truthiness。asyncReturnSessionId:true + waitForFinalOutput:"false"
   过 validator 却进 wait 分支 → fork 但不过 reserved→attempting barrier → lease 留 reserved
   → boot reconcile 当「从未派发」删 → 同键重试真跑第二遍（at-most-once 洞）。修：validator
   严格校验 dryRun/waitForFinalOutput/asyncReturnSessionId 必须 boolean 类型，非布尔 400。

测试：trigger-api 新增非布尔 flag 拒绝（"false"/1/0/"yes" 六格）；e2e 新增「同 key 同
instruction 异 options.status → 409」（证 hash 覆盖全 options）。build 绿；affected+shared
8 套件 190/190 绿。普通 trigger/webhook 零行为变化。

Co-Authored-By: Claude <noreply@anthropic.com>

Author: deepcoldy

src/core/trigger-session.ts

@@ -512,20 +512,23 @@ export async function triggerSessionTurn(
   // "session exists → reuse" map: a turn that crashed before/mid dispatch must
   // resolve to a terminal state, never silently re-run or hang `running`.
   const idempotencyKey = req.options?.idempotencyKey?.trim();
-  // requestHash binds the key to its business payload — a same-key retry with a
-  // different payload is a caller bug (409), not a silent join. Exclude the key
-  // itself and daemon-generated ids (session/chat); include what drives execution.
+  // requestHash binds the key to its full business payload — a same-key retry
+  // with a DIFFERENT payload is a caller bug (409), not a silent join. It must
+  // cover everything that renders into the prompt / drives execution:
+  // instruction, envelope, source, presentation, and the WHOLE options object
+  // EXCEPT the idempotencyKey itself (that's the lookup key, not payload). Hashing
+  // only a hand-picked subset (model/effort/suppress) silently reused a turn when
+  // e.g. options.status firing→resolved changed the prompt but not the hash
+  // (codex #776 round-4). No daemon-generated ids (session/chat/triggerId) are in
+  // these inputs, so the hash is stable across retries.
+  const { idempotencyKey: _omitKey, ...optionsForHash } = (req.options ?? {}) as Record<string, unknown>;
   const requestHash = idempotencyKey
     ? computeInputHash({
         instruction: req.instruction ?? null,
         envelope: req.envelope,
         source: req.source,
         presentation: req.presentation ?? null,
-        options: {
-          model: req.options?.model ?? null,
-          reasoningEffort: req.options?.reasoningEffort ?? null,
-          suppressFinalOutput: req.options?.suppressFinalOutput ?? null,
-        },
+        options: optionsForHash,
       })
     : '';
   const ownerBootId = getDaemonBootId();

src/services/trigger-types.ts

@@ -174,6 +174,17 @@ export function validateTriggerRequest(raw: unknown): { ok: true; request: Trigg
     return { ok: false, status: 400, body: { ok: false, errorCode: 'target_required', error: 'target.kind must be turn or workflow' } };
   }
   const options = isRecord(raw.options) ? raw.options : {};
+  // Strict boolean typing for the mode/gate flags. The validator derives these
+  // with `=== true` but triggerSessionTurn consumes some with truthiness; a
+  // non-boolean (e.g. "false" / 1) would pass a scope gate here yet take a
+  // different runtime branch — which, for an idempotency turn, could skip the
+  // reserved→attempting barrier and break at-most-once. Reject non-booleans so
+  // the two layers can never diverge (codex #776 round-4).
+  for (const flag of ['waitForFinalOutput', 'asyncReturnSessionId', 'dryRun'] as const) {
+    if (options[flag] !== undefined && typeof options[flag] !== 'boolean') {
+      return { ok: false, status: 400, body: { ok: false, errorCode: 'bad_request', error: `options.${flag} must be a boolean` } };
+    }
+  }
   const waitForFinalOutput = options.waitForFinalOutput === true;
   const asyncReturnSessionId = options.asyncReturnSessionId === true;
   const hasChatId = typeof target.chatId === 'string' && target.chatId.trim().length > 0;

test/trigger-api.test.ts

@@ -201,6 +201,25 @@ describe('trigger request contract', () => {
     expect(validateTriggerRequest(req).ok).toBe(true);
   });
 
+  it('rejects non-boolean mode/gate flags (prevents validator/runtime scope divergence)', () => {
+    // codex #776 round-4: a non-boolean waitForFinalOutput/asyncReturnSessionId/
+    // dryRun would pass the `=== true` scope gate yet flip a truthiness branch at
+    // runtime — for an idempotency turn that skips the reserved→attempting barrier
+    // and breaks at-most-once. Must 400.
+    for (const [flag, val] of [
+      ['waitForFinalOutput', 'false'], ['waitForFinalOutput', 1],
+      ['asyncReturnSessionId', 'true'], ['asyncReturnSessionId', 0],
+      ['dryRun', 'false'], ['dryRun', 'yes'],
+    ] as Array<[string, unknown]>) {
+      const req = request();
+      req.target = { kind: 'turn', botId: 'app1' };
+      (req.options as any) = { [flag]: val };
+      const v = validateTriggerRequest(req);
+      expect(v.ok).toBe(false);
+      if (!v.ok) expect(v.body.errorCode).toBe('bad_request');
+    }
+  });
+
   it('builds a prompt that labels event data as untrusted', () => {
     const prompt = buildUntrustedEventPrompt(request(), 'trg_1');
     expect(prompt).toContain('untrusted event data');

test/trigger-session-idempotency-e2e.test.ts

@@ -138,6 +138,18 @@ describe('triggerSessionTurn — idempotency dispatch (real stores)', () => {
     expect(mockForkWorker).toHaveBeenCalledTimes(1);
   });
 
+  it('same key, same instruction, but DIFFERENT options.status → 409 (requestHash covers full options)', async () => {
+    // codex #776 round-4: status firing→resolved changes the rendered prompt; the
+    // hash must change too, else the resolved event silently reuses the firing turn.
+    const firing: TriggerRequest = { ...freshAsyncReq('k-status'), options: { asyncReturnSessionId: true, idempotencyKey: 'k-status', status: 'firing' } };
+    const resolved: TriggerRequest = { ...freshAsyncReq('k-status'), options: { asyncReturnSessionId: true, idempotencyKey: 'k-status', status: 'resolved' } };
+    await triggerSessionTurn(firing, { larkAppId: APP, activeSessions: new Map() });
+    const res = await triggerSessionTurn(resolved, { larkAppId: APP, activeSessions: new Map() });
+    expect(res.ok).toBe(false);
+    expect(res.errorCode).toBe('idempotency_conflict');
+    expect(mockForkWorker).toHaveBeenCalledTimes(1);
+  });
+
   it('fork throw AFTER the barrier → durable async failed(dispatch_unknown) + close, retry does NOT re-run', async () => {
     forkShouldThrow = true;
     const res = await triggerSessionTurn(freshAsyncReq('k-4'), { larkAppId: APP, activeSessions: new Map() });