@raidiant/notifai 0.2.1 → 0.4.0

package/src/hooks.test.ts

@@ -1,15 +1,19 @@
+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,
@@ -17,9 +21,23 @@ import type {
   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 { ApiCallError, type ApiClient } from './client.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,
@@ -29,6 +47,7 @@ import {
   orphanRetirements,
   pruneAbandonedSessions,
   releaseQuestionPush,
+  readMatchingProjectSessionPointer,
   readProjectSession,
   readSessionState,
   registerQuestion,
@@ -55,15 +74,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 +133,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,6 +188,7 @@ interface Harness {
   io: CapturedIo
   recorder: Recorder
   env: NodeJS.ProcessEnv
+  advanceClock(milliseconds: number): void
 }
 
 const NOW = 1_800_000_000_000
@@ -155,7 +205,7 @@ function harness(replies: ReplyView[] = [], idleSeconds: number | null = null):
     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 +213,9 @@ function harness(replies: ReplyView[] = [], idleSeconds: number | null = null):
     io,
     recorder,
     env,
+    advanceClock(milliseconds: number) {
+      clock += milliseconds
+    },
     deps: {
       io,
       store: {
@@ -192,6 +245,140 @@ function stdin(payload: unknown): () => Promise<string> {
   return async () => JSON.stringify(payload)
 }
 
+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))
+  }
+}
+
+interface SessionEndLogLockHolder {
+  child: ChildProcess
+  readyPath: string
+  releasePath: string
+  done: Promise<void>
+}
+
+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 }
+}
+
+interface CliProcessResult {
+  code: number | null
+  signal: NodeJS.Signals | null
+  stdout: string
+  stderr: string
+  durationMs: number
+}
+
+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)
+}
+
+function presenceGatedConfig(cwd: string, env: NodeJS.ProcessEnv) {
+  const config = loadConfig({ cwd, env })
+  config.require_idle = { value: true, source: 'global:test' }
+  return config
+}
+
 /** Long enough ago to be away under the 120s default. */
 const AWAY = NOW - 600_000
 const PRESENT = NOW - 5_000
@@ -199,13 +386,13 @@ const PRESENT = NOW - 5_000
 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 })
+    const config = presenceGatedConfig(deps.cwd, env)
     expect(isUserAway({}, config, NOW, null)).toBe(false)
   })
 
   it('is away only once the configured silence has elapsed', () => {
     const { env, deps } = harness()
-    const config = loadConfig({ cwd: deps.cwd, env })
+    const config = presenceGatedConfig(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)
   })
@@ -214,7 +401,7 @@ describe('presence gate', () => {
   // 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 })
+    const config = presenceGatedConfig(deps.cwd, env)
     expect(isUserAway({ last_prompt_at: AWAY }, config, NOW, 3)).toBe(false)
   })
 
@@ -224,13 +411,14 @@ describe('presence gate', () => {
   // 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 })
+    const config = presenceGatedConfig(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)
   })
 
   it('pushes a spawned session first question once the machine has gone quiet', async () => {
     const h = harness([reply({ text: 'Yes' })], 900)
+    writeGlobalConfig(h, 'require_idle = true\n')
     // 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)
@@ -268,13 +456,14 @@ describe('presence gate', () => {
 
   it('falls back to elapsed time where no idle source exists', () => {
     const { env, deps } = harness()
-    const config = loadConfig({ cwd: deps.cwd, env })
+    const config = presenceGatedConfig(deps.cwd, env)
     expect(isUserAway({ last_prompt_at: AWAY }, config, NOW, null)).toBe(true)
   })
 
   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)
+    writeGlobalConfig(h, 'require_idle = true\n')
     writeSessionState('idle1', h.env, { last_prompt_at: AWAY })
     registerQuestion('idle1', h.env, { question: 'Ship it?' })
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'idle1' }))
@@ -283,6 +472,199 @@ describe('presence gate', () => {
   })
 })
 
