@raidiant/notifai 0.1.7 → 0.1.8

package/src/config.test.ts

@@ -141,9 +141,61 @@ describe('draft building', () => {
       presentation: { title: 'T', body: 'B' },
       targets: { mode: 'all' },
       delivery: { ttl_seconds: 86400, collapse_key: null },
+      platform: {
+        ios: { sound: null, interruption_level: 'passive' },
+        macos: { sound: null, interruption_level: 'passive' },
+      },
     })
   })
 
+  it.each([
+    { flags: {}, sound: null, level: 'passive' },
+    { flags: { kind: 'done' }, sound: 'done', level: 'passive' },
+    { flags: { reply: true }, sound: 'attention', level: 'active' },
+  ])('derives the $sound / $level kind profile from $flags', ({ flags, sound, level }) => {
+    const config = loadConfig({ cwd: base.cwd, env: base.env })
+    const build = buildDraft(config, { title: 'T', body: 'B', ...flags })
+    if (!build.ok) throw new Error(build.error)
+    expect(build.draft.platform).toEqual({
+      ios: { sound, interruption_level: level },
+      macos: { sound, interruption_level: level },
+    })
+  })
+
+  it('orders explicit flags over user config over the kind profile', () => {
+    const { env, cwd } = setup({
+      projectToml: 'sound = "alert"\ninterruption_level = "active"\n',
+    })
+    const config = loadConfig({ cwd, env })
+    const configured = buildDraft(config, { title: 'T', body: 'B', kind: 'done' })
+    if (!configured.ok) throw new Error(configured.error)
+    expect(configured.draft.platform?.ios).toEqual({
+      sound: 'alert',
+      interruption_level: 'active',
+    })
+
+    const explicit = buildDraft(config, {
+      title: 'T',
+      body: 'B',
+      kind: 'done',
+      sound: 'none',
+      level: 'time_sensitive',
+    })
+    if (!explicit.ok) throw new Error(explicit.error)
+    expect(explicit.draft.platform?.ios).toEqual({
+      sound: null,
+      interruption_level: 'time_sensitive',
+    })
+  })
+
+  it('keeps a blocking reply answerable for one hour by default', () => {
+    const config = loadConfig({ cwd: base.cwd, env: base.env })
+    const build = buildDraft(config, { title: 'Question', body: 'Deploy?', reply: true })
+    if (!build.ok) throw new Error(build.error)
+
+    expect(build.draft.reply?.expires_in_seconds).toBe(3_600)
+  })
+
   it('stamps the project from flag or project config', () => {
     const { env, cwd } = setup({ projectToml: 'project = "my-app"\n' })
     const config = loadConfig({ cwd, env })
@@ -200,6 +252,7 @@ describe('draft building', () => {
       interruption_level: 'time_sensitive',
       custom_data: { run_id: '42', branch: 'main' },
     })
+    expect(build.draft.platform?.macos).toEqual(build.draft.platform?.ios)
   })
 
   it('maps optional fields into the selected macOS platform slot', () => {
@@ -209,11 +262,8 @@ describe('draft building', () => {
       body: 'B',
       platform: 'macos',
       sound: 'none',
-      badge: 7,
       threadId: 'desktop-builds',
       level: 'passive',
-      relevance: 0.8,
-      targetContentId: 'build-detail',
       data: ['run_id=42'],
     })
     if (!build.ok) throw new Error(build.error)
@@ -222,16 +272,28 @@ describe('draft building', () => {
     expect(build.draft.platform).toEqual({
       macos: {
         sound: null,
-        badge: 7,
         thread_id: 'desktop-builds',
         interruption_level: 'passive',
-        relevance_score: 0.8,
-        target_content_id: 'build-detail',
         custom_data: { run_id: '42' },
       },
     })
   })
 
+  it('limits collapse keys by UTF-8 bytes', () => {
+    const config = loadConfig({ cwd: base.cwd, env: base.env })
+    expect(buildDraft(config, { title: 'T', body: 'B', collapseKey: '😀'.repeat(16) }).ok).toBe(
+      true,
+    )
+    const oversized = buildDraft(config, {
+      title: 'T',
+      body: 'B',
+      collapseKey: '😀'.repeat(17),
+    })
+    expect(oversized.ok).toBe(false)
+    if (oversized.ok) throw new Error('expected rejection')
+    expect(oversized.error).toContain('64 UTF-8 bytes')
+  })
+
   it('rejects malformed inputs with usage errors', () => {
     const config = loadConfig({ cwd: base.cwd, env: base.env })
     expect(buildDraft(config, { title: '', body: 'B' }).ok).toBe(false)

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}`)
@@ -224,6 +239,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 +477,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 +635,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')
   })
@@ -760,7 +935,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 +978,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 +1036,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 +1122,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 +1151,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 +1337,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 +1472,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 +1504,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')
+  })
+})