@raidiant/notifai 0.3.0 → 0.5.0

package/src/hooks.test.ts

@@ -1,34 +1,56 @@
+import { spawn, type ChildProcess } from 'node:child_process'
 import {
+  existsSync,
   mkdirSync,
   mkdtempSync,
   readFileSync,
   readdirSync,
   realpathSync,
+  rmSync,
   symlinkSync,
   utimesSync,
   writeFileSync,
 } from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
+import { PassThrough } from 'node:stream'
 import type {
   ListRepliesResponse,
   ReplyView,
   SubmissionReceipt,
   SubmitNotificationRequestT,
 } from '@raidiant/notifai-protocol'
-import { describe, expect, it } from 'vitest'
-import type { ApiClient } from './client.js'
-import { EXIT, askCommand, hookRunCommand, type CommandDeps, type CommandIo } from './commands.js'
-import { loadConfig, projectSessionPointerPath, sanitizeSessionId } from './config.js'
+import { describe, expect, it, vi } from 'vitest'
+import { ApiCallError, type ApiClient } from './client.js'
+import { CLAUDE_POST_SEND_LIVENESS_MS, type ClaudeWakeAdapters } from './claude-wake.js'
+import type { CodexWakeAdapters, CodexWakeObservation } from './codex-wake.js'
+import { readStdinWithTimeout } from './hook-input.js'
+import {
+  activeLogPath,
+  bootstrapLogger,
+  createLogger,
+  readLogRecords,
+  type LogRecord,
+} from './logging.js'
+import { EXIT, askCommand, buildQuestions, hookRunCommand, type CommandDeps, type CommandIo } from './commands.js'
+import {
+  loadConfig,
+  projectSessionPointerPath,
+  sanitizeSessionId,
+  sessionConfigPath,
+  stateDir,
+} from './config.js'
 import {
   claimQuestionPush,
   clearSessionState,
   drainRetirements,
   drainOrphanRetirements,
-  isUserAway,
+  runEscalationWaiter,
+  MAX_CONTINUATION_COUNT,
   orphanRetirements,
   pruneAbandonedSessions,
   releaseQuestionPush,
+  readMatchingProjectSessionPointer,
   readProjectSession,
   readSessionState,
   registerQuestion,
@@ -55,15 +77,31 @@ interface Recorder {
   submitted: SubmitNotificationRequestT[]
   /** `submitted[i]`'s request id, so a test can name what it just sent. */
   receipts: string[]
+  /** Stable test aliases survive the fresh client created for each hook. */
+  aliases: Map<string, number>
   closed: string[]
   /** Simulates an offline machine; retirement has to survive one. */
   failSubmits?: boolean
   /** Runs while an agent_question submit is in flight, before onSubmitted. */
   beforeQuestionSubmit?: () => void
+  /** Lets race tests hold every replies call until all contenders are polling. */
+  beforeReplies?: () => Promise<void>
+  /** Per-request answer stream for multi-question ownership tests. */
+  repliesFor?: (requestId: string) => ReplyView[]
 }
 
 function fakeClient(recorder: Recorder, replies: ReplyView[]): ApiClient {
   let submissions = 0
+  const recordedReplies = (requestId: string): ReplyView[] => {
+    const direct = recorder.repliesFor?.(requestId)
+    if (direct !== undefined && direct.length > 0) return direct
+    const ordinal = recorder.aliases.get(requestId)
+    if (ordinal !== undefined) {
+      const legacyAlias = recorder.repliesFor?.(`req_hook_${ordinal}`)
+      if (legacyAlias !== undefined) return legacyAlias
+    }
+    return direct ?? replies
+  }
   return {
     beginPairing: notUsed,
     pollPairing: notUsed,
@@ -98,19 +136,33 @@ function fakeClient(recorder: Recorder, replies: ReplyView[]): ApiClient {
       if (body.draft.event === 'agent_question') recorder.beforeQuestionSubmit?.()
       recorder.submitted.push(body)
       submissions += 1
-      recorder.receipts.push(`req_hook_${submissions}`)
+      const requestId = body.request_id ?? `req_hook_${submissions}`
+      recorder.aliases.set(requestId, recorder.receipts.length + 1)
+      recorder.receipts.push(requestId)
       return {
-        request_id: `req_hook_${submissions}`,
+        request_id: requestId,
+        reply_expires_at: new Date(NOW + 480_000).toISOString(),
         replayed: false,
         overall: 'provider_accepted_all',
         deliveries: [],
         warnings: [],
       } satisfies SubmissionReceipt
     },
-    replies: async (requestId) =>
-      ({ request_id: requestId, reply_expires_at: null, replies }) satisfies ListRepliesResponse,
+    replies: async (requestId) => {
+      await recorder.beforeReplies?.()
+      return ({
+        request_id: requestId,
+        reply_expires_at: null,
+        replies: recordedReplies(requestId),
+      }) satisfies ListRepliesResponse
+    },
     closeReplies: async (requestId) => {
       recorder.closed.push(requestId)
+      return {
+        request_id: requestId,
+        reply_expires_at: new Date(NOW).toISOString(),
+        replies: recordedReplies(requestId),
+      } satisfies ListRepliesResponse
     },
   } as ApiClient
 }
@@ -139,23 +191,19 @@ interface Harness {
   io: CapturedIo
   recorder: Recorder
   env: NodeJS.ProcessEnv
+  advanceClock(milliseconds: number): void
 }
 
 const NOW = 1_800_000_000_000
 
-/**
- * `idleSeconds` defaults to null — "this machine has no idle source" — so these
- * cases exercise the degraded path and stay independent of whether the person
- * running the suite is touching their own keyboard.
- */
-function harness(replies: ReplyView[] = [], idleSeconds: number | null = null): Harness {
+function harness(replies: ReplyView[] = []): Harness {
   const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-hooks-'))
   const env: NodeJS.ProcessEnv = {
     XDG_CONFIG_HOME: path.join(root, 'config'),
     XDG_STATE_HOME: path.join(root, 'state'),
   }
   const io = new CapturedIo()
-  const recorder: Recorder = { submitted: [], receipts: [], closed: [] }
+  const recorder: Recorder = { submitted: [], receipts: [], closed: [], aliases: new Map() }
   // Virtual clock: sleeps advance it instead of costing wall time. A frozen
   // clock would make the reply poll's deadline unreachable and spin forever.
   let clock = NOW
@@ -163,6 +211,9 @@ function harness(replies: ReplyView[] = [], idleSeconds: number | null = null):
     io,
     recorder,
     env,
+    advanceClock(milliseconds: number) {
+      clock += milliseconds
+    },
     deps: {
       io,
       store: {
@@ -180,7 +231,6 @@ function harness(replies: ReplyView[] = [], idleSeconds: number | null = null):
       cwd: root,
       clientFactory: () => fakeClient(recorder, replies),
       now: () => clock,
-      idleSeconds: () => idleSeconds,
       sleep: async (milliseconds: number) => {
         clock += milliseconds
       },
@@ -192,45 +242,144 @@ function stdin(payload: unknown): () => Promise<string> {
   return async () => JSON.stringify(payload)
 }
 
-/** Long enough ago to be away under the 120s default. */
-const AWAY = NOW - 600_000
-const PRESENT = NOW - 5_000
+async function waitUntil(
+  predicate: () => boolean,
+  timeoutMs: number,
+  failure: string,
+): Promise<void> {
+  const deadline = Date.now() + timeoutMs
+  while (!predicate()) {
+    if (Date.now() >= deadline) throw new Error(failure)
+    await new Promise((resolve) => setTimeout(resolve, 5))
+  }
+}
 
-describe('presence gate', () => {
-  it('treats a never-seen session as present, so a missing hook cannot hijack the terminal', () => {
-    const { env, deps } = harness()
-    const config = loadConfig({ cwd: deps.cwd, env })
-    expect(isUserAway({}, config, NOW, null)).toBe(false)
-  })
+interface SessionEndLogLockHolder {
+  child: ChildProcess
+  readyPath: string
+  releasePath: string
+  done: Promise<void>
+}
 
-  it('is away only once the configured silence has elapsed', () => {
-    const { env, deps } = harness()
-    const config = loadConfig({ cwd: deps.cwd, env })
-    expect(isUserAway({ last_prompt_at: PRESENT }, config, NOW, null)).toBe(false)
-    expect(isUserAway({ last_prompt_at: AWAY }, config, NOW, null)).toBe(true)
+function runSessionEndLogLockHolder(
+  root: string,
+  env: NodeJS.ProcessEnv,
+  lockPath: string,
+): SessionEndLogLockHolder {
+  const readyPath = path.join(root, 'session-end-log-lock-ready')
+  const releasePath = path.join(root, 'session-end-log-lock-release')
+  const vitest = path.join(process.cwd(), 'node_modules', 'vitest', 'vitest.mjs')
+  const child = spawn(
+    process.execPath,
+    [
+      vitest,
+      'run',
+      'src/session-end-log-lock-worker.test.ts',
+      '--reporter=dot',
+      '--maxWorkers=1',
+    ],
+    {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        ...env,
+        NOTIFAI_SESSION_END_LOG_LOCK_WORKER_MODE: 'hold',
+        NOTIFAI_SESSION_END_LOG_LOCK_PATH: lockPath,
+        NOTIFAI_SESSION_END_LOG_LOCK_READY: readyPath,
+        NOTIFAI_SESSION_END_LOG_LOCK_RELEASE: releasePath,
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  )
+  const stdout: Buffer[] = []
+  const stderr: Buffer[] = []
+  child.stdout!.on('data', (chunk: Buffer) => stdout.push(chunk))
+  child.stderr!.on('data', (chunk: Buffer) => stderr.push(chunk))
+  const done = new Promise<void>((resolve, reject) => {
+    child.once('error', reject)
+    child.once('exit', (code) => {
+      if (code === 0) resolve()
+      else {
+        reject(
+          new Error(
+            `SessionEnd log lock worker exited ${String(code)}\n${Buffer.concat(stdout).toString()}\n${Buffer.concat(stderr).toString()}`,
+          ),
+        )
+      }
+    })
   })
+  void done.catch(() => undefined)
+  return { child, readyPath, releasePath, done }
+}
 
-  // The case that motivated this: "run the full test suite", then three
-  // minutes of watching. Elapsed time alone said away; the machine knows better.
-  it('keeps a user who is watching a long turn present, however long the turn ran', () => {
-    const { env, deps } = harness()
-    const config = loadConfig({ cwd: deps.cwd, env })
-    expect(isUserAway({ last_prompt_at: AWAY }, config, NOW, 3)).toBe(false)
-  })
+interface CliProcessResult {
+  code: number | null
+  signal: NodeJS.Signals | null
+  stdout: string
+  stderr: string
+  durationMs: number
+}
 
-  // Found by a live Claude Code session: a spawned agent's session
-  // always has a just-set last_prompt_at, so requiring session silence too meant
-  // its FIRST question could never escalate — the "kick off agents and walk
-  // away" case the feature is for.
-  it('lets a freshly spawned session escalate when the machine says nobody is there', () => {
-    const { env, deps } = harness()
-    const config = loadConfig({ cwd: deps.cwd, env })
-    expect(isUserAway({ last_prompt_at: PRESENT }, config, NOW, 900)).toBe(true)
-    expect(isUserAway({ last_prompt_at: AWAY }, config, NOW, 900)).toBe(true)
+function runSessionEndCli(
+  env: NodeJS.ProcessEnv,
+  cwd: string,
+  sessionId: string,
+): { child: ChildProcess; done: Promise<CliProcessResult> } {
+  const startedAt = Date.now()
+  const child = spawn(
+    process.execPath,
+    [
+      path.join(process.cwd(), 'dist', 'main.js'),
+      'hook',
+      'session-end',
+      '--owner',
+      'notifai',
+      '--harness',
+      'codex',
+    ],
+    {
+      cwd,
+      env: { ...process.env, ...env, NOTIFAI_CREDENTIALS: 'file' },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    },
+  )
+  const stdout: Buffer[] = []
+  const stderr: Buffer[] = []
+  child.stdout!.on('data', (chunk: Buffer) => stdout.push(chunk))
+  child.stderr!.on('data', (chunk: Buffer) => stderr.push(chunk))
+  child.stdin!.end(JSON.stringify({ session_id: sessionId, cwd }))
+  const done = new Promise<CliProcessResult>((resolve, reject) => {
+    child.once('error', reject)
+    child.once('exit', (code, signal) => {
+      resolve({
+        code,
+        signal,
+        stdout: Buffer.concat(stdout).toString(),
+        stderr: Buffer.concat(stderr).toString(),
+        durationMs: Date.now() - startedAt,
+      })
+    })
   })
+  void done.catch(() => undefined)
+  return { child, done }
+}
+
+function writeGlobalConfig(h: Harness, toml: string): void {
+  const dir = path.join(h.env['XDG_CONFIG_HOME'] as string, 'notifai')
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(path.join(dir, 'config.toml'), toml)
+}
 
-  it('pushes a spawned session first question once the machine has gone quiet', async () => {
-    const h = harness([reply({ text: 'Yes' })], 900)
+/** Long enough ago that no test is accidentally sensitive to the stamp. */
+const AWAY = NOW - 600_000
+
+describe('pushing a registered question', () => {
+  // Found by a live Claude Code session: a spawned agent always has a
+  // just-set last_prompt_at, and the routing gate once read that as the user
+  // being present — so its FIRST question could never escalate, which is the
+  // "kick off agents and walk away" case the feature exists for.
+  it('pushes a freshly spawned session first question', async () => {
+    const h = harness([reply({ text: 'Yes' })])
     // Prompt 20s ago, exactly as a just-spawned agent has.
     writeSessionState('spawn1', h.env, { last_prompt_at: NOW - 20_000 })
     registerQuestion('spawn1', h.env, { question: 'Ship it?' }, NOW)
@@ -251,7 +400,7 @@ describe('presence gate', () => {
   })
 
   it('names the resolved project in the pushed question title', async () => {
-    const h = harness([reply({ text: 'Yes' })], 900)
+    const h = harness([reply({ text: 'Yes' })])
     const projectDir = path.join(h.deps.cwd, '.notifai')
     mkdirSync(projectDir, { recursive: true })
     writeFileSync(
@@ -265,171 +414,354 @@ describe('presence gate', () => {
 
     expect(h.recorder.submitted[0]?.draft.presentation.title).toBe('Question · notifai-cli')
   })
+})
+
+/**
+ * A hook's decisions are invisible from everywhere else: its stderr belongs to
+ * the harness, and its usual outcome is to do nothing at all. These are the
+ * tests that the local log closes that gap — that "my question never reached my
+ * phone" has an answer rather than a silence.
+ */
+describe('what the hook leaves behind', () => {
+  function recording(h: Harness): CommandDeps {
+    return { ...h.deps, logger: createLogger({ env: h.env, cmd: 'hook stop' }) }
+  }
+
+  function gates(h: Harness): LogRecord[] {
+    return readLogRecords(h.env, { event: ['hook.gate'], limit: 50 }).records
+  }
+
+  it('records why a question was held, in a name a filter can match', async () => {
+    const h = harness([])
+    writeSessionState('held', h.env, { accepted: undefined })
+    registerQuestion('held', h.env, { question: 'Ship it?' }, NOW)
+    // A continuation turn must not re-ask the question it is continuing from.
+    writeSessionState('held', h.env, {
+      ...readSessionState('held', h.env),
+      continuation: { answered_at: NOW + 1000, count: 1 },
+    })
+
+    await hookRunCommand(
+      recording(h),
+      'stop',
+      stdin({ session_id: 'held', cwd: h.deps.cwd, stop_hook_active: true }),
+    )
 
-  it('falls back to elapsed time where no idle source exists', () => {
-    const { env, deps } = harness()
-    const config = loadConfig({ cwd: deps.cwd, env })
-    expect(isUserAway({ last_prompt_at: AWAY }, config, NOW, null)).toBe(true)
+    const held = gates(h).find((record) => record.data?.['reason'] === 'continuation-repeat')
+    expect(held).toBeDefined()
+    expect(held!.data).toMatchObject({ verdict: 'held' })
+    expect(h.recorder.submitted).toHaveLength(0)
   })
 
-  it('does not push a question to the phone while the user is at the keyboard', async () => {
-    // Silent for ten minutes by the session clock, but active by the machine's.
-    const h = harness([reply({ text: 'Yes' })], 2)
-    writeSessionState('idle1', h.env, { last_prompt_at: AWAY })
-    registerQuestion('idle1', h.env, { question: 'Ship it?' })
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'idle1' }))
+  it('records the switch being off, which the user is deliberately never told', async () => {
+    // Silent to the user by design, so from outside "you turned it off" and "a
+    // bug ate my question" look identical. This is what tells them apart.
+    const h = harness([])
+    const dir = path.join(h.env['XDG_CONFIG_HOME'] as string, 'notifai')
+    mkdirSync(dir, { recursive: true })
+    writeFileSync(path.join(dir, 'config.toml'), 'ask_notifications = false\n')
+    writeSessionState('off', h.env, { last_prompt_at: AWAY })
+    registerQuestion('off', h.env, { question: 'Ship it?' })
+
+    await hookRunCommand(recording(h), 'stop', stdin({ session_id: 'off', cwd: h.deps.cwd }))
+
     expect(h.recorder.submitted).toHaveLength(0)
-    expect(h.io.errLines.join('\n')).toContain('at the keyboard')
+    // Nothing was printed, and the log is the only account of it.
+    expect(h.io.errLines.join('\n')).not.toContain('notifications')
+    expect(gates(h).map((record) => record.data?.['reason'])).toContain('notifications-off')
   })
-})
 
-/**
- * Wanting notifications while still at the machine is a legitimate setting —
- * nobody should have to stop using their computer in order to be reached.
- * Presence is a precondition only while the user wants it to be, and switching
- * it off must not disturb the grace timer.
- */
-describe('presence gating is optional (require_idle)', () => {
-  function writeGlobalConfig(h: Harness, toml: string): void {
+  it('records a turn with no question at all, so "did the hook run" is answerable', async () => {
+    const h = harness()
+    await hookRunCommand(recording(h), 'stop', stdin({ session_id: 'quiet', cwd: h.deps.cwd }))
+    const events = readLogRecords(h.env, { limit: 50 }).records.map((record) => record.event)
+    expect(events).toContain('hook.start')
+    expect(events).toContain('hook.end')
+    expect(gates(h).map((record) => record.data?.['reason'])).toContain('no-question')
+  })
+
+  it('lets the hook project re-enable a bootstrap logger and records resolved config', async () => {
+    const h = harness()
+    writeGlobalConfig(h, 'log_level = "off"\n')
+    const startup = path.join(h.deps.cwd, 'startup')
+    const project = path.join(h.deps.cwd, 'project')
+    mkdirSync(startup, { recursive: true })
+    mkdirSync(path.join(project, '.notifai'), { recursive: true })
+    writeFileSync(
+      path.join(project, '.notifai', 'config.toml'),
+      'project = "hook-project"\nlog_level = "debug"\n',
+    )
+    const deps = { ...h.deps, cwd: startup, logger: bootstrapLogger({ env: h.env, cwd: startup }) }
+
+    await hookRunCommand(deps, 'stop', stdin({ session_id: 'reenabled', cwd: project }))
+
+    const records = readLogRecords(h.env, { limit: 50 }).records
+    expect(records.map((record) => record.event)).toEqual(
+      expect.arrayContaining(['config.resolved', 'hook.start', 'hook.end']),
+    )
+    expect(records.find((record) => record.event === 'config.resolved')).toMatchObject({
+      project: 'hook-project',
+      session: 'reenabled',
+    })
+  })
+
+  it('persists an answer once while still reporting it to the harness', async () => {
+    const h = harness([reply({ text: 'Allow exactly once' })])
+    writeSessionState('answer-log', h.env, { last_prompt_at: AWAY })
+    registerQuestion('answer-log', h.env, { question: 'Ship it?' })
+
+    await hookRunCommand(
+      recording(h),
+      'stop',
+      stdin({ session_id: 'answer-log', cwd: h.deps.cwd }),
+    )
+
+    const raw = readFileSync(activeLogPath(h.env), 'utf8')
+    expect(raw.match(/Allow exactly once/g)).toHaveLength(1)
+    const answerRecords = readLogRecords(h.env, { event: ['hook.answer'] }).records
+    expect(answerRecords.map((record) => record.data?.['stage'])).toEqual([
+      'queued',
+      'delivered',
+    ])
+    expect(h.io.errLines.join('\n')).toContain('Allow exactly once')
+  })
+
+  it('records the push and ties it to the request id the server knows', async () => {
+    const h = harness([])
     const dir = path.join(h.env['XDG_CONFIG_HOME'] as string, 'notifai')
     mkdirSync(dir, { recursive: true })
-    writeFileSync(path.join(dir, 'config.toml'), toml)
-  }
+    writeFileSync(path.join(dir, 'config.toml'), 'ask_grace_seconds = 0\n')
+    writeSessionState('pushed', h.env, { last_prompt_at: AWAY })
+    registerQuestion('pushed', h.env, { question: 'Ship it?' })
 
-  it('counts a user actively typing as reachable', () => {
-    // One second of idle: as present as it is possible to be.
-    const config = loadConfig({ cwd: '/nowhere', env: {}, flags: {} })
-    expect(isUserAway({ last_prompt_at: NOW }, config, NOW, 1)).toBe(false)
+    await hookRunCommand(recording(h), 'stop', stdin({ session_id: 'pushed', cwd: h.deps.cwd }))
 
-    const off = loadConfig({ cwd: '/nowhere', env: {}, flags: {} })
-    off.require_idle = { value: false, source: 'default' }
-    expect(isUserAway({ last_prompt_at: NOW }, off, NOW, 1)).toBe(true)
+    const pushed = readLogRecords(h.env, { event: ['hook.pushed'] }).records
+    expect(pushed).toHaveLength(1)
+    expect(pushed[0]!.data).toMatchObject({ ok: true })
+    // The local record and the server's evidence trail share one id, which is
+    // what makes `notifai logs --request <id>` and `notifai status <id>` two
+    // views of one thing.
+    expect(pushed[0]!.data!['request_id']).toBe(h.recorder.receipts[0])
   })
 
-  it('escalates a question while the user is at the keyboard', async () => {
-    const h = harness([], 1)
-    writeGlobalConfig(h, 'require_idle = false\nask_grace_seconds = 0\n')
-    writeSessionState('present1', h.env, { last_prompt_at: NOW })
-    registerQuestion('present1', h.env, { question: 'Ship it?' })
+  it('stores every request in a multi-question wait as a structured identity', async () => {
+    const h = harness([])
+    writeSessionState('request-log', h.env, { last_prompt_at: AWAY })
+    registerQuestion('request-log', h.env, { question: 'Ship it?' }, NOW)
+    registerQuestion('request-log', h.env, { question: 'Deploy it?' }, NOW + 1)
 
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'present1' }))
+    await hookRunCommand(
+      recording(h),
+      'stop',
+      stdin({ session_id: 'request-log', cwd: h.deps.cwd }),
+    )
+
+    const unanswered = readLogRecords(h.env, { event: ['hook.answer'] }).records.at(-1)
+    expect(unanswered?.data?.['request_ids']).toEqual(h.recorder.receipts)
+    expect(readSessionState('request-log', h.env).pending).toBeUndefined()
 
-    expect(h.recorder.submitted).toHaveLength(1)
-    expect(h.io.errLines.join('\n')).not.toContain('at the keyboard')
+    for (const requestId of h.recorder.receipts) {
+      const matching = readLogRecords(h.env, { request: requestId }).records
+      expect(matching).toContainEqual(unanswered)
+    }
+    expect(readLogRecords(h.env, { request: 'req_hook' }).records).not.toContainEqual(unanswered)
   })
 
-  it('still gives the terminal its grace window first', async () => {
-    // The two knobs are independent: not needing the user to leave does not
-    // mean skipping the wait that offers the question to the terminal.
-    const h = harness([], 1)
-    writeGlobalConfig(h, 'require_idle = false\nask_grace_seconds = 300\n')
-    writeSessionState('present2', h.env, { last_prompt_at: NOW })
-    registerQuestion('present2', h.env, { question: 'Ship it?' }, NOW)
+  it('records a config parse failure as a complete fail-open lifecycle', async () => {
+    const h = harness()
+    mkdirSync(path.join(h.deps.cwd, '.notifai'), { recursive: true })
+    writeFileSync(path.join(h.deps.cwd, '.notifai', 'config.toml'), 'not valid = [toml')
 
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'present2' }))
+    await hookRunCommand(
+      { ...h.deps, logger: createLogger({ env: h.env }) },
+      'stop',
+      stdin({ session_id: 'bad-config', cwd: h.deps.cwd }),
+    )
 
-    expect(h.recorder.submitted).toHaveLength(1)
-    // The clock only advances when the hook sleeps, so this is proof the wait
-    // actually happened rather than being skipped.
-    expect((h.deps.now?.() ?? NOW) - NOW).toBeGreaterThanOrEqual(300_000)
+    const records = readLogRecords(h.env, { limit: 10 }).records
+    expect(records.map((record) => record.event)).toEqual(['hook.start', 'hook.end'])
+    expect(records.at(-1)?.data).toMatchObject({ outcome: 'failed', reason: 'config-failed' })
   })
 
-  it('honours the grace window on a machine with no idle source at all', async () => {
-    // With presence gating on, no idle source means refusing to wait
-    // ('no-signal'). With it off there is nothing to watch for, so the timer
-    // is just a timer and works everywhere.
-    const h = harness([], null)
-    writeGlobalConfig(h, 'require_idle = false\nask_grace_seconds = 120\n')
-    registerQuestion('present3', h.env, { question: 'Ship it?' }, NOW)
+  it('records a hook failure with the server own words, not just that it failed', async () => {
+    const h = harness()
+    const deps: CommandDeps = {
+      ...recording(h),
+      clientFactory: () => {
+        throw new ApiCallError(422, 'validation_failed', 'draft rejected', null, [
+          { path: '/draft/lifecycle' },
+        ])
+      },
+    }
+    registerQuestion('broken', h.env, { question: 'Ship it?' })
+    writeSessionState('broken', h.env, { last_prompt_at: AWAY })
 
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'present3' }))
+    await hookRunCommand(deps, 'stop', stdin({ session_id: 'broken', cwd: h.deps.cwd }))
 
-    expect(h.recorder.submitted).toHaveLength(1)
-    expect((h.deps.now?.() ?? NOW) - NOW).toBeGreaterThanOrEqual(120_000)
-    expect(h.io.errLines.join('\n')).not.toContain('no idle signal')
+    const failures = readLogRecords(h.env, { level: 'error' }).records
+    expect(failures.length).toBeGreaterThan(0)
+    expect(JSON.stringify(failures)).toContain('/draft/lifecycle')
+    expect(JSON.stringify(failures)).toContain('validation_failed')
   })
 
-  it('is not a way to switch escalation on when the user has switched it off', async () => {
-    // ask_notifications is the "do not reach me" switch and outranks this one;
-    // wanting to be reachable while working is a different question entirely.
-    const h = harness([], 1)
-    writeGlobalConfig(h, 'require_idle = false\nask_notifications = false\n')
-    registerQuestion('present4', h.env, { question: 'Ship it?' })
+  it('never writes the machine credential, whatever the hook did', async () => {
+    const h = harness([])
+    const dir = path.join(h.env['XDG_CONFIG_HOME'] as string, 'notifai')
+    mkdirSync(dir, { recursive: true })
+    writeFileSync(path.join(dir, 'config.toml'), 'ask_grace_seconds = 0\n')
+    writeSessionState('secret', h.env, { last_prompt_at: AWAY })
+    registerQuestion('secret', h.env, { question: 'Ship it?' })
 
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'present4' }))
+    await hookRunCommand(recording(h), 'stop', stdin({ session_id: 'secret', cwd: h.deps.cwd }))
 
-    expect(h.recorder.submitted).toHaveLength(0)
+    // The log is the artefact most likely to be pasted into a conversation.
+    const raw = readFileSync(activeLogPath(h.env), 'utf8')
+    expect(raw).not.toContain('test-secret')
+    expect(raw).not.toContain('nfm_mac_test')
   })
 })
 
+/**
+ * Wanting notifications while still at the machine is a legitimate setting —
+ * nobody should have to stop using their computer in order to be reached.
+ * Presence is a precondition only while the user wants it to be, and switching
+ * it off must not disturb the grace timer.
+ */
 describe('terminal-first grace window', () => {
-  /** Registers a question asked `agoMs` ago, with the user long since silent. */
+  /** Registers a question asked `agoMs` ago. */
   function pending(h: Harness, session: string, agoMs: number): void {
     writeSessionState(session, h.env, { last_prompt_at: AWAY })
     registerQuestion(session, h.env, { question: 'Ship it?' }, NOW - agoMs)
   }
 
+  it('pushes as soon as the turn ends when no window is configured', async () => {
+    const h = harness([])
+    let submittedAt: number | undefined
+    h.recorder.beforeQuestionSubmit = () => {
+      submittedAt = h.deps.now?.()
+    }
+    // The user typed this very instant. It changes nothing: the waiter does
+    // not hold their terminal, so their being here is not a reason to wait.
+    writeSessionState('present1', h.env, { last_prompt_at: NOW })
+    registerQuestion('present1', h.env, { question: 'Ship it?' })
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'present1' }))
+
+    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(1)
+    expect(submittedAt).toBe(NOW)
+  })
+
   it('holds the question in the terminal until the window elapses', async () => {
-    // Idle 900s: the user is gone, so the wait runs to completion rather than
-    // being abandoned. Sleeps advance the virtual clock.
-    const h = harness([reply({ text: 'Yes' })], 900)
+    const h = harness([reply({ text: 'Yes' })])
+    writeGlobalConfig(h, 'ask_grace_seconds = 300\n')
     pending(h, 'g1', 0)
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'g1' }))
     expect(h.recorder.submitted.length).toBeGreaterThan(0)
-    // Nothing was pushed before the 300s default had passed.
+    // Sleeps advance the virtual clock, so this is proof the wait happened.
     expect(h.deps.now?.()).toBeGreaterThanOrEqual(NOW + 300_000)
   })
 
   it('counts the window from when the question was sent, not from the turn end', async () => {
     // Asked 290s ago while the agent kept working: only 10s of wait remains.
-    const h = harness([reply({ text: 'Yes' })], 900)
+    const h = harness([reply({ text: 'Yes' })])
+    writeGlobalConfig(h, 'ask_grace_seconds = 300\n')
     pending(h, 'g2', 290_000)
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'g2' }))
     expect(h.recorder.submitted.length).toBeGreaterThan(0)
     expect(h.deps.now?.()).toBeLessThan(NOW + 60_000)
   })
 
-  it('sends nothing if the user comes back to the keyboard during the window', async () => {
-    let idle = 900
-    const h = harness([reply({ text: 'Yes' })], 900)
-    // Machine goes active on the second poll: the user sat down.
-    h.deps.idleSeconds = () => {
-      const current = idle
-      idle = 1
-      return current
-    }
-    pending(h, 'g3', 0)
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'g3' }))
-    expect(h.recorder.submitted).toHaveLength(0)
-    expect(h.io.errLines.join('\n')).toContain('came back')
+  it('waits the window out on a machine with no idle signal at all', async () => {
+    // The timer once refused to run without an idle source to watch, because
+    // it was holding a terminal it could not monitor. It holds nothing now.
+    const h = harness([])
+    writeGlobalConfig(h, 'ask_grace_seconds = 120\n')
+    registerQuestion('present3', h.env, { question: 'Ship it?' }, NOW)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'present3' }))
+
+    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(1)
+    expect((h.deps.now?.() ?? NOW) - NOW).toBeGreaterThanOrEqual(120_000)
   })
 
-  it('refuses to hold a terminal it cannot monitor', async () => {
-    // No idle source: waiting would block the prompt with no way to notice the
-    // user returning, so it asks immediately instead.
-    const h = harness([reply({ text: 'Yes' })], null)
-    pending(h, 'g4', 0)
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'g4' }))
-    expect(h.recorder.submitted.length).toBeGreaterThan(0)
-    expect(h.deps.now?.()).toBe(NOW)
-    expect(h.io.errLines.join('\n')).toContain('no idle signal')
+  it('is not a way to switch escalation on when the user has switched it off', async () => {
+    // ask_notifications is the "do not reach me" switch and outranks the timer.
+    const h = harness([])
+    writeGlobalConfig(h, 'ask_grace_seconds = 0\nask_notifications = false\n')
+    registerQuestion('present4', h.env, { question: 'Ship it?' })
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'present4' }))
+
+    expect(h.recorder.submitted).toHaveLength(0)
   })
 
-  it('never lets the window crowd out the reply wait past the hook budget', async () => {
-    // Both dials at maximum would be 540 + 540 — nearly twice the 600s ceiling
-    // the harness kills a hook at, and a killed hook loses an answer already
-    // given. The reply wait wins, so the window yields to nothing at all.
-    const h = harness([reply({ text: 'Yes' })], 900)
-    const dir = path.join(h.env['XDG_CONFIG_HOME'] as string, 'notifai')
-    mkdirSync(dir, { recursive: true })
-    writeFileSync(
-      path.join(dir, 'config.toml'),
-      'ask_grace_seconds = 540\nhook_reply_timeout_seconds = 540\n',
-    )
+  it('never lets the longest window crowd out a reply window the server accepts', async () => {
+    // The maximum grace a user can configure still has to leave the protocol's
+    // 60s minimum inside the waiter ceiling. Real timers do not wake on the
+    // exact requested millisecond, so the sleep deliberately overshoots.
+    const h = harness([reply({ text: 'Yes' })])
+    const virtualSleep = h.deps.sleep!
+    h.deps.sleep = async (milliseconds: number) => virtualSleep(milliseconds + 1)
+    writeGlobalConfig(h, 'ask_grace_seconds = 360\n')
     pending(h, 'g5', 0)
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'g5' }))
     expect(h.recorder.submitted.length).toBeGreaterThan(0)
-    expect(h.deps.now?.()).toBe(NOW)
+    expect(h.deps.now?.()).toBeGreaterThanOrEqual(NOW + 360_000)
+    expect(h.deps.now?.()).toBeLessThan(NOW + 361_000)
+    expect(
+      h.recorder.submitted.find((entry) => entry.draft.event === 'agent_question')?.draft.reply
+        ?.expires_in_seconds,
+    ).toBeGreaterThanOrEqual(60)
+  })
+
+  it('charges transport overrun and close time to the one waiter ceiling', async () => {
+    const h = harness([])
+    const factory = h.deps.clientFactory
+    h.deps.clientFactory = () => {
+      const client = factory!()
+      return {
+        ...client,
+        listDevices: async () => {
+          h.advanceClock(20_000)
+          return client.listDevices()
+        },
+        submit: async (body: SubmitNotificationRequestT, waitSeconds: number) => {
+          h.advanceClock(20_000)
+          return client.submit(body, waitSeconds)
+        },
+        replies: async (
+          requestId: string,
+          options: { waitSeconds: number; afterSeq: number },
+        ) => {
+          // Server hold plus the client's 20s AbortSignal allowance.
+          h.advanceClock((options.waitSeconds + 20) * 1000)
+          return {
+            request_id: requestId,
+            reply_expires_at: new Date(NOW + 480_000).toISOString(),
+            replies: [],
+          }
+        },
+        closeReplies: async (requestId: string) => {
+          h.advanceClock(20_000)
+          return client.closeReplies(requestId)
+        },
+      } as ApiClient
+    }
+    writeGlobalConfig(h, 'ask_grace_seconds = 250\n')
+    pending(h, 'transport-budget', 0)
+
+    await hookRunCommand(h.deps, 'stop', async () => {
+      // stdin/config/setup belong to the same invocation budget as polling.
+      h.advanceClock(30_000)
+      return JSON.stringify({ session_id: 'transport-budget' })
+    })
+
+    // The waiter's 480s ceiling is the last moment it will accept an answer;
+    // closing the window and retiring the card happens after it, which is what
+    // the blocking hosts' extra minute of declared headroom is there for.
+    expect(h.deps.now?.()).toBeLessThanOrEqual(NOW + 540_000)
+    expect(readSessionState('transport-budget', h.env).pending).toBeUndefined()
   })
 })
 