+/**
+ * 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([], 2)
+    writeGlobalConfig(h, 'require_idle = true\n')
+    writeSessionState('held', h.env, { last_prompt_at: AWAY })
+    registerQuestion('held', h.env, { question: 'Ship it?' })
+
+    await hookRunCommand(recording(h), 'stop', stdin({ session_id: 'held', cwd: h.deps.cwd }))
+
+    const held = gates(h).find((record) => record.data?.['reason'] === 'user-present')
+    expect(held).toBeDefined()
+    expect(held!.data).toMatchObject({ verdict: 'held', idle_seconds: 2, away_after_seconds: 120 })
+  })
+
+  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([], 600)
+    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)
+    // 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')
+  })
+
+  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' })], 900)
+    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)
+    expect(readLogRecords(h.env, { event: ['hook.answer'] }).records).toHaveLength(1)
+    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([], 600)
+    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('pushed', h.env, { last_prompt_at: AWAY })
+    registerQuestion('pushed', h.env, { question: 'Ship it?' })
+
+    await hookRunCommand(recording(h), 'stop', stdin({ session_id: 'pushed', cwd: h.deps.cwd }))
+
+    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('stores every request in a multi-question wait as a structured identity', async () => {
+    const h = harness([], 900)
+    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(
+      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()
+
+    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('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, logger: createLogger({ env: h.env }) },
+      'stop',
+      stdin({ session_id: 'bad-config', cwd: h.deps.cwd }),
+    )
+
+    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('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(deps, 'stop', stdin({ session_id: 'broken', cwd: h.deps.cwd }))
+
+    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('never writes the machine credential, whatever the hook did', async () => {
+    const h = harness([], 600)
+    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(recording(h), 'stop', stdin({ session_id: 'secret', cwd: h.deps.cwd }))
+
+    // 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.
@@ -290,31 +672,29 @@ describe('presence gate', () => {
  * it off must not disturb the grace timer.
  */
 describe('presence gating is optional (require_idle)', () => {
-  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('counts a user actively typing as reachable', () => {
+  it('consults active typing only when presence gating is explicitly enabled', () => {
     // 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)
+    const ungated = loadConfig({ cwd: '/nowhere', env: {}, flags: {} })
+    expect(isUserAway({ last_prompt_at: NOW }, ungated, NOW, 1)).toBe(true)
 
-    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 gated = loadConfig({ cwd: '/nowhere', env: {}, flags: {} })
+    gated.require_idle = { value: true, source: 'global:test' }
+    expect(isUserAway({ last_prompt_at: NOW }, gated, NOW, 1)).toBe(false)
   })
 
-  it('escalates a question while the user is at the keyboard', async () => {
+  it('escalates immediately by default while the user is at the keyboard', async () => {
     const h = harness([], 1)
-    writeGlobalConfig(h, 'require_idle = false\nask_grace_seconds = 0\n')
+    let submittedAt: number | undefined
+    h.recorder.beforeQuestionSubmit = () => {
+      submittedAt = h.deps.now?.()
+    }
     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).toHaveLength(1)
+    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(1)
+    expect(submittedAt).toBe(NOW)
     expect(h.io.errLines.join('\n')).not.toContain('at the keyboard')
   })
 
@@ -328,7 +708,7 @@ describe('presence gating is optional (require_idle)', () => {
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'present2' }))
 
-    expect(h.recorder.submitted).toHaveLength(1)
+    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).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)
@@ -344,7 +724,7 @@ describe('presence gating is optional (require_idle)', () => {
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'present3' }))
 
-    expect(h.recorder.submitted).toHaveLength(1)
+    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(1)
     expect((h.deps.now?.() ?? NOW) - NOW).toBeGreaterThanOrEqual(120_000)
     expect(h.io.errLines.join('\n')).not.toContain('no idle signal')
   })
@@ -373,10 +753,11 @@ describe('terminal-first grace window', () => {
     // 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)
+    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.
+    // Nothing was pushed before the explicitly configured 300s had passed.
     expect(h.deps.now?.()).toBeGreaterThanOrEqual(NOW + 300_000)
   })
 
@@ -392,6 +773,7 @@ describe('terminal-first grace window', () => {
   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)
+    writeGlobalConfig(h, 'require_idle = true\n')
     // Machine goes active on the second poll: the user sat down.
     h.deps.idleSeconds = () => {
       const current = idle
@@ -408,6 +790,7 @@ describe('terminal-first grace window', () => {
     // 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)
+    writeGlobalConfig(h, 'require_idle = true\n')
     pending(h, 'g4', 0)
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'g4' }))
     expect(h.recorder.submitted.length).toBeGreaterThan(0)
@@ -416,20 +799,73 @@ describe('terminal-first grace window', () => {
   })
 
   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.
+    // Both preferences can be large, but the shared budget honors maximum
+    // grace while retaining a protocol-valid answer window and scheduling
+    // slack. Real timers do not wake on the exact requested millisecond.
     const h = harness([reply({ text: 'Yes' })], 900)
+    const virtualSleep = h.deps.sleep!
+    h.deps.sleep = async (milliseconds: number) => virtualSleep(milliseconds + 1)
     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',
+      'ask_grace_seconds = 334\nhook_reply_timeout_seconds = 540\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 + 334_000)
+    expect(h.deps.now?.()).toBeLessThan(NOW + 335_000)
+    expect(
+      h.recorder.submitted.find((entry) => entry.draft.event === 'agent_question')?.draft.reply
+        ?.expires_in_seconds,
+    ).toBeGreaterThanOrEqual(60)
+  })
+
+  it('reserves transport overrun and close time inside the whole Stop budget', async () => {
+    const h = harness([], 900)
+    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\nhook_reply_timeout_seconds = 540\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' })
+    })
+
+    expect(h.deps.now?.()).toBeLessThanOrEqual(NOW + 480_000)
+    expect(readSessionState('transport-budget', h.env).pending).toBeUndefined()
   })
 })
 
