@raidiant/notifai 0.1.7 → 0.2.0

package/src/hooks.test.ts

@@ -1,4 +1,13 @@
-import { mkdirSync, mkdtempSync, realpathSync, utimesSync, writeFileSync } from 'node:fs'
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  realpathSync,
+  symlinkSync,
+  utimesSync,
+  writeFileSync,
+} from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import type {
@@ -10,9 +19,11 @@ import type {
 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, sanitizeSessionId } from './config.js'
+import { loadConfig, projectSessionPointerPath, sanitizeSessionId } from './config.js'
 import {
   claimQuestionPush,
+  clearSessionState,
+  drainRetirements,
   drainOrphanRetirements,
   isUserAway,
   orphanRetirements,
@@ -21,6 +32,7 @@ import {
   readProjectSession,
   readSessionState,
   registerQuestion,
+  writeProjectSession,
   writeSessionState,
 } from './hooks.js'
 
@@ -46,6 +58,8 @@ interface Recorder {
   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
 }
 
 function fakeClient(recorder: Recorder, replies: ReplyView[]): ApiClient {
@@ -81,6 +95,7 @@ function fakeClient(recorder: Recorder, replies: ReplyView[]): ApiClient {
     health: async () => true,
     submit: async (body) => {
       if (recorder.failSubmits === true) throw new Error('offline')
+      if (body.draft.event === 'agent_question') recorder.beforeQuestionSubmit?.()
       recorder.submitted.push(body)
       submissions += 1
       recorder.receipts.push(`req_hook_${submissions}`)
@@ -112,7 +127,8 @@ function reply(overrides: Partial<ReplyView> = {}): ReplyView {
     device_id: 'dev_test',
     device_name: 'Furankuphone',
     text: 'Allow',
-    choice_id: 'allow',
+    answers: [{ question_id: 'q1', choice_ids: ['allow'], text: null }],
+    source: null,
     created_at: new Date().toISOString(),
     ...overrides,
   }
@@ -224,6 +240,30 @@ describe('presence gate', () => {
       mode: 'selected',
       device_ids: ['dev_iphone', 'dev_mac'],
     })
+    expect(h.recorder.submitted[0]?.draft.presentation).toMatchObject({
+      title: 'Question',
+      body: 'Ship it?',
+    })
+    expect(h.recorder.submitted[0]?.draft.platform).toEqual({
+      ios: { sound: 'attention', interruption_level: 'active' },
+      macos: { sound: 'attention', interruption_level: 'active' },
+    })
+  })
+
+  it('names the resolved project in the pushed question title', async () => {
+    const h = harness([reply({ text: 'Yes' })], 900)
+    const projectDir = path.join(h.deps.cwd, '.notifai')
+    mkdirSync(projectDir, { recursive: true })
+    writeFileSync(
+      path.join(projectDir, 'config.toml'),
+      'project = "notifai-cli"\nask_grace_seconds = 0\n',
+    )
+    writeSessionState('project-title', h.env, { last_prompt_at: AWAY })
+    registerQuestion('project-title', h.env, { question: 'Ship it?' }, NOW)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'project-title', cwd: h.deps.cwd }))
+
+    expect(h.recorder.submitted[0]?.draft.presentation.title).toBe('Question · notifai-cli')
   })
 
   it('falls back to elapsed time where no idle source exists', () => {
@@ -438,6 +478,142 @@ describe('nagging guards', () => {
     expect(h.recorder.submitted).toEqual([])
     expect(h.io.outLines).toEqual([])
   })
+
+  it('delivers a new question registered during an answer continuation', async () => {
+    const h = harness([reply({ text: 'First answer' })], 900)
+    writeSessionState('n3', h.env, { last_prompt_at: AWAY })
+    registerQuestion('n3', h.env, { question: 'First question?' }, NOW)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'n3' }))
+    await h.deps.sleep?.(1)
+    registerQuestion('n3', h.env, { question: 'Follow-up question?' }, (h.deps.now?.() ?? NOW))
+    h.io.outLines = []
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'n3', stop_hook_active: true }))
+
+    const questions = h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')
+    expect(questions.map((entry) => entry.draft.presentation.body)).toEqual([
+      'First question?',
+      'Follow-up question?',
+    ])
+    expect(h.io.outLines.join('\n')).toContain('First answer')
+  })
+
+  it('stops chained questions at the consecutive continuation cap', async () => {
+    const h = harness([], 900)
+    writeSessionState('n4', h.env, {
+      last_prompt_at: AWAY,
+      continuation: { answered_at: NOW - 1, count: 3 },
+    })
+    registerQuestion('n4', h.env, { question: 'One more?' }, NOW)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'n4', stop_hook_active: true }))
+
+    expect(h.recorder.submitted).toEqual([])
+    expect(readSessionState('n4', h.env).pending?.question).toBe('One more?')
+    expect(h.io.errLines.join('\n')).toContain('continuation limit (3) reached')
+  })
+})
+
+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?.request_id).toBe('req_hook_1')
+    answers.push(reply({ text: 'Ship it' }))
+    h.io.outLines = []
+
+    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(readSessionState('late-stop', h.env).pending).toBeUndefined()
+    expect(h.io.outLines).toHaveLength(1)
+    expect(JSON.parse(h.io.outLines[0] ?? '{}')).toMatchObject({
+      decision: 'block',
+      reason: expect.stringContaining('Ship it'),
+    })
+  })
+
+  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 = []
+
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'late-prompt', cwd: h.deps.cwd }),
+    )
+
+    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',
+    })
+    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'),
+      },
+    })
+  })
+})
+
+describe('OpenCode answer preservation', () => {
+  it('pushes without waiting and leaves the answerable request intact', 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.closed).toEqual([])
+    expect(
+      h.recorder.submitted.filter((entry) => entry.draft.event === 'question_retired'),
+    ).toEqual([])
+    expect(readSessionState('open1', h.env).pending).toMatchObject({
+      question: 'Deploy?',
+      request_id: 'req_hook_1',
+      device_ids: ['dev_iphone', 'dev_mac'],
+    })
+    expect(h.io.outLines).toEqual([])
+  })
+})
+
+describe('reply-wait presence monitoring', () => {
+  it('returns the terminal when the user comes back after the push', async () => {
+    const h = harness([], 900)
+    let checks = 0
+    h.deps.idleSeconds = () => {
+      checks += 1
+      return checks >= 4 ? 1 : 900
+    }
+    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' }))
+
+    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(1)
+    expect(h.recorder.closed).toEqual([])
+    expect(readSessionState('returned', h.env).pending?.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')
+  })
 })
 
 describe('Cursor stop output', () => {
@@ -460,7 +636,7 @@ describe('Cursor stop output', () => {
     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.',
+      'Notifai — the user answered from Furankuphone: "Ship it". Continue with that answer.',
     )
     expect(output).not.toHaveProperty('decision')
   })
@@ -740,11 +916,11 @@ describe('ask registration', () => {
     const h = harness()
     // Inside a hook, a rejection is only a stderr note the agent never reads —
     // so it would look registered and then silently never ask.
-    expect(askCommand(h.deps, 'Ship it?', { choice: 'Yes|No', session: 'a1' })).toBe(EXIT.usage)
+    expect(askCommand(h.deps, 'Ship it?', { choice: ['Only one'], session: 'a1' })).toBe(EXIT.usage)
     expect(readSessionState('a1', h.env).pending).toBeUndefined()
   })
 
-  it('stores validated labels verbatim, commas and all', () => {
+  it('stores the validated question set, comma-bearing labels verbatim', () => {
     const h = harness()
     expect(
       askCommand(h.deps, 'Ship it?', {
@@ -752,7 +928,104 @@ describe('ask registration', () => {
         session: 'a2',
       }),
     ).toBe(EXIT.ok)
-    expect(readSessionState('a2', h.env).pending?.choices).toEqual(['Yes, ship it', 'No, hold'])
+    expect(readSessionState('a2', h.env).pending?.questions).toEqual([
+      {
+        id: 'ship-it',
+        text: 'Ship it?',
+        choices: [
+          { id: 'yes-ship-it', label: 'Yes, ship it' },
+          { id: 'no-hold', label: 'No, hold' },
+        ],
+      },
+    ])
+  })
+
+  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({
+          questions: [
+            { text: 'Deploy where?', choices: ['Staging', 'Production'], multi: true },
+            { text: 'Anything to watch?' },
+          ],
+          detail: '## Context\nThe long story.',
+        }),
+      }),
+    ).toBe(EXIT.ok)
+    const pending = readSessionState('form1', h.env).pending
+    expect(pending?.questions).toHaveLength(2)
+    expect(pending?.detail).toContain('long story')
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'form1' }))
+    const draft = h.recorder.submitted[0]?.draft
+    // The banner leads with the first question and admits the rest exists;
+    // the full set rides the payload for the answering card.
+    expect(draft?.presentation.body).toBe('Deploy where? (+1 more)')
+    expect(draft?.presentation.detail).toContain('long story')
+    expect(draft?.reply?.questions).toEqual([
+      {
+        id: 'deploy-where',
+        text: 'Deploy where?',
+        choices: [
+          { id: 'staging', label: 'Staging' },
+          { id: 'production', label: 'Production' },
+        ],
+        multi: true,
+      },
+      { id: 'anything-to-watch', text: 'Anything to watch?' },
+    ])
+  })
+
+  it('acts on the latest reply when answers conflict, because it is a correction', async () => {
+    const h = harness(
+      [
+        reply({ seq: 1, text: 'Yes', answers: [{ question_id: 'ship-it', choice_ids: ['yes'], text: null }] }),
+        reply({
+          seq: 2,
+          reply_id: 'rpl_2',
+          text: 'No',
+          answers: [{ question_id: 'ship-it', choice_ids: ['no'], text: null }],
+        }),
+      ],
+      900,
+    )
+    writeSessionState('latest1', h.env, { last_prompt_at: AWAY })
+    expect(
+      askCommand(h.deps, 'Ship it?', { session: 'latest1', choice: ['Yes', 'No'] }),
+    ).toBe(EXIT.ok)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'latest1' }))
+
+    const decision = JSON.parse(h.io.outLines.at(-1)!) as { decision: string; reason: string }
+    expect(decision.decision).toBe('block')
+    expect(decision.reason).toContain('"No"')
+    expect(decision.reason).not.toContain('"Yes"')
+  })
+
+  it('hands a free-text answer written in parts to the agent in order', async () => {
+    const h = harness(
+      [
+        reply({ seq: 1, text: 'Use blue', answers: [{ question_id: 'which-color', choice_ids: [], text: 'Use blue' }] }),
+        reply({
+          seq: 2,
+          reply_id: 'rpl_2',
+          text: 'actually teal',
+          answers: [{ question_id: 'which-color', choice_ids: [], text: 'actually teal' }],
+        }),
+      ],
+      900,
+    )
+    writeSessionState('parts1', h.env, { last_prompt_at: AWAY })
+    expect(askCommand(h.deps, 'Which color?', { session: 'parts1' })).toBe(EXIT.ok)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'parts1' }))
+
+    const decision = JSON.parse(h.io.outLines.at(-1)!) as { reason: string }
+    expect(decision.reason).toContain('in the order written')
+    expect(decision.reason).toContain('"Use blue", then "actually teal"')
   })
 
   it('resolves the session as flag, then hook pointer, then NOTIFAI_SESSION', async () => {
@@ -760,7 +1033,12 @@ describe('ask registration', () => {
     // harness's own id, so the pointer must outrank the env var.
     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 }))
+    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?.question).toBe('Ship it?')
     expect(readSessionState('my-label', h.env).pending).toBeUndefined()