@@ -465,7 +797,7 @@ describe('nagging guards', () => {
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'n1' }))
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'n1' }))
 
-    expect(h.recorder.submitted).toHaveLength(1)
+    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(1)
   })
 
   it('respects the harness recursion guard', async () => {
@@ -480,7 +812,7 @@ describe('nagging guards', () => {
   })
 
   it('delivers a new question registered during an answer continuation', async () => {
-    const h = harness([reply({ text: 'First answer' })], 900)
+    const h = harness([reply({ text: 'First answer' })])
     writeSessionState('n3', h.env, { last_prompt_at: AWAY })
     registerQuestion('n3', h.env, { question: 'First question?' }, NOW)
 
@@ -500,7 +832,7 @@ describe('nagging guards', () => {
   })
 
   it('stops chained questions at the consecutive continuation cap', async () => {
-    const h = harness([], 900)
+    const h = harness([])
     writeSessionState('n4', h.env, {
       last_prompt_at: AWAY,
       continuation: { answered_at: NOW - 1, count: 3 },
@@ -513,24 +845,43 @@ describe('nagging guards', () => {
     expect(readSessionState('n4', h.env).pending?.[0]?.question).toBe('One more?')
     expect(h.io.errLines.join('\n')).toContain('continuation limit (3) reached')
   })
+
+  it('starts the consecutive continuation count over when the user takes a turn', async () => {
+    // The cap bounds an agent running on its own. A human at the keyboard is
+    // the end of that chain, not another link in it.
+    const h = harness([])
+    writeSessionState('n5', h.env, {
+      continuation: { answered_at: NOW - 1, count: MAX_CONTINUATION_COUNT },
+    })
+
+    await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 'n5' }))
+
+    expect(readSessionState('n5', h.env).continuation).toEqual({
+      answered_at: NOW - 1,
+      count: 0,
+    })
+  })
 })
 
 describe('late answer collection', () => {
-  it('collects a late answer on Stop and resumes with it instead of asking twice', async () => {
-    const answers: ReplyView[] = []
-    const h = harness(answers, 900)
-    writeSessionState('late-stop', h.env, { last_prompt_at: AWAY })
-    registerQuestion('late-stop', h.env, { question: 'Ship it?' }, NOW)
-
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'late-stop' }))
-    expect(readSessionState('late-stop', h.env).pending?.[0]?.request_id).toBe('req_hook_1')
-    answers.push(reply({ text: 'Ship it' }))
-    h.io.outLines = []
+  it('collects an answer that arrived during the resumed model turn', async () => {
+    const h = harness([reply({ text: 'Ship it' })])
+    writeSessionState('late-stop', h.env, {
+      last_prompt_at: AWAY,
+      pending: [{
+        question: 'Ship it?',
+        asked_at: NOW,
+        request_id: 'req_live',
+        collapse_key: 'collapse-live',
+        device_ids: ['dev_iphone'],
+        reply_deadline_at: NOW + 60_000,
+      }],
+    })
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'late-stop' }))
 
-    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(1)
-    expect(h.recorder.closed).toContain('req_hook_1')
+    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(0)
+    expect(h.recorder.closed).toContain('req_live')
     expect(readSessionState('late-stop', h.env).pending).toBeUndefined()
     expect(h.io.outLines).toHaveLength(1)
     expect(JSON.parse(h.io.outLines[0] ?? '{}')).toMatchObject({
@@ -540,13 +891,18 @@ describe('late answer collection', () => {
   })
 
   it('collects a late answer on UserPromptSubmit and retires it truthfully', async () => {
-    const answers: ReplyView[] = []
-    const h = harness(answers, 900)
-    writeSessionState('late-prompt', h.env, { last_prompt_at: AWAY })
-    registerQuestion('late-prompt', h.env, { question: 'Ship it?' }, NOW)
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'late-prompt' }))
-    answers.push(reply({ text: 'Hold' }))
-    h.io.outLines = []
+    const h = harness([reply({ text: 'Hold' })])
+    writeSessionState('late-prompt', h.env, {
+      last_prompt_at: AWAY,
+      pending: [{
+        question: 'Ship it?',
+        asked_at: NOW,
+        request_id: 'req_live',
+        collapse_key: 'collapse-live',
+        device_ids: ['dev_iphone'],
+        reply_deadline_at: NOW + 60_000,
+      }],
+    })
 
     await hookRunCommand(
       h.deps,
@@ -554,71 +910,302 @@ describe('late answer collection', () => {
       stdin({ session_id: 'late-prompt', cwd: h.deps.cwd }),
     )
 
+    expect(readSessionState('late-prompt', h.env).accepted?.answers[0]?.reply.text).toBe('Hold')
+    expect(h.io.outLines).toEqual([])
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'late-prompt' }))
+    expect(JSON.parse(h.io.outLines.at(-1) ?? '{}').reason).toContain('Hold')
+    await hookRunCommand(
+      h.deps,
+      'stop',
+      stdin({ session_id: 'late-prompt', stop_hook_active: true }),
+    )
+
     const retirement = h.recorder.submitted.find(
       (entry) => entry.draft.event === 'question_retired',
     )?.draft
     expect(retirement?.lifecycle).toMatchObject({
       state: 'answered',
-      retires_request_id: 'req_hook_1',
+      retires_request_id: 'req_live',
     })
     expect(retirement?.lifecycle?.state).not.toBe('answered_elsewhere')
     expect(readSessionState('late-prompt', h.env).pending).toBeUndefined()
-    expect(JSON.parse(h.io.outLines[0] ?? '{}')).toEqual({
-      hookSpecificOutput: {
-        hookEventName: 'UserPromptSubmit',
-        additionalContext: expect.stringContaining('Hold'),
-      },
-    })
+    expect(readSessionState('late-prompt', h.env).accepted).toBeUndefined()
   })
 })
 
