switchroom 0.13.33 → 0.13.36

package/telegram-plugin/tests/silent-end-interrupt-stop-scan.test.ts

@@ -0,0 +1,314 @@
+/**
+ * Regression guard for #1775 — the deterministic transcript-scan
+ * replacement of the silent-end Stop hook's signal source.
+ *
+ * Pre-fix the hook depended on a gateway-written state file as the
+ * block/allow signal. The state file was always written ~175ms AFTER
+ * the hook fired (live evidence on clerk 2026-05-25, 12 correlated
+ * samples), so the hook never saw its own turn's signal.
+ *
+ * Post-fix the hook reads `transcript_path` directly and scans the
+ * just-finished turn's tool_use entries for a qualifying reply. This
+ * test suite pins every branch of the new scan logic — the helper is
+ * a pure function (`scanTurnForFinalReply`), so we exercise it with
+ * synthetic JSONL fixtures rather than spawning the .mjs subprocess.
+ *
+ * Each fixture mimics the shapes the live Claude Code transcripts
+ * use (verified against clerk's
+ * `/state/agent/.claude/projects/.../{session}.jsonl` 2026-05-25).
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  scanTurnForFinalReply,
+  isFinalAnswerReply,
+} from '../hooks/silent-end-scan.mjs'
+
+// ── Fixture builders ────────────────────────────────────────────────
+
+const ENQUEUE = JSON.stringify({
+  type: 'queue-operation',
+  operation: 'enqueue',
+  content: '<channel source="switchroom-telegram" chat_id="111" message_id="42">hi</channel>',
+})
+
+function assistantToolUse(name: string, input: Record<string, unknown>, opts: { isSidechain?: boolean } = {}) {
+  const base = {
+    type: 'assistant',
+    message: { content: [{ type: 'tool_use', name, input }] },
+  }
+  if (opts.isSidechain) (base as Record<string, unknown>).isSidechain = true
+  return JSON.stringify(base)
+}
+
+function assistantText(text: string) {
+  return JSON.stringify({
+    type: 'assistant',
+    message: { content: [{ type: 'text', text }] },
+  })
+}
+
+function jsonl(...lines: string[]) {
+  return lines.join('\n')
+}
+
+// ── isFinalAnswerReply parity with TS ───────────────────────────────
+
+describe('isFinalAnswerReply (parity with final-answer-detect.ts)', () => {
+  it('done:true → final answer regardless of length/notification', () => {
+    expect(isFinalAnswerReply({ text: '', disableNotification: true, done: true })).toBe(true)
+  })
+
+  it('disable_notification:false → final answer (the notification-bearing case)', () => {
+    expect(isFinalAnswerReply({ text: 'ok', disableNotification: false })).toBe(true)
+  })
+
+  it('length ≥ 200 + disable_notification:true → final answer (substantive backstop)', () => {
+    expect(isFinalAnswerReply({ text: 'a'.repeat(200), disableNotification: true })).toBe(true)
+  })
+
+  it('length 199 + disable_notification:true → interim ack', () => {
+    expect(isFinalAnswerReply({ text: 'a'.repeat(199), disableNotification: true })).toBe(false)
+  })
+})
+
+// ── scanTurnForFinalReply branches ──────────────────────────────────
+
+describe('scanTurnForFinalReply — turn-start anchor', () => {
+  it('empty transcript → unknown (caller must fail-open)', () => {
+    const r = scanTurnForFinalReply('')
+    expect(r.decided).toBe('unknown')
+  })
+
+  it('no enqueue line in transcript → unknown', () => {
+    const text = jsonl(
+      assistantText('hello'),
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'ok', disable_notification: false }),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('unknown')
+    expect(r.reason).toBe('no-turn-start')
+  })
+
+  it('multiple enqueues → anchors on the LAST one (queued mid-turn semantics)', () => {
+    // First inbound got a long reply BEFORE the second inbound was
+    // queued. Scanning anchors on the last enqueue, so the early
+    // long reply does NOT count.
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', {
+        text: 'a'.repeat(500),
+        disable_notification: false,
+      }),
+      ENQUEUE, // second queued inbound
+      assistantToolUse('mcp__switchroom-telegram__reply', {
+        text: 'ack',
+        disable_notification: true,
+      }),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+  })
+})
+
+describe('scanTurnForFinalReply — final-reply detection', () => {
+  it('Ken-2026-05-25 repro: ack + plain text answer → block', () => {
+    // The exact shape from clerk's msg 12227 slip.
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', {
+        text: "On it — checking the Bloomfield statement, then I'll lay out…",
+        disable_notification: true,
+      }),
+      assistantToolUse('Bash', { command: 'ls' }),
+      assistantToolUse('Read', { file_path: '/tmp/x' }),
+      assistantText('That was actually your FY25 NOA, not Bloomfield. ' + 'A'.repeat(2200)),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.reason).toBe('no-final-reply')
+  })
+
+  it('notification-bearing reply → allow', () => {
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'ok', disable_notification: false }),
+    )
+    expect(scanTurnForFinalReply(text).decided).toBe('allow')
+  })
+
+  it('stream_reply done:true → allow even with empty text', () => {
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__stream_reply', {
+        text: '',
+        done: true,
+        disable_notification: true,
+      }),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('allow')
+    expect(r.reason).toBe('final-reply')
+  })
+
+  it('long reply mis-marked disable_notification:true → still allow (≥200 chars backstop)', () => {
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', {
+        text: 'B'.repeat(500),
+        disable_notification: true,
+      }),
+    )
+    expect(scanTurnForFinalReply(text).decided).toBe('allow')
+  })
+
+  it('short ack followed by long reply → allow (later qualifies)', () => {
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'on it', disable_notification: true }),
+      assistantToolUse('Bash', { command: 'ls' }),
+      assistantToolUse('mcp__switchroom-telegram__reply', {
+        text: 'Here is the full answer with notification ' + 'C'.repeat(500),
+        disable_notification: false,
+      }),
+    )
+    expect(scanTurnForFinalReply(text).decided).toBe('allow')
+  })
+})
+
+describe('scanTurnForFinalReply — silent-marker carve-out', () => {
+  it('NO_REPLY → allow', () => {
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'NO_REPLY' }),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('allow')
+    expect(r.reason).toBe('silent-marker')
+  })
+
+  it('NO_REPLY with trailing punctuation → allow (matches gateway tolerance)', () => {
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'NO_REPLY.' }),
+    )
+    expect(scanTurnForFinalReply(text).decided).toBe('allow')
+  })
+
+  it('lowercase no_reply → allow (case-insensitive)', () => {
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'no_reply' }),
+    )
+    expect(scanTurnForFinalReply(text).decided).toBe('allow')
+  })
+
+  it('HEARTBEAT_OK → allow (cron-silence carve-out)', () => {
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'HEARTBEAT_OK' }),
+    )
+    expect(scanTurnForFinalReply(text).decided).toBe('allow')
+  })
+})
+
+describe('scanTurnForFinalReply — non-reply tool_use does NOT satisfy', () => {
+  it('Bash + Read + Agent(sub-agent dispatch) without reply → block', () => {
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('Bash', { command: 'ls' }),
+      assistantToolUse('Read', { file_path: '/tmp/x' }),
+      assistantToolUse('Agent', { description: 'sub-agent' }),
+      assistantText('done thinking, but never called reply'),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+  })
+
+  it('isSidechain:true sub-agent reply does NOT count for parent', () => {
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse(
+        'mcp__switchroom-telegram__reply',
+        { text: 'sub-agent answer', disable_notification: false },
+        { isSidechain: true },
+      ),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.reason).toBe('no-final-reply')
+  })
+})
+
+describe('scanTurnForFinalReply — envelope-derived turnKey (block result)', () => {
+  it('block carries turnKey/chatId/threadId parsed from the enqueue envelope', () => {
+    const enq = JSON.stringify({
+      type: 'queue-operation',
+      operation: 'enqueue',
+      content: '<channel source="switchroom-telegram" chat_id="abc" message_thread_id="42" message_id="9">hi</channel>',
+    })
+    const text = jsonl(
+      enq,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'ack', disable_notification: true }),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.chatId).toBe('abc')
+    expect(r.threadId).toBe(42)
+    expect(r.turnKey).toBe('abc:42')
+  })
+
+  it("DM (no message_thread_id) → turnKey uses '_' sentinel matching chatKey()", () => {
+    // chatKey() at telegram-plugin/gateway/chat-key.ts:46 returns
+    // `${chatId}:_` when threadId is missing/0. This must match.
+    const r = scanTurnForFinalReply(
+      jsonl(ENQUEUE, assistantToolUse('mcp__switchroom-telegram__reply', { text: 'ack', disable_notification: true })),
+    )
+    expect(r.decided).toBe('block')
+    expect(r.turnKey).toBe('111:_')
+    expect(r.chatId).toBe('111')
+    expect(r.threadId).toBeNull()
+  })
+
+  it('allow result does NOT need turnKey (only block path writes the state file)', () => {
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'ok', disable_notification: false }),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('allow')
+    expect(r.turnKey).toBeUndefined()
+  })
+})
+
+describe('scanTurnForFinalReply — malformed input tolerance', () => {
+  it('malformed JSON lines interleaved → skipped, decision matches the well-formed ones', () => {
+    const text = jsonl(
+      'this is not json',
+      '{partial',
+      ENQUEUE,
+      'another bad line',
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'ok', disable_notification: false }),
+    )
+    expect(scanTurnForFinalReply(text).decided).toBe('allow')
+  })
+
+  it('lines starting with non-`{` → skipped quickly (perf guard)', () => {
+    const text = jsonl(
+      '# this is a comment',
+      'random plaintext',
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'NO_REPLY' }),
+    )
+    expect(scanTurnForFinalReply(text).decided).toBe('allow')
+  })
+
+  it('assistant line with non-array content is tolerated → no crash', () => {
+    const text = jsonl(
+      ENQUEUE,
+      JSON.stringify({ type: 'assistant', message: { content: null } }),
+      JSON.stringify({ type: 'assistant', message: { content: 'a string somehow' } }),
+    )
+    expect(scanTurnForFinalReply(text).decided).toBe('block')
+  })
+})

package/telegram-plugin/tests/silent-end.test.ts

@@ -301,7 +301,123 @@ describe('recordUndeliveredTurnEnd — #1664 extended trigger', () => {
   })
 })
 
-describe('silent-end-interrupt-stop hook — integration', () => {
+describe('#1741 — ack reply must not clear silent-end state', () => {
+  // The gateway gates `clearSilentEndState` at the reply send-site on
+  // `isFinalAnswerReply`. These tests reproduce that gate as a unit:
+  // simulate a turn's reply sequence by calling the same predicate the
+  // gateway uses, and assert state-file persistence matches the contract.
+  //
+  // Why this matters: if `turn_end` never lands (Claude Code's
+  // `turn_duration` system event is unreliable for trivial-prompt
+  // turns), the only line of defence between an undelivered turn and
+  // the Stop hook is the persistence of `silent-end-pending.json`.
+  // Pre-fix, an ack reply cleared the file unconditionally — so the
+  // Stop hook found no state and allowed the stop on every ack-then-
+  // tool-then-silent shape. Post-fix, only a plausibly-final reply
+  // clears it.
+
+  function simulateReplyAtGateway(
+    reply: { text: string; disableNotification: boolean; done?: boolean },
+    turnKey: string,
+  ): void {
+    // The gateway calls clearSilentEndState ONLY when isFinalAnswerReply
+    // is true. Mirror that gate exactly.
+    if (isFinalAnswerReply(reply)) {
+      clearSilentEndState(turnKey)
+    }
+  }
+
+  it('ack reply (disable_notification, short, no done) does NOT clear pending state', () => {
+    // A prior turn-end already wrote state (or a re-prompt round wrote it).
+    writeSilentEndState({ chatId: 'c', threadId: null, turnKey: 'c:_' })
+    // Agent sends an interim ack.
+    simulateReplyAtGateway(
+      { text: 'On it', disableNotification: true },
+      'c:_',
+    )
+    // State must persist — the Stop hook still needs to be able to
+    // catch a subsequent silent end.
+    expect(readSilentEndState()).not.toBeNull()
+    expect(readSilentEndState()!.turnKey).toBe('c:_')
+  })
+
+  it('final-answer reply (disable_notification=false) clears the state', () => {
+    writeSilentEndState({ chatId: 'c', threadId: null, turnKey: 'c:_' })
+    simulateReplyAtGateway(
+      { text: "Done — here's the result.", disableNotification: false },
+      'c:_',
+    )
+    expect(readSilentEndState()).toBeNull()
+  })
+
+  it('stream_reply done=true clears the state even with disable_notification=true', () => {
+    writeSilentEndState({ chatId: 'c', threadId: null, turnKey: 'c:_' })
+    simulateReplyAtGateway(
+      { text: 'ok', disableNotification: true, done: true },
+      'c:_',
+    )
+    expect(readSilentEndState()).toBeNull()
+  })
+
+  it('long ack-shaped reply (>=200 chars) is treated as final and clears the state', () => {
+    writeSilentEndState({ chatId: 'c', threadId: null, turnKey: 'c:_' })
+    simulateReplyAtGateway(
+      { text: 'x'.repeat(250), disableNotification: true },
+      'c:_',
+    )
+    expect(readSilentEndState()).toBeNull()
+  })
+
+  it('ack-then-silent end-to-end: ack does not clear, Stop hook still blocks', () => {
+    // 1. The previous undelivered turn-end wrote state, OR the turn
+    //    starts fresh and only the Stop hook will see this state file
+    //    once the gateway re-writes it. Simulate the gateway's writer
+    //    firing at turn-end with finalAnswerDelivered=false (no
+    //    qualifying reply happened this turn).
+    writeSilentEndState({ chatId: 'c', threadId: null, turnKey: 'c:_' })
+    // 2. Mid-turn ack reply lands. Pre-fix this would unlink the
+    //    state file; post-fix it must persist.
+    simulateReplyAtGateway(
+      { text: 'On it, working on it…', disableNotification: true },
+      'c:_',
+    )
+    // 3. Stop hook fires (separately tested below): it must still
+    //    find the state file and decide to block. Verify the file is
+    //    intact at the path the hook reads.
+    const state = readSilentEndState()
+    expect(state).not.toBeNull()
+    expect(state!.turnKey).toBe('c:_')
+  })
+
+  it('ack-then-final: ack does not clear, final clears', () => {
+    writeSilentEndState({ chatId: 'c', threadId: null, turnKey: 'c:_' })
+    // Interim ack — state persists.
+    simulateReplyAtGateway(
+      { text: 'On it', disableNotification: true },
+      'c:_',
+    )
+    expect(readSilentEndState()).not.toBeNull()
+    // Final answer — state cleared.
+    simulateReplyAtGateway(
+      { text: 'Done — the answer is 42.', disableNotification: false },
+      'c:_',
+    )
+    expect(readSilentEndState()).toBeNull()
+  })
+})
+
+describe('silent-end-interrupt-stop hook — integration (#1775: transcript-scan signal)', () => {
+  // Post-#1775 the hook's BLOCK/ALLOW signal is derived from the
+  // transcript file, not the state file. The state file remains for
+  // retry-count bookkeeping only. These tests pin the new contract.
+  //
+  // The race the new contract closes: pre-fix the hook read the
+  // state file as its signal, but the gateway wrote that file
+  // ~175ms AFTER the hook fired (race lost every time). Now the
+  // hook reads `transcript_path` directly — Claude Code flushes
+  // assistant content before firing Stop hooks, so the read is
+  // race-free.
+
   const hookPath = join(__dirname, '..', 'hooks', 'silent-end-interrupt-stop.mjs')
 
   function runHook(input: object): { exit: number; stdout: string; stderr: string } {
@@ -315,75 +431,148 @@ describe('silent-end-interrupt-stop hook — integration', () => {
     return { exit: r.status ?? 1, stdout: r.stdout ?? '', stderr: r.stderr ?? '' }
   }
 
-  it('allows the stop when no state file exists (normal completion)', () => {
-    const r = runHook({
-      session_id: 's',
-      transcript_path: '/tmp/x.jsonl',
-      hook_event_name: 'Stop',
-    })
+  function writeTranscript(lines: object[]): string {
+    const path = join(stateDir, 'transcript.jsonl')
+    mkdirSync(stateDir, { recursive: true })
+    writeFileSync(path, lines.map(l => JSON.stringify(l)).join('\n'), 'utf8')
+    return path
+  }
+
+  const ENQUEUE = {
+    type: 'queue-operation',
+    operation: 'enqueue',
+    content: '<channel source="switchroom-telegram" chat_id="c">hi</channel>',
+  }
+
+  function replyToolUse(text: string, opts: { disable_notification?: boolean; done?: boolean } = {}) {
+    return {
+      type: 'assistant',
+      message: {
+        content: [
+          { type: 'tool_use', name: 'mcp__switchroom-telegram__reply', input: { text, ...opts } },
+        ],
+      },
+    }
+  }
+
+  it('allows the stop when transcript_path is missing from the event (fail-open)', () => {
+    // Pre-#1775 this branch was "no state file → allow". Post-fix
+    // the same outcome holds via the fail-open transcript guard.
+    const r = runHook({ session_id: 's', hook_event_name: 'Stop' })
     expect(r.exit).toBe(0)
     expect(r.stdout.trim()).toBe('')
   })
 
-  it('blocks the stop with decision:block when silent-end state exists at retryCount=0', () => {
-    writeSilentEndState({ chatId: 'c', threadId: null, turnKey: 'c:_' })
-    const r = runHook({
-      session_id: 's',
-      transcript_path: '/tmp/x.jsonl',
-      hook_event_name: 'Stop',
-    })
+  it('blocks the stop when transcript shows ack-only (no final reply) — Ken-2026-05-25 repro', () => {
+    const transcript = writeTranscript([
+      ENQUEUE,
+      replyToolUse('on it — checking now', { disable_notification: true }),
+      { type: 'assistant', message: { content: [{ type: 'tool_use', name: 'Bash', input: {} }] } },
+      { type: 'assistant', message: { content: [{ type: 'text', text: 'A'.repeat(2237) }] } },
+    ])
+    const r = runHook({ session_id: 's', transcript_path: transcript, hook_event_name: 'Stop' })
     expect(r.exit).toBe(0)
     const out = JSON.parse(r.stdout.trim())
     expect(out.decision).toBe('block')
     expect(out.reason).toContain('reply')
-    // #1664 — the re-prompt must offer the NO_REPLY escape hatch so a
-    // model that already delivered (or intentionally has nothing to add)
-    // can end the turn cleanly instead of being forced to re-send.
+    // #1664 — the re-prompt must offer the NO_REPLY escape hatch.
     expect(out.reason).toContain('NO_REPLY')
-    // retryCount must have been incremented to 1
+    // retryCount incremented to 1 (the budget bookkeeping still
+    // uses the state file).
     expect(readSilentEndState()!.retryCount).toBe(1)
   })
 
-  it('allows the stop when retryCount >= MAX_RETRIES (1)', () => {
+  it('allows the stop when retryCount >= MAX_RETRIES (1), even if transcript still shows no reply', () => {
+    // Retry already spent — gateway will post the user-facing
+    // fallback so the user isn't left silent.
     const path = join(stateDir, 'silent-end-pending.json')
+    mkdirSync(stateDir, { recursive: true })
     writeFileSync(path, JSON.stringify({
       chatId: 'c', threadId: null, turnKey: 'c:_', retryCount: 1, timestamp: 0,
     }))
-    const r = runHook({
-      session_id: 's',
-      transcript_path: '/tmp/x.jsonl',
-      hook_event_name: 'Stop',
-    })
+    const transcript = writeTranscript([
+      ENQUEUE,
+      replyToolUse('still just an ack', { disable_notification: true }),
+    ])
+    const r = runHook({ session_id: 's', transcript_path: transcript, hook_event_name: 'Stop' })
     expect(r.exit).toBe(0)
     expect(r.stdout.trim()).toBe('')
     expect(r.stderr).toContain('retry exhausted')
   })
 
-  it('end-to-end: write silent-end → hook blocks → simulate reply → next stop allows', () => {
-    // 1. Turn ends silently — gateway writes state
-    writeSilentEndState({ chatId: 'c', threadId: null, turnKey: 'c:_' })
+  it('allows the stop when transcript shows a notification-bearing reply (no state needed)', () => {
+    // Pre-#1775 this scenario depended on the gateway having
+    // already cleared the state file (race-prone). Post-fix the
+    // transcript scan finds the qualifying reply directly.
+    const transcript = writeTranscript([
+      ENQUEUE,
+      replyToolUse('here is the answer', { disable_notification: false }),
+    ])
+    const r = runHook({ session_id: 's', transcript_path: transcript, hook_event_name: 'Stop' })
+    expect(r.exit).toBe(0)
+    expect(r.stdout.trim()).toBe('')
+    // No state file written (nothing to bookkeep — no block).
+    expect(readSilentEndState()).toBeNull()
+  })
 
-    // 2. Stop hook fires, blocks, increments retryCount
-    const r1 = runHook({ session_id: 's', transcript_path: '/tmp/x.jsonl', hook_event_name: 'Stop' })
+  it('end-to-end: silent turn → hook blocks → re-prompt delivers → next stop allows', () => {
+    // The contract for the HOOK's stdout decision — independent of
+    // gateway state-file lifecycle. Gateway's clear happens via
+    // recordSilentTurnEnd / clearSilentEndState; this test only
+    // exercises the hook's decision based on the transcript that's
+    // on disk at hook-time.
+
+    // 1. Turn first-stop with ack-only transcript → block + retryCount→1.
+    const transcriptAck = writeTranscript([
+      ENQUEUE,
+      replyToolUse('ack', { disable_notification: true }),
+    ])
+    const r1 = runHook({ session_id: 's', transcript_path: transcriptAck, hook_event_name: 'Stop' })
     expect(JSON.parse(r1.stdout).decision).toBe('block')
     expect(readSilentEndState()!.retryCount).toBe(1)
 
-    // 3. Re-prompted agent calls reply — gateway clears the file
-    clearSilentEndState('c:_')
-    expect(readSilentEndState()).toBeNull()
-
-    // 4. Next Stop allows cleanly (no state file)
-    const r2 = runHook({ session_id: 's', transcript_path: '/tmp/x.jsonl', hook_event_name: 'Stop' })
+    // 2. Model retried within the same turn — transcript now has the
+    //    final reply appended. The hook scans transcript at its next
+    //    fire and finds the qualifying reply.
+    const transcriptFinal = writeTranscript([
+      ENQUEUE,
+      replyToolUse('ack', { disable_notification: true }),
+      replyToolUse('here is the actual answer', { disable_notification: false }),
+    ])
+    const r2 = runHook({ session_id: 's', transcript_path: transcriptFinal, hook_event_name: 'Stop' })
     expect(r2.stdout.trim()).toBe('')
+    // State file still present (retryCount=1) — gateway's
+    // clearSilentEndState path (post-finalAnswerDelivered) is what
+    // clears it; the hook doesn't manage that.
   })
 
-  it('fails open on a corrupt state file', () => {
+  it('NO_REPLY silent-marker in transcript → allow stop even without final reply', () => {
+    const transcript = writeTranscript([
+      ENQUEUE,
+      replyToolUse('NO_REPLY'),
+    ])
+    const r = runHook({ session_id: 's', transcript_path: transcript, hook_event_name: 'Stop' })
+    expect(r.exit).toBe(0)
+    expect(r.stdout.trim()).toBe('')
+  })
+
+  it('fails open on a corrupt state file (when block would otherwise fire)', () => {
+    // Transcript shows ack-only (would block), but state file is
+    // corrupt. The hook treats the state file as fresh (retryCount=0)
+    // and proceeds to block + write a fresh state file. This is the
+    // safe behavior — corrupt state shouldn't cause perpetual stop.
+    const transcript = writeTranscript([
+      ENQUEUE,
+      replyToolUse('ack', { disable_notification: true }),
+    ])
     const path = join(stateDir, 'silent-end-pending.json')
     mkdirSync(stateDir, { recursive: true })
     writeFileSync(path, 'corrupt {{{', 'utf8')
-    const r = runHook({ session_id: 's', transcript_path: '/tmp/x.jsonl', hook_event_name: 'Stop' })
+    const r = runHook({ session_id: 's', transcript_path: transcript, hook_event_name: 'Stop' })
     expect(r.exit).toBe(0)
-    expect(r.stdout.trim()).toBe('')
+    // Decision is block (transcript says block, state is treated as fresh).
+    expect(JSON.parse(r.stdout.trim()).decision).toBe('block')
+    expect(readSilentEndState()!.retryCount).toBe(1)
   })
 
   it('fails open on empty stdin', () => {