@@ -798,12 +1076,34 @@ 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 () => {
+    const h = harness()
+
+    expect(await hookRunCommand(h.deps, 'user-prompt-submit', async () => '{"session_id":')).toBe(
+      EXIT.ok,
+    )
+
+    expect(h.io.errLines.join('\n')).toMatch(/malformed|truncated/i)
+  })
+
+  it('explains when a missing machine credential makes a hook skip routing', async () => {
+    const h = harness()
+    h.deps.store.load = () => null
+
+    expect(
+      await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 'unpaired' })),
+    ).toBe(EXIT.ok)
+
+    expect(h.io.errLines.join('\n')).toMatch(/not paired|credential/i)
+  })
+
   it('preserves a delivered question through ask replacement and 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 }))
@@ -834,6 +1134,7 @@ describe('user-prompt-submit hook', () => {
       h.deps,
       'user-prompt-submit',
       stdin({ session_id: 'transition', cwd: h.deps.cwd }),
+      'claude-code',
     )
 
     const retirement = h.recorder.submitted.find(
@@ -919,12 +1220,20 @@ describe('user-prompt-submit hook', () => {
     const project = realpathSync(viaSymlink)
     if (project === viaSymlink) return // no symlink on this platform; nothing to prove
 
-    await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 's14', cwd: viaSymlink }))
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 's14', cwd: viaSymlink }),
+      'claude-code',
+    )
 
     expect(readProjectSession(project, h.env, NOW)).toBe('s14')
     expect(readProjectSession(viaSymlink, h.env, NOW)).toBe('s14')
     // A pointer older than a day is not evidence of a live session.
     expect(readProjectSession(project, h.env, NOW + 2 * 24 * 3600 * 1000)).toBeNull()