-describe('OpenCode answer preservation', () => {
-  it('pushes without waiting and leaves the answerable request intact', async () => {
-    const h = harness([reply({ text: 'Approve' })], 900)
+describe('OpenCode answer continuation', () => {
+  it('fails closed instead of accepting an answer the idle event cannot deliver', async () => {
+    const h = harness([reply({ text: 'Approve' })])
     writeSessionState('open1', h.env, { last_prompt_at: AWAY })
     registerQuestion('open1', h.env, { question: 'Deploy?' }, NOW)
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'open1' }), 'opencode')
 
-    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(1)
+    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(0)
     expect(h.recorder.closed).toEqual([])
     expect(
       h.recorder.submitted.filter((entry) => entry.draft.event === 'question_retired'),
-    ).toEqual([])
-    expect(readSessionState('open1', h.env).pending?.[0]).toMatchObject({
-      question: 'Deploy?',
-      request_id: 'req_hook_1',
-      device_ids: ['dev_iphone', 'dev_mac'],
-    })
+    ).toHaveLength(0)
+    expect(readSessionState('open1', h.env).pending).toBeUndefined()
     expect(h.io.outLines).toEqual([])
+    expect(h.io.errLines.join('\n')).toContain('no proven answer continuation')
   })
 })
 
-describe('reply-wait presence monitoring', () => {
-  it('returns the terminal when the user comes back after the push', async () => {
-    const h = harness([], 900)
-    let checks = 0
-    h.deps.idleSeconds = () => {
-      checks += 1
-      return checks >= 4 ? 1 : 900
+describe('the waiter owning one question to the end', () => {
+  it('delivers a reply that commits while the server close fence is finalizing silence', async () => {
+    const h = harness([])
+    const factory = h.deps.clientFactory
+    h.deps.clientFactory = () => {
+      const client = factory!()
+      return {
+        ...client,
+        replies: async (requestId: string) => ({
+          request_id: requestId,
+          reply_expires_at: new Date(NOW + 60_000).toISOString(),
+          replies: [],
+        }),
+        closeReplies: async (requestId: string) => {
+          h.recorder.closed.push(requestId)
+          return {
+            request_id: requestId,
+            reply_expires_at: new Date(NOW + 60_000).toISOString(),
+            replies: [reply({ text: 'Committed at the fence' })],
+          }
+        },
+      } as ApiClient
+    }
+    writeSessionState('fenced-reply', h.env, { last_prompt_at: AWAY })
+    registerQuestion('fenced-reply', h.env, { question: 'Deploy?' }, NOW)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'fenced-reply' }))
+
+    expect(JSON.parse(h.io.outLines.at(-1) ?? '{}').reason).toContain(
+      'Committed at the fence',
+    )
+    expect(readSessionState('fenced-reply', h.env).accepted).toBeDefined()
+  })
+
+  it('preserves a silent question when the close fence cannot be proven', async () => {
+    const h = harness([])
+    const factory = h.deps.clientFactory
+    h.deps.clientFactory = () => {
+      const client = factory!()
+      return {
+        ...client,
+        closeReplies: async () => {
+          throw new Error('partitioned during close')
+        },
+      } as ApiClient
     }
-    writeSessionState('returned', h.env, { last_prompt_at: AWAY })
-    registerQuestion('returned', h.env, { question: 'Deploy?' }, NOW - 300_000)
+    writeSessionState('unproven-close', h.env, { last_prompt_at: AWAY })
+    registerQuestion('unproven-close', h.env, { question: 'Deploy?' }, NOW)
 
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'returned' }))
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'unproven-close' }))
 