@@ -465,7 +901,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 () => {
@@ -516,21 +952,24 @@ describe('nagging guards', () => {
 })
 
 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' })], 900)
+    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 +979,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' })], 900)
+    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,49 +998,229 @@ 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 () => {
+describe('OpenCode answer continuation', () => {
+  it('fails closed instead of accepting an answer the idle event cannot deliver', async () => {
     const h = harness([reply({ text: 'Approve' })], 900)
     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('delivers a reply that commits while the server close fence is finalizing silence', async () => {
+    const h = harness([], 900)
+    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
+    }
+    writeGlobalConfig(h, 'hook_reply_timeout_seconds = 60\n')
+    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([], 900)
+    const factory = h.deps.clientFactory
+    h.deps.clientFactory = () => {
+      const client = factory!()
+      return {
+        ...client,
+        closeReplies: async () => {
+          throw new Error('partitioned during close')
+        },
+      } as ApiClient
+    }
+    writeGlobalConfig(h, 'hook_reply_timeout_seconds = 60\n')
+    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: 'unproven-close' }))
+
+    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([], 900)
+    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([], 900)
+    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([], 900)
+    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('returns the terminal when the user comes back after the push', async () => {
     const h = harness([], 900)
+    writeGlobalConfig(h, 'require_idle = true\n')
     let checks = 0
     h.deps.idleSeconds = () => {
       checks += 1
@@ -605,19 +1229,92 @@ describe('reply-wait presence monitoring', () => {
     writeSessionState('returned', h.env, { last_prompt_at: AWAY })
     registerQuestion('returned', h.env, { question: 'Deploy?' }, NOW - 300_000)
 
-    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'returned' }))
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'returned' }))
+
+    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(1)
+    expect(h.recorder.closed).toContain(h.recorder.receipts[0])
+    expect(readSessionState('returned', h.env).pending).toBeUndefined()
+    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('retired before returning the terminal')
+  })
+
+  it('closes and retires silence at the absolute owner deadline', async () => {
+    const h = harness([], 900)
+    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
+    }
+    writeGlobalConfig(h, 'hook_reply_timeout_seconds = 60\n')
+    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' })], 900)
+    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)
+    expect(windows).toEqual([395, 355])
+    expect(h.deps.now?.()).toBeLessThanOrEqual(NOW + 435_000)
+  })
+
+  it('re-arms the next Stop for an independently pending answer', async () => {
+    const h = harness([], 900)
+    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?',
+    ])
 
-    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')
+    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 () => {
+  it('fails closed when the invoking shell cannot name the exact conversation', async () => {
     const h = harness([reply({ text: 'Ship it' })], 900)
     writeSessionState('cursor-conversation', h.env, { last_prompt_at: AWAY })
     registerQuestion('cursor-conversation', h.env, { question: 'Deploy now?' })
@@ -633,12 +1330,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 +1355,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 +1404,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 +1423,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 +1435,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 +1453,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,18 +1487,7 @@ 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 () => {
@@ -822,8 +1503,155 @@ 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([], 900)
+    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([], 900)
+    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([], 900)
+    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([], 900)
+    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 () => {
@@ -843,7 +1671,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,6 +1680,49 @@ 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' })], 900)
+    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 byRequest = new Map([['req_hook_1', [reply({ text: 'Ship it' })]]])
@@ -867,7 +1738,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 +1765,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 () => {
@@ -1030,12 +1907,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',
@@ -1051,18 +1926,23 @@ describe('ask registration', () => {
   it('registers a multi-question form and pushes it as one set', async () => {
     const h = harness([reply({ text: 'Yes' })], 900)
     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')
@@ -1101,9 +1981,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 +2008,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 +2017,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 +2045,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 +2057,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 +2072,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 () => {
@@ -1225,28 +2133,20 @@ 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 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 +2158,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 +2177,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 +2207,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,7 +2226,7 @@ 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',
     })
   })
 
@@ -1328,12 +2235,17 @@ describe('user-prompt-submit hook', () => {
     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 +2276,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 +2378,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 +2395,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 () => {
@@ -1443,6 +2455,11 @@ describe('telling concurrent agents apart', () => {
     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')
@@ -1460,7 +2477,7 @@ describe('telling concurrent agents apart', () => {
 })
 
 describe('clock jumps', () => {
-  const config = loadConfig({ cwd: '/nowhere', env: {} })
+  const config = presenceGatedConfig('/nowhere', {})
 
   it('does not hijack a terminal because the clock jumped forward', () => {
     // NTP correction or a VM resume moves `now` without any time passing for
@@ -1694,13 +2711,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, () => {
@@ -1729,10 +2766,56 @@ 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, 900)
+    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 () => {
+  it('keeps the new question when the older owner expires', async () => {
     const h = harness([], 900)
     writeSessionState('submit-race', h.env, { last_prompt_at: AWAY })
     registerQuestion('submit-race', h.env, { question: 'Old question?' }, NOW)
@@ -1743,16 +2826,16 @@ 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 () => {
@@ -1768,12 +2851,7 @@ 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(
-      h.recorder.submitted.find(
-        (entry) =>
-          entry.draft.event === 'question_retired' &&
-          entry.draft.lifecycle?.retires_request_id === 'req_hook_1',
-      )?.draft.lifecycle?.state,
-    ).toBe('answered')
+    expect(state.accepted?.answers[0]?.pending.request_id).toBe(h.recorder.receipts[0])
+    expect(state.accepted?.answers[0]?.reply.text).toBe('Old answer')
   })
 })