+
+    clearSessionState('s14', h.env)
+    expect(readProjectSession(project, h.env, NOW)).toBeNull()
   })
 })
 
@@ -940,6 +1249,26 @@ describe('session-end hook', () => {
     expect(h.recorder.closed).toEqual([])
   })
 
+  it('clears only the ending session project pointer', async () => {
+    const h = harness()
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'ending', cwd: h.deps.cwd }),
+      'claude-code',
+    )
+    expect(readProjectSession(h.deps.cwd, h.env, NOW)).toBe('ending')
+
+    await hookRunCommand(
+      h.deps,
+      'session-end',
+      stdin({ session_id: 'ending', cwd: h.deps.cwd }),
+      'claude-code',
+    )
+
+    expect(readProjectSession(h.deps.cwd, h.env, NOW)).toBeNull()
+  })
+
   it('preserves incomplete live state and reports why it cannot retire it', async () => {
     const h = harness()
     writeSessionState('s-incomplete', h.env, {
@@ -1106,6 +1435,113 @@ describe('pruning abandoned session state', () => {
   })
 })
 
+describe('durable state writes', () => {
+  function sessionFile(h: Harness, sessionId: string): string {
+    return path.join(
+      h.env['XDG_STATE_HOME'] as string,
+      'notifai',
+      'sessions',
+      `${sanitizeSessionId(sessionId)}.json`,
+    )
+  }
+
+  it('recovers a truncated state file with one complete atomic document', () => {
+    const h = harness()
+    const file = sessionFile(h, 'truncated')
+    mkdirSync(path.dirname(file), { recursive: true })
+    writeFileSync(file, '{"pending":')
+    expect(readSessionState('truncated', h.env)).toEqual({})
+
+    writeSessionState('truncated', h.env, { last_prompt_at: NOW })
+
+    expect(JSON.parse(readFileSync(file, 'utf8'))).toEqual({ last_prompt_at: NOW })
+    expect(readdirSync(path.dirname(file)).filter((name) => name.includes('.tmp'))).toEqual([])
+  })
+
+  it('refuses a session-state symlink instead of writing through it', () => {
+    const h = harness()
+    const file = sessionFile(h, 'linked')
+    const target = path.join(path.dirname(file), 'target.json')
+    mkdirSync(path.dirname(file), { recursive: true })
+    writeFileSync(target, '{"untouched":true}\n')
+    symlinkSync(target, file)
+
+    expect(() => writeSessionState('linked', h.env, { last_prompt_at: NOW })).toThrow(/symlink/)
+    expect(readFileSync(target, 'utf8')).toBe('{"untouched":true}\n')
+  })
+
+  it('refuses project-pointer and retirement-queue symlinks too', () => {
+    const h = harness()
+    writeSessionState('linked-pointer', h.env, { last_prompt_at: NOW })
+    const target = path.join(h.env['XDG_STATE_HOME'] as string, 'pointer-target.json')
+    writeFileSync(target, '{"untouched":true}\n')
+    const pointer = projectSessionPointerPath(h.deps.cwd, h.env)
+    mkdirSync(path.dirname(pointer), { recursive: true })
+    symlinkSync(target, pointer)
+
+    expect(() =>
+      writeProjectSession(h.deps.cwd, h.env, 'linked-pointer', NOW, 'claude-code'),
+    ).toThrow(/symlink/)
+    expect(readFileSync(target, 'utf8')).toBe('{"untouched":true}\n')
+
+    const queueTarget = path.join(h.env['XDG_STATE_HOME'] as string, 'queue-target.json')
+    const queue = path.join(h.env['XDG_STATE_HOME'] as string, 'notifai', 'retire-queue.json')
+    writeFileSync(queueTarget, '[]\n')
+    symlinkSync(queueTarget, queue)
+    expect(() =>
+      orphanRetirements(
+        h.env,
+        [
+          {
+            request_id: 'req_linked',
+            collapse_key: 'collapse-linked',
+            device_ids: ['dev_iphone'],
+            question: 'Still there?',
+            state: 'expired',
+          },
+        ],
+        'linked-pointer',
+        NOW,
+      ),
+    ).toThrow(/symlink/)
+    expect(readFileSync(queueTarget, 'utf8')).toBe('[]\n')
+  })
+
+  it('persists each successful retirement before a later corrupt entry interrupts the drain', async () => {
+    const h = harness()
+    writeSessionState('partial-drain', h.env, {
+      retiring: [
+        {
+          request_id: 'req_good',
+          collapse_key: 'collapse-good',
+          device_ids: ['dev_iphone'],
+          question: 'First?',
+          state: 'expired',
+        },
+        {
+          request_id: 'req_bad',
+          collapse_key: 'collapse-bad',
+          device_ids: [],
+          question: 'Second?',
+          state: 'expired',
+        },
+      ],
+    })
+    const ctx = {
+      client: h.deps.clientFactory('https://test.notifai.invalid', 'Bearer x'),
+      config: loadConfig({ cwd: h.deps.cwd, env: h.env }),
+    }
+
+    await expect(drainRetirements(ctx, 'partial-drain', h.env)).rejects.toThrow(
+      /missing its device identifiers/,
+    )
+
+    expect(readSessionState('partial-drain', h.env).retiring?.map((entry) => entry.request_id)).toEqual([
+      'req_bad',
+    ])
+  })
+})
+
 /**
  * Path-independent ownership stops the usual cause
  * of two handlers firing; this stops the consequence when something else does.
@@ -1134,6 +1570,19 @@ describe('two hooks racing one question', () => {
     expect(claimQuestionPush('race3', h.env, REAL)).toBe(true)
   })
 
+  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)
+    let contender: ReturnType<typeof claimQuestionPush> | undefined
+
+    const recovered = claimQuestionPush('race-break', h.env, REAL, () => {
+      contender = claimQuestionPush('race-break', h.env, REAL)
+    })
+
+    expect(contender).toBeDefined()
+    expect([recovered, contender].filter(Boolean)).toHaveLength(1)
+  })
+
   it('does not let two sessions block each other', () => {
     const h = harness()
     expect(claimQuestionPush('race4a', h.env, REAL)).toBe(true)
@@ -1153,3 +1602,45 @@ describe('two hooks racing one question', () => {
     expect(h.io.errLines.join(" ")).toContain('already handling')
   })
 })
+
+describe('question registration racing a Stop submission', () => {
+  it('preserves a newer question when the older submit publishes its request id', async () => {
+    const h = harness([], 900)
+    writeSessionState('submit-race', h.env, { last_prompt_at: AWAY })
+    registerQuestion('submit-race', h.env, { question: 'Old question?' }, NOW)
+    h.recorder.beforeQuestionSubmit = () => {
+      h.recorder.beforeQuestionSubmit = undefined
+      registerQuestion('submit-race', h.env, { question: 'New question?' }, NOW + 1)
+    }
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'submit-race' }))
+
+    const state = readSessionState('submit-race', h.env)
+    expect(state.pending?.question).toBe('New question?')
+    expect(state.retiring).toContainEqual(
+      expect.objectContaining({ request_id: 'req_hook_1', state: 'superseded' }),
+    )
+  })
+
+  it('keeps the newer question when the older in-flight question receives an answer', async () => {
+    const h = harness([reply({ text: 'Old answer' })], 900)
+    writeSessionState('answer-race', h.env, { last_prompt_at: AWAY })
+    registerQuestion('answer-race', h.env, { question: 'Old question?' }, NOW)
+    h.recorder.beforeQuestionSubmit = () => {
+      h.recorder.beforeQuestionSubmit = undefined
+      registerQuestion('answer-race', h.env, { question: 'New question?' }, NOW + 1)
+    }
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'answer-race' }))
+
+    const state = readSessionState('answer-race', h.env)
+    expect(state.pending?.question).toBe('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')
+  })
+})