-    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(1)
-    expect(h.recorder.closed).toEqual([])
-    expect(readSessionState('returned', h.env).pending?.[0]?.request_id).toBe('req_hook_1')
-    expect((h.deps.now?.() ?? NOW) - NOW).toBeLessThan(30_000)
-    expect(h.io.errLines.join('\n')).toContain('came back')
-    expect(h.io.errLines.join('\n')).toContain('notifai replies --pending')
+    const state = readSessionState('unproven-close', h.env)
+    expect(state.pending?.[0]?.request_id).toBe(h.recorder.receipts[0])
+    expect(state.retiring).toBeUndefined()
+    expect(h.io.errLines.join('\n')).toContain('preserving ownership')
+  })
+
+  it('recovers an accepted question after its submit response is lost', async () => {
+    const h = harness([])
+    const factory = h.deps.clientFactory
+    let acceptedRequestId: string | undefined
+    h.deps.clientFactory = () => {
+      const client = factory!()
+      return {
+        ...client,
+        submit: async (body: SubmitNotificationRequestT) => {
+          if (body.draft.event !== 'agent_question') return client.submit(body, 0)
+          acceptedRequestId = body.request_id
+          h.recorder.submitted.push(body)
+          h.recorder.receipts.push(body.request_id!)
+          h.recorder.aliases.set(body.request_id!, 1)
+          throw new Error('response lost after commit')
+        },
+        replies: async (requestId: string) => ({
+          request_id: requestId,
+          reply_expires_at: new Date(NOW + 60_000).toISOString(),
+          replies: requestId === acceptedRequestId ? [reply({ text: 'Yes, recover it' })] : [],
+        }),
+        closeReplies: async (requestId: string) => ({
+          request_id: requestId,
+          reply_expires_at: new Date(NOW).toISOString(),
+          replies: requestId === acceptedRequestId ? [reply({ text: 'Yes, recover it' })] : [],
+        }),
+      } as ApiClient
+    }
+    writeSessionState('ambiguous-submit', h.env, { last_prompt_at: AWAY })
+    registerQuestion('ambiguous-submit', h.env, { question: 'Deploy?' }, NOW)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'ambiguous-submit' }))
+
+    expect(acceptedRequestId).toMatch(/^req_[A-Za-z0-9_-]{22,24}$/)
+    expect(JSON.parse(h.io.outLines.at(-1) ?? '{}').reason).toContain('Yes, recover it')
+    expect(readSessionState('ambiguous-submit', h.env).accepted?.answers[0]?.pending.request_id)
+      .toBe(acceptedRequestId)
+  })
+
+  it('replays the frozen intent when an ambiguous submit never reached the server', async () => {
+    const h = harness([])
+    const factory = h.deps.clientFactory
+    let firstAttempt: SubmitNotificationRequestT | undefined
+    h.deps.clientFactory = () => {
+      const client = factory!()
+      return {
+        ...client,
+        submit: async (body: SubmitNotificationRequestT) => {
+          firstAttempt = body
+          throw new Error('connection failed before commit')
+        },
+        replies: async () => {
+          throw new ApiCallError(404, 'not_found', 'No such request.')
+        },
+        closeReplies: async () => {
+          throw new ApiCallError(404, 'not_found', 'No such request.')
+        },
+      } as ApiClient
+    }
+    writeSessionState('precommit-loss', h.env, { last_prompt_at: AWAY })
+    registerQuestion('precommit-loss', h.env, { question: 'Deploy?' }, NOW)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'precommit-loss' }))
+
+    const stranded = readSessionState('precommit-loss', h.env).pending?.[0]
+    expect(stranded?.request_id).toBeUndefined()
+    expect(stranded?.submission).toBeDefined()
+    expect(h.io.errLines.join('\n')).toContain('response was ambiguous')
+
+    h.advanceClock(600_000)
+    h.deps.clientFactory = factory
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'precommit-loss' }))
+
+    expect(h.recorder.submitted[0]).toEqual(firstAttempt)
+  })
+
+  it('preserves and exactly replays an intent after a definitive submit rejection', async () => {
+    const h = harness([])
+    const factory = h.deps.clientFactory
+    let polls = 0
+    h.deps.clientFactory = () => {
+      const client = factory!()
+      return {
+        ...client,
+        submit: async () => {
+          throw new ApiCallError(422, 'invalid_request', 'The draft was rejected.')
+        },
+        replies: async () => {
+          polls += 1
+          throw new Error('must not poll an unaccepted request')
+        },
+      } as ApiClient
+    }
+    writeSessionState('rejected-submit', h.env, { last_prompt_at: AWAY })
+    registerQuestion('rejected-submit', h.env, { question: 'Deploy?' }, NOW)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'rejected-submit' }))
+
+    const pending = readSessionState('rejected-submit', h.env).pending?.[0]
+    expect(pending?.request_id).toBeUndefined()
+    expect(pending?.submission?.request_id).toMatch(/^req_[A-Za-z0-9_-]{22,24}$/)
+    expect(polls).toBe(0)
+    expect(h.io.errLines.join('\n')).toContain('submission was rejected')
+
+    const frozen = pending?.submission
+    if (frozen === undefined) throw new Error('expected a persisted submission intent')
+    writeGlobalConfig(h, 'project = "changed-after-crash"\n')
+    h.advanceClock(600_000)
+    h.deps.clientFactory = factory
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'rejected-submit' }))
+
+    expect(h.recorder.submitted[0]).toEqual({
+      request_id: frozen.request_id,
+      idempotency_key: frozen.idempotency_key,
+      draft: frozen.draft,
+    })
+  })
+
+  it('closes and retires silence at the absolute owner deadline', async () => {
+    const h = harness([])
+    const factory = h.deps.clientFactory
+    h.deps.clientFactory = () => {
+      const client = factory!()
+      return {
+        ...client,
+        submit: async (body: SubmitNotificationRequestT, waitSeconds: number) => ({
+          ...(await client.submit(body, waitSeconds)),
+          // The real server commits the configured reply window, rather than
+          // the generic recorder's deliberately broad 480s fixture.
+          reply_expires_at: new Date(NOW + 60_000).toISOString(),
+        }),
+      } as ApiClient
+    }
+    writeSessionState('deadline', h.env, { last_prompt_at: AWAY })
+    registerQuestion('deadline', h.env, { question: 'Deploy?' }, NOW)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'deadline' }))
+
+    expect(h.deps.now?.()).toBe(NOW + 60_000)
+    expect(h.recorder.closed).toContain(h.recorder.receipts[0])
+    expect(readSessionState('deadline', h.env).pending).toBeUndefined()
+    expect(h.io.errLines.join('\n')).toContain('expired with its continuation owner')
+  })
+
+  it('charges sequential submission latency to one deadline', async () => {
+    const h = harness([reply({ text: 'Done' })])
+    writeSessionState('latency', h.env, { last_prompt_at: AWAY })
+    registerQuestion('latency', h.env, { question: 'First?' }, NOW)
+    registerQuestion('latency', h.env, { question: 'Second?' }, NOW)
+    h.recorder.beforeQuestionSubmit = () => h.advanceClock(40_000)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'latency' }))
+
+    const windows = h.recorder.submitted
+      .filter((entry) => entry.draft.event === 'agent_question')
+      .map((entry) => entry.draft.reply?.expires_in_seconds)
+    // Both windows end at the same absolute moment: the second question's is
+    // shorter by exactly the 40s the first submission spent.
+    expect(windows).toEqual([480, 440])
+    expect(h.deps.now?.()).toBeLessThanOrEqual(NOW + 480_000)
+  })
+
+  it('re-arms the next Stop for an independently pending answer', async () => {
+    const h = harness([])
+    const answers = new Map<string, ReplyView[]>([
+      ['req_hook_1', [reply({ text: 'First answer' })]],
+      ['req_hook_2', []],
+    ])
+    h.recorder.repliesFor = (requestId) => answers.get(requestId) ?? []
+    writeSessionState('successor', h.env, { last_prompt_at: AWAY })
+    registerQuestion('successor', h.env, { question: 'First?' }, NOW)
+    registerQuestion('successor', h.env, { question: 'Second?' }, NOW)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'successor' }))
+    expect(JSON.parse(h.io.outLines.at(-1) ?? '{}').reason).toContain('First answer')
+    expect(readSessionState('successor', h.env).pending?.map((entry) => entry.question)).toEqual([
+      'Second?',
+    ])
+
+    answers.set('req_hook_2', [reply({ text: 'Second answer' })])
+    h.io.outLines = []
+    await hookRunCommand(
+      h.deps,
+      'stop',
+      stdin({ session_id: 'successor', stop_hook_active: true }),
+    )
+
+    expect(JSON.parse(h.io.outLines.at(-1) ?? '{}').reason).toContain('Second answer')
+    expect(readSessionState('successor', h.env).pending).toBeUndefined()
+    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(2)
   })
 })
 
 describe('Cursor stop output', () => {
-  it('maps the phone answer to one native followup_message', async () => {
-    const h = harness([reply({ text: 'Ship it' })], 900)
+  it('fails closed when the invoking shell cannot name the exact conversation', async () => {
+    const h = harness([reply({ text: 'Ship it' })])
     writeSessionState('cursor-conversation', h.env, { last_prompt_at: AWAY })
     registerQuestion('cursor-conversation', h.env, { question: 'Deploy now?' })
 
@@ -633,12 +1220,9 @@ describe('Cursor stop output', () => {
       'cursor',
     )
 
-    expect(h.io.outLines).toHaveLength(1)
-    const output = JSON.parse(h.io.outLines[0] ?? '{}') as Record<string, unknown>
-    expect(output['followup_message']).toContain(
-      'Notifai — the user answered from Furankuphone: "Ship it". Continue with that answer.',
-    )
-    expect(output).not.toHaveProperty('decision')
+    expect(h.recorder.submitted).toHaveLength(0)
+    expect(h.io.outLines).toHaveLength(0)
+    expect(h.io.errLines.join('\n')).toContain('asynchronous ask is unsupported')
   })
 })
 
@@ -661,36 +1245,40 @@ describe('question queueing and retirement debt', () => {
       }))
   }
 
-  it('keeps the first question live and asks the second alongside it', async () => {
+  function seedLive(h: Harness, sessionId: string, requestId = 'req_live'): void {
+    writeSessionState(sessionId, h.env, {
+      last_prompt_at: AWAY,
+      pending: [{
+        question: 'Ship it?',
+        asked_at: NOW,
+        request_id: requestId,
+        collapse_key: 'collapse-live',
+        device_ids: ['dev_iphone', 'dev_mac'],
+        reply_deadline_at: NOW + 60_000,
+      }],
+    })
+  }
+
+  it('registers a second question without mutating the live first question', () => {
     const h = harness([])
-    writeSessionState('sup1', h.env, { last_prompt_at: AWAY })
-    registerQuestion('sup1', h.env, { question: 'Ship it?' })
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'sup1' }))
-    const first = h.recorder.receipts[0]
-    expect(first).toBeDefined()
+    seedLive(h, 'sup1')
 
     // The agent carried on and asked something else. The first question is
     // still the user's to answer — a second question never ends the first;
     // superseding is reply semantics, not question semantics.
     registerQuestion('sup1', h.env, { question: 'Deploy it?' })
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'sup1' }))
 
     expect(retirements(h)).toEqual([])
-    expect(
-      h.recorder.submitted.filter((s) => s.draft.presentation.body === 'Deploy it?'),
-    ).toHaveLength(1)
     const live = readSessionState('sup1', h.env).pending
     expect(live).toHaveLength(2)
     expect(live?.map((entry) => entry.question)).toEqual(['Ship it?', 'Deploy it?'])
-    expect(live?.every((entry) => entry.request_id !== undefined)).toBe(true)
+    expect(live?.map((entry) => entry.request_id)).toEqual(['req_live', undefined])
   })
 
   it('keeps the ids when the retirement cannot be sent, and retries later', async () => {
     const h = harness([])
-    writeSessionState('sup2', h.env, { last_prompt_at: AWAY })
-    registerQuestion('sup2', h.env, { question: 'Ship it?' })
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'sup2' }))
-    const first = h.recorder.receipts[0]
+    seedLive(h, 'sup2')
+    const first = 'req_live'
 
     // Offline when the user returns: the wipe parks the retirement, the
     // drain fails, and it must not forget what it was for.
@@ -706,13 +1294,11 @@ describe('question queueing and retirement debt', () => {
 
   it('keeps the original delivery targets when routing changes before retirement', async () => {
     const h = harness([])
-    writeSessionState('sup-targets', h.env, { last_prompt_at: AWAY })
-    registerQuestion('sup-targets', h.env, { question: 'Ship it?' })
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'sup-targets' }))
+    seedLive(h, 'sup-targets')
 
     const live = readSessionState('sup-targets', h.env).pending?.[0]
     expect(live).toMatchObject({
-      request_id: 'req_hook_1',
+      request_id: 'req_live',
       device_ids: ['dev_iphone', 'dev_mac'],
     })
 
@@ -727,7 +1313,7 @@ describe('question queueing and retirement debt', () => {
     const retirement = h.recorder.submitted.find(
       (submission) => submission.draft.event === 'question_retired',
     )
-    expect(retirement?.draft.lifecycle?.retires_request_id).toBe('req_hook_1')
+    expect(retirement?.draft.lifecycle?.retires_request_id).toBe('req_live')
     expect(retirement?.draft.targets).toEqual({
       mode: 'selected',
       device_ids: ['dev_iphone', 'dev_mac'],
@@ -739,10 +1325,8 @@ describe('question queueing and retirement debt', () => {
     // before every guard — retirement debt has nothing to do with whether
     // this turn may ask.
     const h = harness([])
-    writeSessionState('sup3', h.env, { last_prompt_at: AWAY })
-    registerQuestion('sup3', h.env, { question: 'Ship it?' })
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'sup3' }))
-    const first = h.recorder.receipts[0]
+    seedLive(h, 'sup3')
+    const first = 'req_live'
 
     h.recorder.failSubmits = true
     await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 'sup3' }))
@@ -759,10 +1343,8 @@ describe('question queueing and retirement debt', () => {
     // UserPromptSubmit resets session state to record presence, and that reset
     // used to take the retirement queue with it.
     const h = harness([])
-    writeSessionState('sup4', h.env, { last_prompt_at: AWAY })
-    registerQuestion('sup4', h.env, { question: 'Ship it?' })
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'sup4' }))
-    const first = h.recorder.receipts[0]
+    seedLive(h, 'sup4')
+    const first = 'req_live'
 
     // The first return is offline: the wipe parks, the drain fails, and the
     // next prompt must still find the debt.
@@ -795,22 +1377,11 @@ describe('question queueing and retirement debt', () => {
 describe('several questions in flight', () => {
   /** Route each live request its own replies; the shared list cannot say who answered what. */
   function repliesByRequest(h: Harness, byRequest: Map<string, ReplyView[]>): void {
-    const factory = h.deps.clientFactory
-    h.deps.clientFactory = () => {
-      const client = factory!()
-      return {
-        ...client,
-        replies: async (requestId: string) => ({
-          request_id: requestId,
-          reply_expires_at: null,
-          replies: byRequest.get(requestId) ?? [],
-        }),
-      } as ApiClient
-    }
+    h.recorder.repliesFor = (requestId) => byRequest.get(requestId) ?? []
   }
 
   it('escalates every registered question in one pass, each as its own notification', async () => {
-    const h = harness([], 900)
+    const h = harness([])
     writeSessionState('multi1', h.env, { last_prompt_at: AWAY })
     registerQuestion('multi1', h.env, { question: 'Ship it?' }, NOW)
     registerQuestion('multi1', h.env, { question: 'Deploy where?' }, NOW + 1)
@@ -822,12 +1393,159 @@ describe('several questions in flight', () => {
     // Each is its own notification with its own collapse key — one ask never
     // stands in for, or replaces, another.
     expect(new Set(questions.map((s) => s.draft.delivery.collapse_key)).size).toBe(2)
-    const live = readSessionState('multi1', h.env).pending
-    expect(live?.map((entry) => entry.request_id)).toEqual(['req_hook_1', 'req_hook_2'])
+    expect(readSessionState('multi1', h.env).pending).toBeUndefined()
+    expect(new Set(h.recorder.closed)).toEqual(new Set(h.recorder.receipts))
+  })
+
+  /**
+   * A registered form/ask must become a durable server request at turn-end.
+   * Codex and Claude both enter through the same Stop
+   * handler; the harness flag only changes answer injection, not settlement.
+   */
+  it('settles a registered form into a durable request_id on the Codex Stop path', async () => {
+    const h = harness([])
+    writeSessionState('codex-form', h.env, { last_prompt_at: AWAY })
+    const built = buildQuestions(
+      { form: JSON.stringify({
+          questions: [
+            { text: 'Start personally?', choices: ['Yes', 'No'] },
+            { text: 'Which region?', choices: ['US', 'EU'] },
+          ],
+        }) },
+      undefined,
+    )
+    expect(built.ok).toBe(true)
+    if (!built.ok) return
+    registerQuestion('codex-form', h.env, {
+      question: built.questions[0]!.text,
+      questions: built.questions,
+    })
+
+    // Registration alone must not submit; durability happens at turn-end.
+    expect(h.recorder.submitted).toEqual([])
+    expect(readSessionState('codex-form', h.env).pending?.[0]?.request_id).toBeUndefined()
+
+    await hookRunCommand(
+      h.deps,
+      'stop',
+      stdin({ session_id: 'codex-form' }),
+      'codex',
+    )
+
+    expect(h.recorder.submitted.filter((s) => s.draft.event === 'agent_question')).toHaveLength(1)
+    expect(readSessionState('codex-form', h.env).pending).toBeUndefined()
+    expect(h.recorder.closed).toContain(h.recorder.receipts[0])
+    expect(h.io.errLines.join('\n')).toMatch(/expired with its continuation owner/)
+  })
+
+  it('keeps a settled ask durable and collects the answer after a transient internal_error', async () => {
+    const h = harness([])
+    let polls = 0
+    const factory = h.deps.clientFactory
+    h.deps.clientFactory = () => {
+      const client = factory!()
+      return {
+        ...client,
+        replies: async (requestId: string) => {
+          polls += 1
+          if (polls <= 2) {
+            throw new ApiCallError(500, 'internal_error', 'An unexpected server error occurred.')
+          }
+          return {
+            request_id: requestId,
+            reply_expires_at: null,
+            replies: [reply({ text: 'Yes — start personally' })],
+          } satisfies ListRepliesResponse
+        },
+      } as ApiClient
+    }
+    writeSessionState('recover-500', h.env, { last_prompt_at: AWAY })
+    registerQuestion('recover-500', h.env, { question: 'Start personally?' }, NOW - 300_000)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'recover-500' }), 'codex')
+
+    // Submit recorded the durable id before any wait; a 500 must not erase it
+    // mid-flight, and recovery must still surface the late answer.
+    const questions = h.recorder.submitted.filter((s) => s.draft.event === 'agent_question')
+    expect(questions).toHaveLength(1)
+    expect(h.recorder.receipts[0]).toMatch(/^req_[A-Za-z0-9_-]{22,24}$/)
+    expect(polls).toBeGreaterThanOrEqual(3)
+    expect(h.recorder.closed).toContain(h.recorder.receipts[0])
+    expect(readSessionState('recover-500', h.env).pending).toBeUndefined()
+    const output = JSON.parse(h.io.outLines[0] ?? '{}') as { decision?: string; reason?: string }
+    expect(output.decision).toBe('block')
+    expect(output.reason).toContain('Yes — start personally')
+  })
+
+  it('stops retrying and names a permanent rejection during the blocking multi-wait', async () => {
+    const h = harness([])
+    let polls = 0
+    const factory = h.deps.clientFactory
+    h.deps.clientFactory = () => {
+      const client = factory!()
+      return {
+        ...client,
+        replies: async () => {
+          polls += 1
+          throw new ApiCallError(404, 'not_found', 'No such request.')
+        },
+      } as ApiClient
+    }
+    writeSessionState('permanent-wait', h.env, { last_prompt_at: AWAY })
+    registerQuestion('permanent-wait', h.env, { question: 'Still there?' }, NOW - 300_000)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'permanent-wait' }), 'codex')
+
+    expect(polls).toBe(1)
+    expect(readSessionState('permanent-wait', h.env).pending).toBeUndefined()
+    expect(h.io.errLines.join('\n')).toContain(
+      `${h.recorder.receipts[0]}: not_found (HTTP 404): No such request.`,
+    )
+    expect(h.io.errLines.join('\n')).not.toContain('could not reach the server')
+  })
+
+  it('distinguishes a permanent late-poll rejection from transient trouble', async () => {
+    const h = harness([])
+    let polls = 0
+    const factory = h.deps.clientFactory
+    h.deps.clientFactory = () => {
+      const client = factory!()
+      return {
+        ...client,
+        replies: async () => {
+          polls += 1
+          throw new ApiCallError(401, 'machine_revoked', 'This machine was revoked.')
+        },
+      } as ApiClient
+    }
+    writeSessionState('permanent-late', h.env, {
+      last_prompt_at: AWAY,
+      pending: [
+        {
+          question: 'Deploy?',
+          asked_at: NOW - 300_000,
+          request_id: 'req_existing',
+          collapse_key: 'question-existing',
+          device_ids: ['dev_iphone'],
+          reply_deadline_at: NOW + 60_000,
+        },
+      ],
+    })
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'permanent-late' }), 'codex')
+
+    expect(polls).toBe(1)
+    expect(h.io.errLines.join('\n')).toContain(
+      'req_existing: machine_revoked (HTTP 401): This machine was revoked.',
+    )
+    expect(h.io.errLines.join('\n')).toContain(
+      'reply polling stopped after a permanent server rejection',
+    )
+    expect(h.io.errLines.join('\n')).not.toContain('could not check whether its answer arrived')
   })
 
   it('resumes with every answer that arrived, each tied to its question', async () => {
-    const h = harness([], 900)
+    const h = harness([])
     repliesByRequest(
       h,
       new Map([
@@ -843,7 +1561,7 @@ describe('several questions in flight', () => {
 
     // Both reply windows close immediately (first answer claims each
     // question); the retirement drain closes again, which is idempotent.
-    expect(new Set(h.recorder.closed)).toEqual(new Set(['req_hook_1', 'req_hook_2']))
+    expect(new Set(h.recorder.closed)).toEqual(new Set(h.recorder.receipts))
     expect(readSessionState('multi2', h.env).pending).toBeUndefined()
     const output = JSON.parse(h.io.outLines[0] ?? '{}') as { decision?: string; reason?: string }
     expect(output.decision).toBe('block')
@@ -852,8 +1570,51 @@ describe('several questions in flight', () => {
     expect(output.reason).toContain('"Deploy where?" → "Staging"')
   })
 
+  it('journals an accepted answer until a successor Stop proves delivery', async () => {
+    const h = harness([reply({ text: 'Ship it' })])
+    writeSessionState('answer-handoff', h.env, {
+      last_prompt_at: AWAY,
+      pending: [
+        {
+          question: 'Ship it?',
+          asked_at: NOW,
+          request_id: 'req_existing',
+          collapse_key: 'question-existing',
+          device_ids: ['dev_iphone'],
+          reply_deadline_at: NOW + 60_000,
+        },
+      ],
+    })
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'answer-handoff' }))
+    const staged = readSessionState('answer-handoff', h.env)
+    expect(staged.accepted?.answers[0]?.reply.text).toBe('Ship it')
+    expect(JSON.parse(h.io.outLines.at(-1)!).decision).toBe('block')
+
+    h.io.outLines = []
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'answer-handoff' }))
+    expect(JSON.parse(h.io.outLines.at(-1)!).reason).toContain('Ship it')
+    expect(readSessionState('answer-handoff', h.env).accepted).toBeDefined()
+
+    h.io.outLines = []
+    await hookRunCommand(
+      h.deps,
+      'stop',
+      stdin({ session_id: 'answer-handoff', stop_hook_active: true }),
+    )
+    expect(h.io.outLines).toEqual([])
+    expect(readSessionState('answer-handoff', h.env).accepted).toBeUndefined()
+    expect(
+      h.recorder.submitted.find(
+        (entry) =>
+          entry.draft.event === 'question_retired' &&
+          entry.draft.lifecycle?.retires_request_id === 'req_existing',
+      )?.draft.lifecycle?.state,
+    ).toBe('answered')
+  })
+
   it('resumes with a partial answer and keeps the rest registered', async () => {
-    const h = harness([], 900)
+    const h = harness([])
     const byRequest = new Map([['req_hook_1', [reply({ text: 'Ship it' })]]])
     repliesByRequest(h, byRequest)
     writeSessionState('multi3', h.env, { last_prompt_at: AWAY })
@@ -867,7 +1628,7 @@ describe('several questions in flight', () => {
     expect(output.reason).toContain('1 more registered question is still waiting')
     const live = readSessionState('multi3', h.env).pending
     expect(live?.map((entry) => entry.question)).toEqual(['Deploy where?'])
-    expect(live?.[0]?.request_id).toBe('req_hook_2')
+    expect(live?.[0]?.request_id).toBe(h.recorder.receipts[1])
 
     // The remaining question's answer arrives before the next turn ends; the
     // late-answer path hands it over without asking anything twice.
@@ -894,14 +1655,20 @@ describe('a question that outlives its session', () => {
       }))
   }
 
-  /** Escalate a question that nobody answers, so it is live on the devices. */
+  /** State a still-owned request can have when SessionEnd races its Stop. */
   async function pushUnanswered(h: Harness, sessionId: string): Promise<string> {
-    writeSessionState(sessionId, h.env, { last_prompt_at: AWAY })
-    registerQuestion(sessionId, h.env, { question: 'Ship it?' })
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: sessionId }))
-    const requestId = h.recorder.receipts[0]
-    expect(requestId).toBeDefined()
-    return requestId!
+    writeSessionState(sessionId, h.env, {
+      last_prompt_at: AWAY,
+      pending: [{
+        question: 'Ship it?',
+        asked_at: NOW,
+        request_id: 'req_live',
+        collapse_key: 'collapse-live',
+        device_ids: ['dev_iphone'],
+        reply_deadline_at: NOW + 60_000,
+      }],
+    })
+    return 'req_live'
   }
 
   it('retires a question the harness exited on, from a later session', async () => {
@@ -1008,14 +1775,15 @@ describe('hostile input', () => {
     expect(seen).toBe('https://test.notifai.invalid')
   })
 
-  it('clamps an out-of-range away threshold instead of trusting it', () => {
+  it('clamps an out-of-range grace window instead of trusting it', () => {
     const h = harness()
     const project = mkdtempSync(path.join(os.tmpdir(), 'notifai-bounds-'))
     mkdirSync(path.join(project, '.notifai'), { recursive: true })
-    writeFileSync(path.join(project, '.notifai', 'config.toml'), 'away_after_seconds = -1\n')
+    writeFileSync(path.join(project, '.notifai', 'config.toml'), 'ask_grace_seconds = 99999\n')
     const config = loadConfig({ cwd: project, env: h.env })
-    // -1 would make someone who just typed count as absent.
-    expect(config.away_after_seconds.value).toBeGreaterThanOrEqual(5)
+    // A committed repository file must not be able to consume the waiter's
+    // whole ceiling and leave no window in which an answer is still accepted.
+    expect(config.ask_grace_seconds.value).toBeLessThanOrEqual(360)
   })
 })
 
@@ -1030,12 +1798,10 @@ describe('ask registration', () => {
 
   it('stores the validated question set, comma-bearing labels verbatim', () => {
     const h = harness()
-    expect(
-      askCommand(h.deps, 'Ship it?', {
-        choice: ['Yes, ship it', 'No, hold'],
-        session: 'a2',
-      }),
-    ).toBe(EXIT.ok)
+    const built = buildQuestions({ choice: ['Yes, ship it', 'No, hold'] }, 'Ship it?')
+    expect(built.ok).toBe(true)
+    if (!built.ok) return
+    registerQuestion('a2', h.env, { question: built.questions[0]!.text, questions: built.questions })
     expect(readSessionState('a2', h.env).pending?.[0]?.questions).toEqual([
       {
         id: 'ship-it',
@@ -1049,20 +1815,25 @@ describe('ask registration', () => {
   })
 
   it('registers a multi-question form and pushes it as one set', async () => {
-    const h = harness([reply({ text: 'Yes' })], 900)
+    const h = harness([reply({ text: 'Yes' })])
     writeSessionState('form1', h.env, { last_prompt_at: AWAY })
-    expect(
-      askCommand(h.deps, undefined, {
-        session: 'form1',
-        form: JSON.stringify({
+    const built = buildQuestions(
+      { form: JSON.stringify({
           questions: [
             { text: 'Deploy where?', choices: ['Staging', 'Production'], multi: true },
             { text: 'Anything to watch?' },
           ],
           detail: '## Context\nThe long story.',
-        }),
-      }),
-    ).toBe(EXIT.ok)
+        }) },
+      undefined,
+    )
+    expect(built.ok).toBe(true)
+    if (!built.ok) return
+    registerQuestion('form1', h.env, {
+      question: built.questions[0]!.text,
+      questions: built.questions,
+      ...(built.detail === undefined ? {} : { detail: built.detail }),
+    })
     const pending = readSessionState('form1', h.env).pending?.[0]
     expect(pending?.questions).toHaveLength(2)
     expect(pending?.detail).toContain('long story')
@@ -1087,6 +1858,34 @@ describe('ask registration', () => {
     ])
   })
 
+  it('relays the real registered identity, question text, and answer without trust or approval claims', async () => {
+    const h = harness(
+      [
+        reply({
+          text: 'BETA',
+          answers: [{ question_id: 'rollout-option', choice_ids: ['beta'], text: null }],
+        }),
+      ],
+      900,
+    )
+    writeSessionState('framing1', h.env, { last_prompt_at: AWAY })
+    const built = buildQuestions({ choice: ['ALPHA', 'BETA'] }, 'Which rollout option?')
+    expect(built.ok).toBe(true)
+    if (!built.ok) return
+    registerQuestion('framing1', h.env, {
+      question: 'Which rollout option?',
+      questions: built.questions,
+    })
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'framing1' }))
+
+    const decision = JSON.parse(h.io.outLines.at(-1)!) as { decision: string; reason: string }
+    expect(decision.decision).toBe('block')
+    expect(decision.reason).toContain('question_id rollout-option')
+    expect(decision.reason).toContain('"Which rollout option?"')
+    expect(decision.reason).toContain('"BETA"')
+    expect(decision.reason).not.toMatch(/trusted|urgent|permission|approval/i)
+  })
+
   it('acts on the latest reply when answers conflict, because it is a correction', async () => {
     const h = harness(
       [
@@ -1101,9 +1900,10 @@ describe('ask registration', () => {
       900,
     )
     writeSessionState('latest1', h.env, { last_prompt_at: AWAY })
-    expect(
-      askCommand(h.deps, 'Ship it?', { session: 'latest1', choice: ['Yes', 'No'] }),
-    ).toBe(EXIT.ok)
+    const built = buildQuestions({ choice: ['Yes', 'No'] }, 'Ship it?')
+    expect(built.ok).toBe(true)
+    if (!built.ok) return
+    registerQuestion('latest1', h.env, { question: 'Ship it?', questions: built.questions })
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'latest1' }))
 
@@ -1127,7 +1927,7 @@ describe('ask registration', () => {
       900,
     )
     writeSessionState('parts1', h.env, { last_prompt_at: AWAY })
-    expect(askCommand(h.deps, 'Which color?', { session: 'parts1' })).toBe(EXIT.ok)
+    registerQuestion('parts1', h.env, { question: 'Which color?' })
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'parts1' }))
 
@@ -1136,27 +1936,17 @@ describe('ask registration', () => {
     expect(decision.reason).toContain('"Use blue", then "actually teal"')
   })
 
-  it('resolves the session as flag, then hook pointer, then NOTIFAI_SESSION', async () => {
-    // The exported id is often a chosen label while hook state is keyed by the
-    // harness's own id, so the pointer must outrank the env var.
+  it('does not let an explicit session bypass exact active-harness proof', () => {
     const h = harness()
-    h.deps.env['NOTIFAI_SESSION'] = 'my-label'
-    await hookRunCommand(
-      h.deps,
-      'user-prompt-submit',
-      stdin({ session_id: 'real1', cwd: h.deps.cwd }),
-      'claude-code',
-    )
-    expect(askCommand(h.deps, 'Ship it?', {})).toBe(EXIT.ok)
-    expect(readSessionState('real1', h.env).pending?.[0]?.question).toBe('Ship it?')
-    expect(readSessionState('my-label', h.env).pending).toBeUndefined()
+    expect(askCommand(h.deps, 'Ship it?', { session: 'guessed' })).toBe(EXIT.usage)
+    expect(readSessionState('guessed', h.env).pending).toBeUndefined()
   })
 
-  it('falls back to NOTIFAI_SESSION where no hook has spoken', () => {
+  it('does not route from NOTIFAI_SESSION where no exact harness has spoken', () => {
     const h = harness()
     h.deps.env['NOTIFAI_SESSION'] = 'solo-session'
-    expect(askCommand(h.deps, 'Ship it?', {})).toBe(EXIT.ok)
-    expect(readSessionState('solo-session', h.env).pending?.[0]?.question).toBe('Ship it?')
+    expect(askCommand(h.deps, 'Ship it?', {})).toBe(EXIT.usage)
+    expect(readSessionState('solo-session', h.env).pending).toBeUndefined()
   })
 
   it('queues alongside incomplete live state without touching it', () => {
@@ -1174,7 +1964,7 @@ describe('ask registration', () => {
       ],
     })
 
-    expect(askCommand(h.deps, 'Another?', { session: 'incomplete' })).toBe(EXIT.ok)
+    registerQuestion('incomplete', h.env, { question: 'Another?' })
     const pending = readSessionState('incomplete', h.env).pending
     expect(pending?.map((entry) => entry.question)).toEqual(['Original?', 'Another?'])
     expect(pending?.[0]).toMatchObject({
@@ -1186,11 +1976,10 @@ describe('ask registration', () => {
   it('refuses a fifth question and names the form alternative', () => {
     const h = harness()
     for (const question of ['One?', 'Two?', 'Three?', 'Four?']) {
-      expect(askCommand(h.deps, question, { session: 'crowded' })).toBe(EXIT.ok)
+      registerQuestion('crowded', h.env, { question })
     }
 
-    expect(askCommand(h.deps, 'Five?', { session: 'crowded' })).toBe(EXIT.failed)
-    expect(h.io.errLines.join('\n')).toContain('ask --form')
+    expect(() => registerQuestion('crowded', h.env, { question: 'Five?' })).toThrow(/ask --form/)
     expect(readSessionState('crowded', h.env).pending).toHaveLength(4)
   })
 })
@@ -1202,14 +1991,52 @@ describe('user-prompt-submit hook', () => {
     expect(readSessionState('s10', h.env).last_prompt_at).toBe(NOW)
   })
 
-  it('diagnoses malformed or truncated hook input instead of silently doing nothing', async () => {
+  it('records Stop separately so a prompt hook cannot impersonate turn-end routing', async () => {
     const h = harness()
+    await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 'events' }))
+    expect(readSessionState('events', h.env).last_stop_at).toBeUndefined()
 
-    expect(await hookRunCommand(h.deps, 'user-prompt-submit', async () => '{"session_id":')).toBe(
-      EXIT.ok,
-    )
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'events' }))
+    expect(readSessionState('events', h.env).last_stop_at).toBe(NOW)
+  })
+
+  it('diagnoses partial production input as malformed or truncated', async () => {
+    const h = harness()
+    const deps = { ...h.deps, logger: createLogger({ env: h.env }) }
+    const input = new PassThrough()
+    input.write('{"session_id":')
+
+    expect(
+      await hookRunCommand(
+        deps,
+        'user-prompt-submit',
+        () => readStdinWithTimeout(input, 5),
+      ),
+    ).toBe(EXIT.ok)
 
     expect(h.io.errLines.join('\n')).toMatch(/malformed|truncated/i)
+    const records = readLogRecords(h.env, { limit: 10 }).records
+    expect(records.map((record) => record.event)).toEqual(['hook.start', 'hook.end'])
+    expect(records.at(-1)?.data).toMatchObject({ reason: 'malformed-input' })
+  })
+
+  it('records an empty production input timeout before failing open', async () => {
+    const h = harness()
+    const deps = { ...h.deps, logger: createLogger({ env: h.env }) }
+    const input = new PassThrough()
+
+    expect(
+      await hookRunCommand(
+        deps,
+        'user-prompt-submit',
+        () => readStdinWithTimeout(input, 5),
+      ),
+    ).toBe(EXIT.ok)
+
+    const records = readLogRecords(h.env, { limit: 10 }).records
+    expect(records.map((record) => record.event)).toEqual(['hook.start', 'hook.end'])
+    expect(records.at(-1)?.data).toMatchObject({ reason: 'input-read-failed' })
+    expect(records.at(-1)?.data?.['message']).toMatch(/timed out waiting/)
   })
 
   it('explains when a missing machine credential makes a hook skip routing', async () => {
@@ -1224,29 +2051,21 @@ describe('user-prompt-submit hook', () => {
   })
 
   it('preserves a delivered question through a second ask and the prompt transition', async () => {
-    const h = harness([], 900)
-    await hookRunCommand(
-      h.deps,
-      'user-prompt-submit',
-      stdin({ session_id: 'transition', cwd: h.deps.cwd }),
-      'claude-code',
-    )
-    expect(askCommand(h.deps, 'Ship it?', { choice: ['Yes', 'No'] })).toBe(EXIT.ok)
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'transition', cwd: h.deps.cwd }))
-
-    const live = readSessionState('transition', h.env).pending?.[0]
-    expect(live).toMatchObject({
+    const h = harness([])
+    const live = {
       question: 'Ship it?',
-      request_id: 'req_hook_1',
+      request_id: 'req_live',
+      collapse_key: 'collapse-live',
       device_ids: ['dev_iphone', 'dev_mac'],
-    })
-    expect(live?.collapse_key).toMatch(/^notifai-hook-/)
+      reply_deadline_at: NOW + 60_000,
+    }
+    writeSessionState('transition', h.env, { last_prompt_at: AWAY, pending: [live] })
 
     // A second plain `ask` resolves through the project pointer and joins the
     // queue behind the live question — it must not touch it. The next prompt
     // then resets presence before another Stop can run — the transition that
     // used to erase the retirement debt.
-    expect(askCommand(h.deps, 'Deploy it?', { choice: ['Staging', 'Production'] })).toBe(EXIT.ok)
+    registerQuestion('transition', h.env, { question: 'Deploy it?' })
     const queued = readSessionState('transition', h.env)
     expect(queued.retiring ?? []).toEqual([])
     expect(queued.pending?.map((entry) => entry.question)).toEqual(['Ship it?', 'Deploy it?'])
@@ -1258,16 +2077,17 @@ describe('user-prompt-submit hook', () => {
       'claude-code',
     )
 
-    // The delivered question retires truthfully; the never-delivered second
-    // one has nothing on any device and leaves no trace.
+    // The delivered question retires truthfully. The never-delivered second
+    // one must remain queued: if Codex skipped Stop, erasing it here loses the
+    // only copy before it ever reached a device.
     const retirement = h.recorder.submitted.find(
       (submission) => submission.draft.event === 'question_retired',
     )?.draft
-    expect(retirement?.delivery.collapse_key).toBe(live?.collapse_key)
+    expect(retirement?.delivery.collapse_key).toBe(live.collapse_key)
     expect(retirement?.lifecycle).toEqual({
       tier: 'done',
       state: 'answered_elsewhere',
-      retires_request_id: live?.request_id,
+      retires_request_id: live.request_id,
     })
     expect(retirement?.targets).toEqual({
       mode: 'selected',
@@ -1276,28 +2096,29 @@ describe('user-prompt-submit hook', () => {
     expect(
       h.recorder.submitted.filter((s) => s.draft.event === 'question_retired'),
     ).toHaveLength(1)
+    expect(readSessionState('transition', h.env).pending?.map((entry) => entry.question)).toEqual([
+      'Deploy it?',
+    ])
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'transition', cwd: h.deps.cwd }))
+    expect(readSessionState('transition', h.env).pending).toBeUndefined()
   })
 
-  it('retires a question a real timed-out Stop left live on the devices', async () => {
-    // Drives the actual flow rather than hand-writing state: the previous
-    // version of this test fabricated a shape production never wrote, so it
-    // passed while the retirement path was unreachable.
+  it('retires a real timed-out Stop before a later prompt can accept an answer', async () => {
     const h = harness([])
     writeSessionState('s11', h.env, { last_prompt_at: AWAY })
     registerQuestion('s11', h.env, { question: 'Which environment?' })
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 's11' }))
-    const live = readSessionState('s11', h.env).pending?.[0]
-    expect(live?.request_id).toBe('req_hook_1')
-    expect(live?.collapse_key).toBeDefined()
+    expect(readSessionState('s11', h.env).pending).toBeUndefined()
+    const retirementCount = h.recorder.submitted.filter(
+      (entry) => entry.draft.event === 'question_retired',
+    ).length
 
     await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 's11', cwd: '/repo' }))
 
-    expect(h.recorder.closed).toEqual(['req_hook_1'])
-    const retirement = h.recorder.submitted.at(-1)?.draft
-    expect(retirement?.presentation.title).toBe('Answered in the terminal')
-    expect(retirement?.delivery.collapse_key).toBe(live?.collapse_key)
-    expect(retirement?.reply).toBeUndefined()
+    expect(h.recorder.closed).toContain(h.recorder.receipts[0])
+    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'question_retired')).toHaveLength(retirementCount + 1)
   })
 
   it('marks the retirement done/answered_elsewhere so it ships silently', async () => {
@@ -1305,11 +2126,16 @@ describe('user-prompt-submit hook', () => {
     // lifecycle update, which the server renders as a background push — the
     // old "Answered" tombstone alert told the user what they just did.
     const h = harness([])
-    writeSessionState('s15', h.env, { last_prompt_at: AWAY })
-    registerQuestion('s15', h.env, { question: 'Which environment?' })
-
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 's15' }))
-    expect(h.recorder.submitted[0]?.draft.lifecycle).toEqual({ tier: 'needs_you' })
+    writeSessionState('s15', h.env, {
+      last_prompt_at: AWAY,
+      pending: [{
+        question: 'Which environment?',
+        request_id: 'req_live',
+        collapse_key: 'collapse-live',
+        device_ids: ['dev_iphone'],
+        reply_deadline_at: NOW + 60_000,
+      }],
+    })
 
     await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 's15', cwd: '/repo' }))
 
@@ -1319,21 +2145,26 @@ describe('user-prompt-submit hook', () => {
       state: 'answered_elsewhere',
       // The history-entry correlation id: companions key entries by request
       // id and never persisted the collapse key.
-      retires_request_id: 'req_hook_1',
+      retires_request_id: 'req_live',
     })
   })
 
   it('retires as done/answered when the answer came from a device', async () => {
-    const h = harness([reply({ text: 'Yes' })], 900)
+    const h = harness([reply({ text: 'Yes' })])
     registerQuestion('s16', h.env, { question: 'Ship it?' })
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 's16' }))
+    await hookRunCommand(
+      h.deps,
+      'stop',
+      stdin({ session_id: 's16', stop_hook_active: true }),
+    )
 
     const retirement = h.recorder.submitted.find((s) => s.draft.event === 'question_retired')
     expect(retirement?.draft.lifecycle).toEqual({
       tier: 'done',
       state: 'answered',
-      retires_request_id: 'req_hook_1',
+      retires_request_id: h.recorder.receipts[0],
     })
   })
 
@@ -1364,19 +2195,101 @@ describe('user-prompt-submit hook', () => {
 })
 
 describe('session-end hook', () => {
-  it('drops local state without touching the network, inside its ~1s budget', async () => {
+  it('drops local state without touching the network and records the lifecycle', async () => {
     const h = harness()
     writeSessionState('s12', h.env, { last_prompt_at: NOW })
+    const deps = { ...h.deps, logger: createLogger({ env: h.env }) }
 
-    const code = await hookRunCommand(h.deps, 'session-end', stdin({ session_id: 's12' }))
+    const code = await hookRunCommand(deps, 'session-end', stdin({ session_id: 's12' }))
 
     expect(code).toBe(EXIT.ok)
     expect(readSessionState('s12', h.env)).toEqual({})
     expect(h.recorder.closed).toEqual([])
+    const records = readLogRecords(h.env, { limit: 10 }).records
+    expect(records.map((record) => record.event)).toEqual(['hook.start', 'hook.end'])
+    expect(records.at(-1)?.data).toMatchObject({ outcome: 'cleaned', queued_retirements: 0 })
+  })
+
+  it('runs the real Codex SessionEnd cleanup before contended diagnostics and exits fail-open', async () => {
+    const h = harness()
+    const sessionId = 'session-end-budget'
+    writeSessionState(sessionId, h.env, { last_prompt_at: NOW })
+    writeProjectSession(h.deps.cwd, h.env, sessionId, Date.now(), 'codex')
+    const configFile = sessionConfigPath(sessionId, h.env)
+    mkdirSync(path.dirname(configFile), { recursive: true })
+    writeFileSync(configFile, 'ask_notifications = false\nlog_level = "info"\n')
+    expect(loadConfig({ cwd: h.deps.cwd, env: h.env, sessionId }).ask_notifications).toMatchObject({
+      value: false,
+      source: expect.stringMatching(/^session:/),
+    })
+
+    const stateFile = path.join(
+      stateDir(h.env),
+      'sessions',
+      `${sanitizeSessionId(sessionId)}.json`,
+    )
+    const projectPointer = projectSessionPointerPath(h.deps.cwd, h.env)
+    expect(existsSync(stateFile)).toBe(true)
+    expect(existsSync(configFile)).toBe(true)
+    expect(existsSync(projectPointer)).toBe(true)
+
+    const logLock = `${activeLogPath(h.env)}.lock`
+    const holder = runSessionEndLogLockHolder(h.deps.cwd, h.env, logLock)
+    let cli: ReturnType<typeof runSessionEndCli> | undefined
+    try {
+      await waitUntil(
+        () => existsSync(holder.readyPath),
+        10_000,
+        'SessionEnd log lock worker did not acquire its bakery ticket',
+      )
+      expect(readdirSync(logLock).filter((name) => name.startsWith('ticket-'))).toHaveLength(1)
+
+      cli = runSessionEndCli(h.env, h.deps.cwd, sessionId)
+      await waitUntil(
+        () =>
+          readdirSync(logLock).filter((name) => name.startsWith('ticket-')).length >= 2,
+        700,
+        'the real Codex hook did not reach contended diagnostics before its deadline',
+      )
+
+      // Reaching the second bakery ticket proves main.ts preAction did not write
+      // first. Every durable cleanup must already be visible while diagnostics
+      // are still blocked behind the live holder.
+      expect(existsSync(stateFile)).toBe(false)
+      expect(existsSync(configFile)).toBe(false)
+      expect(existsSync(projectPointer)).toBe(false)
+
+      const result = await cli.done
+      expect(result).toMatchObject({ code: EXIT.ok, signal: null, stdout: '', stderr: '' })
+      expect(result.durationMs).toBeGreaterThanOrEqual(900)
+      expect(result.durationMs).toBeLessThan(2_000)
+      // The diagnostic contender timed out rather than stealing the held lock,
+      // disabled its sink, and still let the real CLI exit successfully.
+      expect(existsSync(activeLogPath(h.env))).toBe(false)
+
+      writeFileSync(holder.releasePath, 'release')
+      await holder.done
+
+      expect(readSessionState(sessionId, h.env)).toEqual({})
+      expect(readProjectSession(h.deps.cwd, h.env, Date.now())).toBeNull()
+      expect(loadConfig({ cwd: h.deps.cwd, env: h.env, sessionId }).ask_notifications).toEqual({
+        value: true,
+        source: 'default',
+      })
+    } finally {
+      if (!existsSync(holder.releasePath)) writeFileSync(holder.releasePath, 'release')
+      if (cli?.child.exitCode === null && cli.child.signalCode === null) cli.child.kill('SIGKILL')
+      if (holder.child.exitCode === null && holder.child.signalCode === null) {
+        holder.child.kill('SIGKILL')
+      }
+      rmSync(h.deps.cwd, { recursive: true, force: true })
+    }
   })
 
-  it('clears only the ending session project pointer', async () => {
+  it('clears only the ending session from a concurrent project index', async () => {
     const h = harness()
+    writeSessionState('still-running', h.env, { last_prompt_at: NOW })
+    writeProjectSession(h.deps.cwd, h.env, 'still-running', NOW - 1, 'codex')
     await hookRunCommand(
       h.deps,
       'user-prompt-submit',
@@ -1384,6 +2297,15 @@ describe('session-end hook', () => {
       'claude-code',
     )
     expect(readProjectSession(h.deps.cwd, h.env, NOW)).toBe('ending')
+    expect(
+      readMatchingProjectSessionPointer(
+        h.deps.cwd,
+        h.env,
+        NOW,
+        'still-running',
+        'codex',
+      ),
+    ).toEqual({ sessionId: 'still-running', harness: 'codex' })
 
     await hookRunCommand(
       h.deps,
@@ -1392,7 +2314,16 @@ describe('session-end hook', () => {
       'claude-code',
     )
 
-    expect(readProjectSession(h.deps.cwd, h.env, NOW)).toBeNull()
+    expect(readProjectSession(h.deps.cwd, h.env, NOW)).toBe('still-running')
+    expect(
+      readMatchingProjectSessionPointer(
+        h.deps.cwd,
+        h.env,
+        NOW,
+        'still-running',
+        'codex',
+      ),
+    ).toEqual({ sessionId: 'still-running', harness: 'codex' })
   })
 
   it('preserves incomplete live state and reports why it cannot retire it', async () => {
@@ -1430,7 +2361,7 @@ describe('telling concurrent agents apart', () => {
     // The hook has always known session_id and never passed it on, so two
     // agents in separate worktrees produced identical notifications and the
     // user could answer the wrong one's question.
-    const h = harness([], 900)
+    const h = harness([])
     registerQuestion('sess-abc', h.env, { question: 'Ship it?' }, NOW)
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'sess-abc' }))
@@ -1439,17 +2370,22 @@ describe('telling concurrent agents apart', () => {
   })
 
   it('stamps the retirement too, so it lands on the right agent’s notification', async () => {
-    const h = harness([reply({ text: 'Yes' })], 900)
+    const h = harness([reply({ text: 'Yes' })])
     registerQuestion('sess-abc', h.env, { question: 'Ship it?' }, NOW)
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'sess-abc' }))
+    await hookRunCommand(
+      h.deps,
+      'stop',
+      stdin({ session_id: 'sess-abc', stop_hook_active: true }),
+    )
 
     const retirement = h.recorder.submitted.find((s) => s.draft.event === 'question_retired')
     expect(retirement?.draft.session).toBe('sess-abc')
   })
 
   it('prefers a name the user chose over the harness UUID', async () => {
-    const h = harness([], 900)
+    const h = harness([])
     h.env['NOTIFAI_SESSION'] = 'migration-worktree'
     registerQuestion('sess-abc', h.env, { question: 'Ship it?' }, NOW)
 
@@ -1460,44 +2396,19 @@ describe('telling concurrent agents apart', () => {
 })
 
 describe('clock jumps', () => {
-  const config = loadConfig({ cwd: '/nowhere', env: {} })
-
-  it('does not hijack a terminal because the clock jumped forward', () => {
-    // NTP correction or a VM resume moves `now` without any time passing for
-    // the person sitting at the keyboard. Without an idle source there is
-    // nothing to check the delta against, so a huge one is not evidence.
-    const state = { last_prompt_at: NOW - 400 * 24 * 3600 * 1000 }
-    expect(isUserAway(state, config, NOW, null)).toBe(false)
-  })
-
-  it('does not read a backward jump as the user being present either', () => {
-    // A negative delta is nonsense, not freshness. It resolves the same way:
-    // no evidence, so leave the terminal alone.
-    expect(isUserAway({ last_prompt_at: NOW + 60_000 }, config, NOW, null)).toBe(false)
-  })
-
-  it('still escalates on an ordinary long silence', () => {
-    expect(isUserAway({ last_prompt_at: NOW - 3600_000 }, config, NOW, null)).toBe(true)
-  })
-
-  it('lets the OS idle signal decide regardless of the wall clock', () => {
-    // The idle probe measures elapsed time directly, so it is unaffected — and
-    // it outranks the proxy anyway.
-    const nonsense = { last_prompt_at: NOW + 999_999_999 }
-    expect(isUserAway(nonsense, config, NOW, 900)).toBe(true)
-    expect(isUserAway(nonsense, config, NOW, 1)).toBe(false)
-  })
-
-  it('does not let a stamp from the future hold the terminal past the budget', async () => {
-    // asked_at is wall-clock too. A future stamp used to make the grace window
-    // unreachable, blocking Stop until the harness killed it.
-    const h = harness([], 900)
+  it('does not let a stamp from the future consume the whole waiter ceiling', async () => {
+    // `asked_at` is wall-clock, and an NTP correction or VM resume can move it.
+    // A stamp thirty days out would otherwise make the grace window unreachable
+    // and leave nothing of the ceiling for an answer to arrive in.
+    const h = harness([])
+    writeGlobalConfig(h, 'ask_grace_seconds = 300\n')
     registerQuestion('sess-jump', h.env, { question: 'Ship it?' }, NOW + 30 * 24 * 3600 * 1000)
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'sess-jump' }))
 
-    // It escalated rather than spinning: the window restarted from now.
     expect(h.recorder.submitted.length).toBeGreaterThan(0)
+    // The window ran from now, not from the impossible stamp.
+    expect(h.deps.now?.()).toBeGreaterThanOrEqual(NOW + 300_000)
   })
 })
 
@@ -1694,13 +2605,33 @@ describe('two hooks racing one question', () => {
     // A crashed hook must not suppress every question for this session for
     // ever — that is worse than the duplicate the claim prevents.
     const h = harness()
-    claimQuestionPush('race3', h.env, REAL - 10 * 60_000)
+    const file = path.join(stateDir(h.env), 'sessions', `${sanitizeSessionId('race3')}.claim`)
+    mkdirSync(path.dirname(file), { recursive: true })
+    writeFileSync(
+      file,
+      `${JSON.stringify({ pid: 999_999_999, at: REAL - 1, token: 'dead' })}\n`,
+    )
     expect(claimQuestionPush('race3', h.env, REAL)).toBe(true)
   })
 
+  it('never steals an old claim while its process is still alive', () => {
+    const h = harness()
+    expect(claimQuestionPush('race-live', h.env, REAL - 10 * 60_000)).toBe(true)
+    expect(claimQuestionPush('race-live', h.env, REAL)).toBe(false)
+  })
+
   it('serializes a contender that arrives while a stale claim is being replaced', () => {
     const h = harness()
-    claimQuestionPush('race-break', h.env, REAL - 10 * 60_000)
+    const file = path.join(
+      stateDir(h.env),
+      'sessions',
+      `${sanitizeSessionId('race-break')}.claim`,
+    )
+    mkdirSync(path.dirname(file), { recursive: true })
+    writeFileSync(
+      file,
+      `${JSON.stringify({ pid: 999_999_999, at: REAL - 10 * 60_000, token: 'dead' })}\n`,
+    )
     let contender: ReturnType<typeof claimQuestionPush> | undefined
 
     const recovered = claimQuestionPush('race-break', h.env, REAL, () => {
@@ -1718,7 +2649,7 @@ describe('two hooks racing one question', () => {
   })
 
   it('sends one notification when a second Stop arrives mid-flight', async () => {
-    const h = harness([], 900)
+    const h = harness([])
     writeSessionState('race5', h.env, { last_prompt_at: AWAY })
     registerQuestion('race5', h.env, { question: 'Ship it?' })
     // Standing in for the other process: the claim is already held.
@@ -1729,11 +2660,57 @@ describe('two hooks racing one question', () => {
     expect(h.recorder.submitted).toHaveLength(0)
     expect(h.io.errLines.join(" ")).toContain('already handling')
   })
+
+  it('resumes the agent once when two Stops collect the same late answer', async () => {
+    const answers: ReplyView[] = []
+    const h = harness(answers)
+    writeSessionState('race-late-answer', h.env, {
+      last_prompt_at: AWAY,
+      pending: [
+        {
+          question: 'Ship it?',
+          asked_at: NOW,
+          request_id: 'req_existing',
+          collapse_key: 'question-existing',
+          device_ids: ['dev_iphone'],
+          reply_deadline_at: NOW + 60_000,
+        },
+      ],
+    })
+    answers.push(reply({ text: 'Ship it' }))
+    h.io.outLines = []
+
+    let polls = 0
+    let markFirstPoll: (() => void) | undefined
+    const firstPoll = new Promise<void>((resolve) => {
+      markFirstPoll = resolve
+    })
+    let releasePolls: (() => void) | undefined
+    const heldPoll = new Promise<void>((resolve) => {
+      releasePolls = resolve
+    })
+    h.recorder.beforeReplies = async () => {
+      polls += 1
+      markFirstPoll?.()
+      await heldPoll
+    }
+
+    const firstStop = hookRunCommand(h.deps, 'stop', stdin({ session_id: 'race-late-answer' }))
+    await firstPoll
+    const secondStop = hookRunCommand(h.deps, 'stop', stdin({ session_id: 'race-late-answer' }))
+    await Promise.race([secondStop, new Promise<void>((resolve) => setImmediate(resolve))])
+    releasePolls?.()
+    await Promise.all([firstStop, secondStop])
+
+    const resumes = h.io.outLines.map((line) => JSON.parse(line) as { decision?: string })
+    expect(polls).toBe(1)
+    expect(resumes.filter((entry) => entry.decision === 'block')).toHaveLength(1)
+  })
 })
 
 describe('question registration racing a Stop submission', () => {
-  it('keeps both questions when a new ask races the older submit', async () => {
-    const h = harness([], 900)
+  it('keeps the new question when the older owner expires', async () => {
+    const h = harness([])
     writeSessionState('submit-race', h.env, { last_prompt_at: AWAY })
     registerQuestion('submit-race', h.env, { question: 'Old question?' }, NOW)
     h.recorder.beforeQuestionSubmit = () => {
@@ -1743,20 +2720,20 @@ describe('question registration racing a Stop submission', () => {
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'submit-race' }))
 
-    // The racing ask appended; the in-flight submit still finds its own entry
-    // and records the delivery ids on it. Nobody retires anybody.
+    // The racing ask appended and remains unasked. The already-delivered old
+    // question is retired when this Stop owner reaches its deadline, so it
+    // cannot accept a phone answer after the hook has returned.
     const state = readSessionState('submit-race', h.env)
-    expect(state.pending?.map((entry) => entry.question)).toEqual([
-      'Old question?',
-      'New question?',
-    ])
-    expect(state.pending?.[0]?.request_id).toBe('req_hook_1')
-    expect(state.pending?.[1]?.request_id).toBeUndefined()
-    expect(state.retiring ?? []).toEqual([])
+    expect(state.pending?.map((entry) => entry.question)).toEqual(['New question?'])
+    expect(state.pending?.[0]?.request_id).toBeUndefined()
+    expect(h.recorder.closed).toContain(h.recorder.receipts[0])
+    expect(state.retiring).toContainEqual(
+      expect.objectContaining({ request_id: h.recorder.receipts[0], state: 'expired' }),
+    )
   })
 
   it('keeps the newer question when the older in-flight question receives an answer', async () => {
-    const h = harness([reply({ text: 'Old answer' })], 900)
+    const h = harness([reply({ text: 'Old answer' })])
     writeSessionState('answer-race', h.env, { last_prompt_at: AWAY })
     registerQuestion('answer-race', h.env, { question: 'Old question?' }, NOW)
     h.recorder.beforeQuestionSubmit = () => {
@@ -1768,12 +2745,603 @@ describe('question registration racing a Stop submission', () => {
 
     const state = readSessionState('answer-race', h.env)
     expect(state.pending?.map((entry) => entry.question)).toEqual(['New question?'])
+    expect(state.accepted?.answers[0]?.pending.request_id).toBe(h.recorder.receipts[0])
+    expect(state.accepted?.answers[0]?.reply.text).toBe('Old answer')
+  })
+})
+
+describe('Claude Code Stop wake route', () => {
+  function claudeWake(status: 'idle' | 'busy' = 'idle'): ClaudeWakeAdapters & {
+    sent: string[]
+    resumed: string[]
+    sleeps: number[]
+  } {
+    const sent: string[] = []
+    const resumed: string[] = []
+    const sleeps: number[] = []
+    return {
+      sent,
+      resumed,
+      sleeps,
+      async listAgents() {
+        return [
+          {
+            pid: 12345,
+            sessionId: 'claude-route',
+            startedAt: NOW,
+            status,
+          },
+        ]
+      },
+      readDescriptor() {
+        return {
+          pid: 12345,
+          sessionId: 'claude-route',
+          cwd: '/tmp/claude-route',
+          startedAt: NOW,
+          procStart: 'Wed Aug 12 08:17:53 2026',
+          version: '2.1.228',
+          peerProtocol: 1,
+          messagingSocketPath: '/tmp/cc-socks/12345.sock',
+          status,
+        }
+      },
+      async sendSocket(_socketPath, line) {
+        sent.push(line)
+      },
+      async resume(_sessionId, _cwd, context) {
+        resumed.push(context)
+      },
+      async sleep(milliseconds) {
+        sleeps.push(milliseconds)
+      },
+    }
+  }
+
+  it('routes an accepted answer through the Claude inbox instead of hook stdout', async () => {
+    const h = harness([reply({ text: 'BETA' })])
+    writeGlobalConfig(h, 'ask_grace_seconds = 0\n')
+    writeSessionState('claude-route', h.env, { last_prompt_at: AWAY })
+    const built = buildQuestions({ choice: ['ALPHA', 'BETA'] }, 'Which rollout option?')
+    expect(built.ok).toBe(true)
+    if (!built.ok) return
+    registerQuestion('claude-route', h.env, {
+      question: 'Which rollout option?',
+      questions: built.questions,
+    })
+    const wake = claudeWake()
+
+    await hookRunCommand(
+      { ...h.deps, claudeWake: wake, claudeSourcePid: 12345 },
+      'stop',
+      stdin({ session_id: 'claude-route', cwd: '/tmp/claude-route' }),
+      'claude-code',
+    )
+
+    expect(h.io.outLines).toEqual([])
+    expect(wake.sent).toHaveLength(1)
+    const message = JSON.parse(wake.sent[0]!) as {
+      type: string
+      message: { role: string; content: string }
+    }
+    expect(message).toMatchObject({ type: 'user', message: { role: 'user' } })
+    expect(message.message.content).toContain('question_id')
+    expect(message.message.content).toContain('"Which rollout option?"')
+    expect(message.message.content).toContain('"BETA"')
+    expect(message.message.content).not.toMatch(/trusted|urgent|permission|approval/i)
+    expect(wake.sleeps).toEqual([CLAUDE_POST_SEND_LIVENESS_MS])
+    expect(readSessionState('claude-route', h.env).accepted).toBeDefined()
+  })
+
+  /** One answer already accepted and journaled, ready for the next Stop. */
+  function journaledAnswer(
+    h: Harness,
+    options: { recordedAt?: number; deliveredAt?: number } = {},
+  ): void {
+    const recordedAt = options.recordedAt ?? NOW
+    writeSessionState('claude-route', h.env, {
+      ...readSessionState('claude-route', h.env),
+      accepted: {
+        ...(options.deliveredAt === undefined
+          ? {}
+          : { delivered_at: options.deliveredAt, delivered_route: 'inbox-socket' }),
+        answers: [
+          {
+            pending: {
+              question: 'Which rollout option?',
+              request_id: 'req_existing',
+              collapse_key: 'question-existing',
+              device_ids: ['dev_iphone'],
+            },
+            reply: reply({ text: 'BETA' }),
+            replies: [reply({ text: 'BETA' })],
+          },
+        ],
+        remaining: 0,
+        recorded_at: recordedAt,
+      },
+    })
+  }
+
+  it('settles a socket delivery so the woken turn cannot redeliver the answer', async () => {
+    // The exact device-proof failure. A socket delivery starts a brand-new turn
+    // rather than continuing this one, so the Stop that ends the woken turn
+    // reports stop_hook_active=false — for ever. While that flag was the only
+    // acknowledgement, the journal never settled and every turn-end delivered
+    // the same answer again: 250 times, in the transcript that found this.
+    const h = harness([])
+    journaledAnswer(h)
+    const wake = claudeWake()
+    const deps = { ...h.deps, claudeWake: wake, claudeSourcePid: 12345 }
+    const stop = (stopHookActive: boolean) =>
+      hookRunCommand(
+        deps,
+        'stop',
+        stdin({
+          session_id: 'claude-route',
+          cwd: '/tmp/claude-route',
+          stop_hook_active: stopHookActive,
+        }),
+        'claude-code',
+      )
+
+    await stop(false)
+
+    expect(wake.sent).toHaveLength(1)
+    const delivered = readSessionState('claude-route', h.env).accepted
+    expect(delivered?.delivered_route).toBe('inbox-socket')
+    expect(typeof delivered?.delivered_at).toBe('number')
+
+    // Three more turn-ends of the woken session, none of them a continuation.
+    await stop(false)
+    await stop(false)
+    await stop(false)
+
+    expect(wake.sent).toHaveLength(1)
+    expect(wake.resumed).toEqual([])
+    expect(readSessionState('claude-route', h.env).accepted).toBeUndefined()
+    // Settled, not merely dropped: the answered question is retired truthfully.
     expect(
       h.recorder.submitted.find(
         (entry) =>
           entry.draft.event === 'question_retired' &&
-          entry.draft.lifecycle?.retires_request_id === 'req_hook_1',
+          entry.draft.lifecycle?.retires_request_id === 'req_existing',
       )?.draft.lifecycle?.state,
     ).toBe('answered')
   })
+
+  it('applies the continuation cap to a woken turn that never sets stop_hook_active', async () => {
+    // The chained loop the cap exists for, on a route that starts new turns.
+    // Keyed to stop_hook_active the cap could never fire here at all.
+    const h = harness([])
+    writeGlobalConfig(h, 'ask_grace_seconds = 0\n')
+    writeSessionState('claude-route', h.env, {
+      last_prompt_at: AWAY,
+      continuation: { answered_at: NOW - 2000, count: MAX_CONTINUATION_COUNT - 1 },
+    })
+    journaledAnswer(h, { recordedAt: NOW - 1000, deliveredAt: NOW - 900 })
+    // The woken turn asked a genuinely new question before it ended.
+    registerQuestion('claude-route', h.env, { question: 'And after that?' }, NOW)
+    const wake = claudeWake()
+
+    await hookRunCommand(
+      { ...h.deps, claudeWake: wake, claudeSourcePid: 12345 },
+      'stop',
+      stdin({
+        session_id: 'claude-route',
+        cwd: '/tmp/claude-route',
+        stop_hook_active: false,
+      }),
+      'claude-code',
+    )
+
+    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toEqual(
+      [],
+    )
+    expect(readSessionState('claude-route', h.env).pending?.[0]?.question).toBe('And after that?')
+    expect(h.io.errLines.join('\n')).toContain(
+      `continuation limit (${MAX_CONTINUATION_COUNT}) reached`,
+    )
+  })
+
+  it('uses the accepted journal as the loop guard after a socket wake fires Stop again', async () => {
+    const h = harness([])
+    writeSessionState('claude-route', h.env, {
+      accepted: {
+        answers: [
+          {
+            pending: {
+              question: 'Which rollout option?',
+              request_id: 'req_existing',
+              collapse_key: 'question-existing',
+              device_ids: ['dev_iphone'],
+            },
+            reply: reply({ text: 'BETA' }),
+            replies: [reply({ text: 'BETA' })],
+          },
+        ],
+        remaining: 0,
+        recorded_at: NOW,
+      },
+    })
+    const wake = claudeWake()
+
+    await hookRunCommand(
+      { ...h.deps, claudeWake: wake, claudeSourcePid: 12345 },
+      'stop',
+      stdin({
+        session_id: 'claude-route',
+        cwd: '/tmp/claude-route',
+        stop_hook_active: true,
+      }),
+      'claude-code',
+    )
+
+    expect(wake.sent).toEqual([])
+    expect(wake.resumed).toEqual([])
+    expect(h.io.outLines).toEqual([])
+    expect(readSessionState('claude-route', h.env).accepted).toBeUndefined()
+  })
+})
+
+describe('Codex Stop wake route', () => {
+  const CODEX_THREAD = '019ff69d-a07f-7161-ab6e-bd06b3b93c8e'
+
+  function codexWake(
+    options: { sourceAlive?: boolean; probe?: CodexWakeObservation } = {},
+  ): CodexWakeAdapters & { resumed: string[]; probed: string[] } {
+    const resumed: string[] = []
+    const probed: string[] = []
+    return {
+      resumed,
+      probed,
+      probeThreadWriter(lockPath) {
+        probed.push(lockPath)
+        return options.probe ?? { state: 'stopped' }
+      },
+      sourceAlive() {
+        return options.sourceAlive ?? true
+      },
+      async resume(_threadId, _cwd, context) {
+        resumed.push(context)
+      },
+    }
+  }
+
+  function journaledAnswer(h: Harness): void {
+    writeSessionState(CODEX_THREAD, h.env, {
+      accepted: {
+        answers: [
+          {
+            pending: {
+              question: 'Which rollout option?',
+              request_id: 'req_existing',
+              collapse_key: 'question-existing',
+              device_ids: ['dev_iphone'],
+            },
+            reply: reply({ text: 'BETA' }),
+            replies: [reply({ text: 'BETA' })],
+          },
+        ],
+        remaining: 0,
+        recorded_at: NOW,
+      },
+    })
+  }
+
+  it('continues the held turn with decision:block when the answer arrives during the hold', async () => {
+    const h = harness([reply({ text: 'BETA' })])
+    writeGlobalConfig(h, 'ask_grace_seconds = 0\n')
+    writeSessionState(CODEX_THREAD, h.env, { last_prompt_at: AWAY })
+    const built = buildQuestions({ choice: ['ALPHA', 'BETA'] }, 'Which rollout option?')
+    expect(built.ok).toBe(true)
+    if (!built.ok) return
+    registerQuestion(CODEX_THREAD, h.env, {
+      question: 'Which rollout option?',
+      questions: built.questions,
+    })
+    const wake = codexWake()
+
+    await hookRunCommand(
+      { ...h.deps, codexWake: wake, codexSourcePid: 12345 },
+      'stop',
+      stdin({ session_id: CODEX_THREAD, cwd: '/tmp/codex-route' }),
+      'codex',
+    )
+
+    expect(h.io.outLines).toHaveLength(1)
+    const decision = JSON.parse(h.io.outLines[0]!) as { decision: string; reason: string }
+    expect(decision.decision).toBe('block')
+    expect(decision.reason).toContain('"BETA"')
+    // The default route owes the thread-writer lock nothing: a live Codex is
+    // reading this stdout, and a probe could only take the answer away.
+    expect(wake.probed).toEqual([])
+    expect(wake.resumed).toEqual([])
+    expect(readSessionState(CODEX_THREAD, h.env).accepted).toBeDefined()
+  })
+
+  it('replays an answer journaled after the hold on the next Stop', async () => {
+    const h = harness([])
+    journaledAnswer(h)
+    const wake = codexWake()
+
+    await hookRunCommand(
+      { ...h.deps, codexWake: wake, codexSourcePid: 12345 },
+      'stop',
+      stdin({ session_id: CODEX_THREAD, cwd: '/tmp/codex-route' }),
+      'codex',
+    )
+
+    expect(h.io.outLines).toHaveLength(1)
+    expect(JSON.parse(h.io.outLines[0]!)).toMatchObject({ decision: 'block' })
+    // Still journaled: only a successor Stop proves the continued turn ran.
+    expect(readSessionState(CODEX_THREAD, h.env).accepted).toBeDefined()
+  })
+
+  it('cold-resumes the journaled answer when the Codex process is gone and no writer holds the thread', async () => {
+    const h = harness([])
+    journaledAnswer(h)
+    const wake = codexWake({ sourceAlive: false, probe: { state: 'stopped' } })
+
+    await hookRunCommand(
+      { ...h.deps, codexWake: wake, codexSourcePid: 12345 },
+      'stop',
+      stdin({ session_id: CODEX_THREAD, cwd: '/tmp/codex-route' }),
+      'codex',
+    )
+
+    expect(h.io.outLines).toEqual([])
+    expect(wake.resumed).toHaveLength(1)
+    expect(wake.resumed[0]).toContain('"BETA"')
+    expect(wake.probed).toHaveLength(2)
+  })
+
+  it('holds the answer rather than resuming a thread a live writer owns', async () => {
+    const h = harness([])
+    journaledAnswer(h)
+    const wake = codexWake({ sourceAlive: false, probe: { state: 'live' } })
+
+    await hookRunCommand(
+      { ...h.deps, codexWake: wake, codexSourcePid: 12345 },
+      'stop',
+      stdin({ session_id: CODEX_THREAD, cwd: '/tmp/codex-route' }),
+      'codex',
+    )
+
+    expect(h.io.outLines).toEqual([])
+    expect(wake.resumed).toEqual([])
+    expect(readSessionState(CODEX_THREAD, h.env).accepted).toBeDefined()
+    expect(h.io.errLines.join('\n')).toContain('holding the accepted answer for the next turn')
+  })
+})
+
+describe('escalation waiter delivery seam', () => {
+  function waiterContext(h: Harness) {
+    const client = h.deps.clientFactory!('https://test.notifai.invalid', 'Bearer test')
+    return {
+      client,
+      config: loadConfig({ cwd: h.deps.cwd, env: h.env }),
+      env: h.env,
+      now: h.deps.now!,
+      sleep: h.deps.sleep!,
+      waitForFirstReply: async (requestId: string, timeoutSeconds: number) => {
+        const response = await client.replies(requestId, {
+          waitSeconds: timeoutSeconds,
+          afterSeq: 0,
+        })
+        return { replies: response.replies, timedOut: response.replies.length === 0 }
+      },
+      harness: 'codex' as const,
+    }
+  }
+
+  it('waits through grace, routes the fenced answer, and holds the claim until delivery settles', async () => {
+    const h = harness([reply({ text: 'Ship it' })])
+    writeGlobalConfig(h, 'ask_grace_seconds = 120\n')
+    writeSessionState('waiter-route', h.env, { last_prompt_at: AWAY })
+    registerQuestion('waiter-route', h.env, { question: 'Ship it?' }, NOW)
+
+    const context = waiterContext(h)
+    const deliveries: Array<{ route: string; context: string }> = []
+    let claimHeldDuringDelivery = false
+    const deliver = vi.fn(async (event: { context: string }) => {
+      deliveries.push({ route: 'hook-continuation', context: event.context })
+      claimHeldDuringDelivery = !claimQuestionPush('waiter-route', h.env)
+      return { stdout: JSON.stringify({ decision: 'block', reason: event.context }) }
+    })
+
+    const outcome = await runEscalationWaiter(context, {
+      sessionId: 'waiter-route',
+      envelope: { session_id: 'waiter-route' },
+      route: { kind: 'hook-continuation', deliver },
+      processDeadlineAt: NOW + 480_000,
+    })
+
+    expect((h.deps.now?.() ?? NOW) - NOW).toBeGreaterThanOrEqual(120_000)
+    expect(deliver).toHaveBeenCalledTimes(1)
+    expect(deliver).toHaveBeenCalledWith(
+      expect.objectContaining({ journal_recorded_at: expect.any(Number) }),
+    )
+    expect(deliveries).toEqual([
+      { route: 'hook-continuation', context: expect.stringContaining('Ship it') },
+    ])
+    expect(claimHeldDuringDelivery).toBe(true)
+    expect(JSON.parse(outcome.stdout ?? '{}')).toMatchObject({
+      decision: 'block',
+      reason: expect.stringContaining('Ship it'),
+    })
+    expect(claimQuestionPush('waiter-route', h.env)).toBe(true)
+    releaseQuestionPush('waiter-route', h.env)
+  })
+
+  it('races a second Stop while grace, polling, fencing, and route delivery are still owned', async () => {
+    const h = harness([])
+    writeGlobalConfig(h, 'ask_grace_seconds = 10\n')
+    writeSessionState('waiter-race-lifetime', h.env, { last_prompt_at: AWAY })
+    registerQuestion('waiter-race-lifetime', h.env, { question: 'Ship it?' }, NOW)
+    const context = waiterContext(h)
+    const phases: string[] = []
+
+    let waitingForReply = false
+    context.sleep = async (milliseconds: number) => {
+      if (!waitingForReply) {
+        phases.push('grace')
+        expect(claimQuestionPush('waiter-race-lifetime', h.env)).toBe(false)
+      }
+      h.advanceClock(milliseconds)
+    }
+    context.waitForFirstReply = async () => {
+      waitingForReply = true
+      phases.push('reply-wait')
+      expect(claimQuestionPush('waiter-race-lifetime', h.env)).toBe(false)
+      return { replies: [reply({ text: 'Ship it' })], timedOut: false }
+    }
+    const closeReplies = context.client.closeReplies.bind(context.client)
+    context.client.closeReplies = async (requestId) => {
+      phases.push('close-fence')
+      expect(claimQuestionPush('waiter-race-lifetime', h.env)).toBe(false)
+      return closeReplies(requestId)
+    }
+
+    await runEscalationWaiter(context, {
+      sessionId: 'waiter-race-lifetime',
+      envelope: { session_id: 'waiter-race-lifetime' },
+      route: {
+        kind: 'hook-continuation',
+        deliver: async (event) => {
+          phases.push('delivery')
+          expect(claimQuestionPush('waiter-race-lifetime', h.env)).toBe(false)
+          return { stdout: JSON.stringify({ decision: 'block', reason: event.context }), notes: [] }
+        },
+      },
+      processDeadlineAt: NOW + 480_000,
+    })
+
+    expect(phases.filter((phase) => phase === 'grace').length).toBeGreaterThan(0)
+    expect(phases.filter((phase) => phase !== 'grace')).toEqual([
+      'reply-wait',
+      'close-fence',
+      'delivery',
+    ])
+    expect(claimQuestionPush('waiter-race-lifetime', h.env)).toBe(true)
+    releaseQuestionPush('waiter-race-lifetime', h.env)
+  })
+
+  /** One accepted answer on the journal, whatever route is about to own it. */
+  function journaled(h: Harness, sessionId: string): void {
+    writeSessionState(sessionId, h.env, {
+      accepted: {
+        answers: [
+          {
+            pending: {
+              question: 'Ship it?',
+              request_id: 'req_existing',
+              collapse_key: 'question-existing',
+              device_ids: ['dev_iphone'],
+            },
+            reply: reply({ text: 'Ship it' }),
+            replies: [reply({ text: 'Ship it' })],
+          },
+        ],
+        remaining: 0,
+        recorded_at: NOW,
+      },
+    })
+  }
+
+  it('delivers an accepted answer once on a route that acknowledges its own write', async () => {
+    const h = harness([])
+    journaled(h, 'waiter-once')
+    const context = waiterContext(h)
+    const deliveries: string[] = []
+    const route = {
+      kind: 'inbox-socket' as const,
+      deliver: async (event: { context: string }) => {
+        deliveries.push(event.context)
+        return {
+          notes: ['posted the accepted answer'],
+          log: { route: 'inbox-socket', stage: 'delivered' },
+          acknowledgement: 'delivered' as const,
+        }
+      },
+    }
+
+    // Five turn-ends, none of them a harness continuation — the shape of every
+    // route that wakes a new turn instead of continuing this one.
+    for (let pass = 0; pass < 5; pass += 1) {
+      await runEscalationWaiter(context, {
+        sessionId: 'waiter-once',
+        envelope: { session_id: 'waiter-once', stop_hook_active: false },
+        route,
+        processDeadlineAt: NOW + 480_000,
+      })
+    }
+
+    expect(deliveries).toHaveLength(1)
+    expect(deliveries[0]).toContain('Ship it')
+    expect(readSessionState('waiter-once', h.env).accepted).toBeUndefined()
+  })
+
+  it('bounds deliveries by the continuation cap on every route', async () => {
+    // A route that never acknowledges must still stop. The cap lives where all
+    // routes pass, so no future route can be the one it does not cover.
+    for (const kind of ['inbox-socket', 'hook-continuation'] as const) {
+      const h = harness([])
+      const sessionId = `waiter-cap-${kind}`
+      journaled(h, sessionId)
+      const context = waiterContext(h)
+      let deliveries = 0
+      const notes: string[] = []
+
+      for (let pass = 0; pass < MAX_CONTINUATION_COUNT + 3; pass += 1) {
+        const outcome = await runEscalationWaiter(context, {
+          sessionId,
+          envelope: { session_id: sessionId, stop_hook_active: false },
+          route: {
+            kind,
+            deliver: async () => {
+              deliveries += 1
+              return { notes: [], acknowledgement: 'held' as const }
+            },
+          },
+          processDeadlineAt: NOW + 480_000,
+        })
+        notes.push(...outcome.notes)
+      }
+
+      expect(deliveries).toBe(MAX_CONTINUATION_COUNT)
+      expect(notes.join('\n')).toContain(
+        `${MAX_CONTINUATION_COUNT} times without being acknowledged`,
+      )
+      expect(readSessionState(sessionId, h.env).accepted).toBeUndefined()
+    }
+  })
+
+  it('keeps the accepted journal when an out-of-band route rejects delivery', async () => {
+    const h = harness([reply({ text: 'Hold it' })])
+    writeGlobalConfig(h, 'ask_grace_seconds = 0\n')
+    writeSessionState('waiter-failed-route', h.env, { last_prompt_at: AWAY })
+    registerQuestion('waiter-failed-route', h.env, { question: 'Ship it?' }, NOW)
+    const context = waiterContext(h)
+
+    await expect(
+      runEscalationWaiter(context, {
+        sessionId: 'waiter-failed-route',
+        envelope: { session_id: 'waiter-failed-route' },
+        route: {
+          kind: 'inbox-socket',
+          deliver: async () => {
+            throw new Error('socket unavailable')
+          },
+        },
+        processDeadlineAt: NOW + 480_000,
+      }),
+    ).rejects.toThrow('socket unavailable')
+
+    expect(readSessionState('waiter-failed-route', h.env).accepted?.answers[0]?.reply.text).toBe(
+      'Hold it',
+    )
+    expect(claimQuestionPush('waiter-failed-route', h.env)).toBe(true)
+    releaseQuestionPush('waiter-failed-route', h.env)
+  })
 })