@raidiant/notifai 7.0.2 → 9.0.0

package/src/hooks.test.ts

@@ -50,6 +50,7 @@ import {
   MAX_CONTINUATION_COUNT,
   MAX_HELD_DELIVERIES,
   orphanRetirements,
+  pendingAnsweredByPrompt,
   pruneAbandonedSessions,
   releaseQuestionPush,
   readMatchingProjectSessionPointer,
@@ -127,6 +128,8 @@ interface Recorder {
   closed: string[]
   /** Simulates an offline machine; retirement has to survive one. */
   failSubmits?: boolean
+  /** Simulates an unreachable close fence so retirement stays queued. */
+  failCloses?: 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. */
@@ -142,6 +145,16 @@ interface Recorder {
   acknowledgementChecks?: string[]
 }
 
+function isQuestionSubmit(entry: { draft: { reply?: unknown } }): boolean {
+  return entry.draft.reply !== undefined
+}
+
+function isRetirementSubmit(entry: {
+  draft: { lifecycle?: { retires_request_id?: string } }
+}): boolean {
+  return entry.draft.lifecycle?.retires_request_id !== undefined
+}
+
 function fakeClient(recorder: Recorder, replies: ReplyView[]): ApiClient {
   let submissions = 0
   const recordedReplies = (requestId: string): ReplyView[] => {
@@ -157,7 +170,7 @@ function fakeClient(recorder: Recorder, replies: ReplyView[]): ApiClient {
   return {
     beginPairing: notUsed,
     pollPairing: notUsed,
-    // Both current companion apps register reply categories.
+    // Current reply-capable Companion fixtures.
     listDevices: async () => ({
       devices: [
         {
@@ -215,7 +228,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?.()
+      if (body.draft.reply !== undefined) recorder.beforeQuestionSubmit?.()
       recorder.submitted.push(body)
       submissions += 1
       const requestId = body.request_id ?? `req_hook_${submissions}`
@@ -250,6 +263,7 @@ function fakeClient(recorder: Recorder, replies: ReplyView[]): ApiClient {
       }) satisfies ListRepliesResponse
     },
     closeReplies: async (requestId) => {
+      if (recorder.failCloses === true) throw new Error('offline')
       recorder.closed.push(requestId)
       return {
         request_id: requestId,
@@ -555,6 +569,38 @@ describe('pushing a registered question', () => {
     expect(h.recorder.submitted[0]?.draft.platform?.ios?.sound).toBe('attention')
   })
 
+  it('routes a registered question to an answer-capable Android installation', async () => {
+    const h = harness([reply({ text: 'Yes' })])
+    const client = {
+      ...fakeClient(h.recorder, [reply({ text: 'Yes' })]),
+      listDevices: async () => ({
+        devices: [
+          {
+            device_id: 'dev_android',
+            display_name: 'Pixel',
+            platform: 'android' as const,
+            permission_status: 'authorized',
+            registration_healthy: true,
+            capabilities: ['answer'],
+            derived_status: 'working',
+            last_seen_at: null,
+          },
+        ],
+      }),
+    } as ApiClient
+    const deps = { ...h.deps, clientFactory: () => client }
+    writeSessionState('android-answer', h.env, { last_prompt_at: AWAY })
+    registerQuestion('android-answer', h.env, { question: 'Ship it?' }, NOW)
+
+    await hookRunCommand(deps, 'stop', stdin({ session_id: 'android-answer' }))
+
+    expect(h.recorder.submitted[0]?.draft.targets).toEqual({
+      mode: 'selected',
+      device_ids: ['dev_android'],
+    })
+    expect(h.recorder.submitted[0]?.draft.platform?.android?.sound).toBe('attention')
+  })
+
   it('keeps sparse alt text paired with its original media item', async () => {
     const h = harness([reply({ text: 'Yes' })])
     writeSessionState('media-order', h.env, { last_prompt_at: AWAY })
@@ -704,7 +750,7 @@ describe('what the hook leaves behind', () => {
     )
 
     const raw = readFileSync(activeLogPath(h.env), 'utf8')
-    expect(raw.match(/Allow exactly once/g)).toHaveLength(1)
+    expect(raw).not.toContain('Allow exactly once')
     const answerRecords = readLogRecords(h.env, { event: ['hook.answer'] }).records
     expect(answerRecords.map((record) => record.data?.['stage'])).toEqual([
       'queued',
@@ -835,7 +881,7 @@ describe('terminal-first grace window', () => {
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'present1' }))
 
-    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(1)
+    expect(h.recorder.submitted.filter((entry) => isQuestionSubmit(entry))).toHaveLength(1)
     expect(submittedAt).toBe(NOW)
   })
 
@@ -868,7 +914,7 @@ describe('terminal-first grace window', () => {
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'present3' }))
 
-    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(1)
+    expect(h.recorder.submitted.filter((entry) => isQuestionSubmit(entry))).toHaveLength(1)
     expect((h.deps.now?.() ?? NOW) - NOW).toBeGreaterThanOrEqual(120_000)
   })
 
@@ -897,7 +943,7 @@ describe('terminal-first grace window', () => {
     expect(h.deps.now?.()).toBeGreaterThanOrEqual(NOW + 360_000)
     expect(h.deps.now?.()).toBeLessThan(NOW + 361_000)
     expect(
-      h.recorder.submitted.find((entry) => entry.draft.event === 'agent_question')?.draft.reply
+      h.recorder.submitted.find((entry) => isQuestionSubmit(entry))?.draft.reply
         ?.expires_in_seconds,
     ).toBeGreaterThanOrEqual(60)
   })
@@ -1006,7 +1052,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.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(1)
+    expect(h.recorder.submitted.filter((entry) => isQuestionSubmit(entry))).toHaveLength(1)
   })
 
   it('respects the harness recursion guard', async () => {
@@ -1034,7 +1080,7 @@ describe('nagging guards', () => {
 
     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')
+    const questions = h.recorder.submitted.filter((entry) => isQuestionSubmit(entry))
     expect(questions.map((entry) => entry.draft.presentation.body)).toEqual([
       'First question?',
       'Follow-up question?',
@@ -1091,7 +1137,7 @@ describe('late answer collection', () => {
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'late-stop' }))
 
-    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(0)
+    expect(h.recorder.submitted.filter((entry) => isQuestionSubmit(entry))).toHaveLength(0)
     expect(h.recorder.closed).toContain('req_live')
     expect(readSessionState('late-stop', h.env).pending).toBeUndefined()
     expect(h.io.outLines).toHaveLength(1)
@@ -1138,14 +1184,10 @@ describe('late answer collection', () => {
       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_live',
-    })
-    expect(retirement?.lifecycle?.state).not.toBe('answered_elsewhere')
+    expect(h.recorder.closed).toContain('req_live')
+    expect(
+      h.recorder.submitted.filter((entry) => isRetirementSubmit(entry)),
+    ).toHaveLength(0)
     expect(readSessionState('late-prompt', h.env).pending).toBeUndefined()
     expect(readSessionState('late-prompt', h.env).accepted).toBeUndefined()
   })
@@ -1159,10 +1201,10 @@ describe('OpenCode answer continuation', () => {
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'open1' }), 'opencode')
 
-    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toHaveLength(0)
+    expect(h.recorder.submitted.filter((entry) => isQuestionSubmit(entry))).toHaveLength(0)
     expect(h.recorder.closed).toEqual([])
     expect(
-      h.recorder.submitted.filter((entry) => entry.draft.event === 'question_retired'),
+      h.recorder.submitted.filter((entry) => isRetirementSubmit(entry)),
     ).toHaveLength(0)
     expect(readSessionState('open1', h.env).pending).toBeUndefined()
     expect(h.io.outLines).toEqual([])
@@ -1236,7 +1278,7 @@ describe('the waiter owning one question to the end', () => {
       return {
         ...client,
         submit: async (body: SubmitNotificationRequestT) => {
-          if (body.draft.event !== 'agent_question') return client.submit(body, 0)
+          if (body.draft.reply === undefined) return client.submit(body, 0)
           acceptedRequestId = body.request_id
           h.recorder.submitted.push(body)
           h.recorder.receipts.push(body.request_id!)
@@ -1464,7 +1506,7 @@ describe('the waiter owning one question to the end', () => {
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'deadline' }))
 
-    expect(h.deps.now?.()).toBe(NOW + 60_000)
+    expect(h.deps.now?.()).toBe(NOW + 57_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')
@@ -1480,7 +1522,7 @@ describe('the waiter owning one question to the end', () => {
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'latency' }))
 
     const windows = h.recorder.submitted
-      .filter((entry) => entry.draft.event === 'agent_question')
+      .filter((entry) => isQuestionSubmit(entry))
       .map((entry) => entry.draft.reply?.expires_in_seconds)
     // How long the user may answer does not shrink because this owner spent
     // part of its own budget getting the question out. Both questions stay
@@ -1520,7 +1562,116 @@ describe('the waiter owning one question to the end', () => {
 
     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)
+    expect(h.recorder.submitted.filter((entry) => isQuestionSubmit(entry))).toHaveLength(2)
+  })
+
+  it('does not start another waiter for a live question whose owner lease is already spent', async () => {
+    const h = harness([])
+    h.recorder.replyExpiresAt = new Date(NOW + 86_400_000).toISOString()
+    writeSessionState('spent-owner', h.env, {
+      last_prompt_at: AWAY,
+      pending: [
+        {
+          question: 'Old question?',
+          asked_at: NOW - 3_300_000,
+          request_id: 'req_old',
+          collapse_key: 'question-old',
+          device_ids: ['dev_iphone'],
+          reply_deadline_at: NOW + 86_400_000,
+          owner_deadline_at: NOW - 1,
+        },
+      ],
+    })
+
+    const started = h.deps.now?.() ?? NOW
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'spent-owner' }))
+
+    expect(h.deps.now?.()).toBeLessThan(started + 30_000)
+    expect(h.recorder.submitted.filter((entry) => isQuestionSubmit(entry))).toHaveLength(0)
+    expect(readSessionState('spent-owner', h.env).pending?.[0]?.request_id).toBe('req_old')
+    expect(h.io.errLines.join('\n')).toContain('previous waiter already used its ceiling')
+  })
+
+  it('does not re-arm a live question written before owner leases were persisted', async () => {
+    const h = harness([])
+    h.recorder.replyExpiresAt = new Date(NOW + 86_400_000).toISOString()
+    writeSessionState('legacy-spent', h.env, {
+      last_prompt_at: AWAY,
+      pending: [
+        {
+          question: 'Degraded waiter leftover?',
+          asked_at: NOW - 3_300_000,
+          request_id: 'req_ATU4_legacy',
+          collapse_key: 'question-legacy',
+          device_ids: ['dev_iphone'],
+          reply_deadline_at: NOW + 86_400_000,
+        },
+      ],
+    })
+
+    const started = h.deps.now?.() ?? NOW
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'legacy-spent' }))
+
+    expect(h.deps.now?.()).toBeLessThan(started + 30_000)
+    expect(readSessionState('legacy-spent', h.env).pending?.[0]?.request_id).toBe(
+      'req_ATU4_legacy',
+    )
+  })
+
+  it('pushes a newly registered question on the next Stop after a spent waiter', async () => {
+    const h = harness([])
+    h.recorder.replyExpiresAt = new Date(NOW + 86_400_000).toISOString()
+    writeSessionState('after-degraded', h.env, {
+      last_prompt_at: AWAY,
+      pending: [
+        {
+          question: 'Earlier question?',
+          asked_at: NOW - 3_300_000,
+          request_id: 'req_earlier',
+          collapse_key: 'question-earlier',
+          device_ids: ['dev_iphone'],
+          reply_deadline_at: NOW + 86_400_000,
+        },
+      ],
+    })
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'after-degraded' }))
+    registerQuestion('after-degraded', h.env, { question: 'New question?' }, h.deps.now?.())
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'after-degraded' }))
+
+    const questions = h.recorder.submitted.filter((entry) => isQuestionSubmit(entry))
+    expect(questions.map((entry) => entry.draft.presentation.body)).toEqual(['New question?'])
+    expect(readSessionState('after-degraded', h.env).pending?.map((entry) => entry.question)).toEqual(
+      ['Earlier question?', 'New question?'],
+    )
+  })
+
+  it('still waits out a live owner lease for an independent answer', async () => {
+    const h = harness([])
+    const answerAt = NOW + 10_000
+    h.recorder.repliesFor = (requestId) =>
+      requestId === 'req_live' && (h.deps.now?.() ?? 0) >= answerAt
+        ? [reply({ text: 'Later' })]
+        : []
+    writeSessionState('lease', h.env, {
+      last_prompt_at: AWAY,
+      pending: [
+        {
+          question: 'Still waiting?',
+          asked_at: NOW,
+          request_id: 'req_live',
+          collapse_key: 'question-live',
+          device_ids: ['dev_iphone'],
+          reply_deadline_at: NOW + 86_400_000,
+          owner_deadline_at: NOW + 60_000,
+        },
+      ],
+    })
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'lease' }))
+
+    expect(JSON.parse(h.io.outLines.at(-1) ?? '{}').reason).toContain('Later')
+    expect(h.deps.now?.()).toBeGreaterThanOrEqual(answerAt)
   })
 })
 
@@ -1556,14 +1707,9 @@ describe('Cursor stop output', () => {
  * questions piling up on a phone teach the user to ignore the surface.
  */
 describe('question queueing and retirement debt', () => {
-  /** The lifecycle state of each retirement push the recorder captured. */
-  function retirements(h: Harness): { state: unknown; retires: unknown }[] {
-    return h.recorder.submitted
-      .filter((s) => s.draft.event === 'question_retired')
-      .map((s) => ({
-        state: s.draft.lifecycle?.state,
-        retires: s.draft.lifecycle?.retires_request_id,
-      }))
+  /** Request ids whose close fence proved retirement. */
+  function retirements(h: Harness): string[] {
+    return h.recorder.closed
   }
 
   function seedLive(h: Harness, sessionId: string, requestId = 'req_live'): void {
@@ -1603,13 +1749,17 @@ describe('question queueing and retirement debt', () => {
 
     // Offline when the user returns: the wipe parks the retirement, the
     // drain fails, and it must not forget what it was for.
-    h.recorder.failSubmits = true
-    await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 'sup2' }))
+    h.recorder.failCloses = true
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'sup2', prompt: 'done' }),
+    )
     expect(readSessionState('sup2', h.env).retiring).toHaveLength(1)
 
-    h.recorder.failSubmits = false
+    h.recorder.failCloses = false
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'sup2' }))
-    expect(retirements(h)).toContainEqual({ state: 'answered_elsewhere', retires: first })
+    expect(retirements(h)).toContain(first)
     expect(readSessionState('sup2', h.env).retiring).toEqual([])
   })
 
@@ -1629,16 +1779,22 @@ describe('question queueing and retirement debt', () => {
     const configDir = path.join(h.env['XDG_CONFIG_HOME'] as string, 'notifai')
     mkdirSync(configDir, { recursive: true })
     writeFileSync(path.join(configDir, 'config.toml'), 'devices = ["dev_iphone"]\n')
-    await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 'sup-targets' }))
-
-    const retirement = h.recorder.submitted.find(
-      (submission) => submission.draft.event === 'question_retired',
+    h.recorder.failCloses = true
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'sup-targets', prompt: 'done' }),
     )
-    expect(retirement?.draft.lifecycle?.retires_request_id).toBe('req_live')
-    expect(retirement?.draft.targets).toEqual({
-      mode: 'selected',
-      device_ids: ['dev_iphone', 'dev_mac'],
-    })
+
+    expect(readSessionState('sup-targets', h.env).retiring).toEqual([
+      expect.objectContaining({
+        request_id: 'req_live',
+        device_ids: ['dev_iphone', 'dev_mac'],
+      }),
+    ])
+    expect(
+      h.recorder.submitted.filter((submission) => isRetirementSubmit(submission)),
+    ).toHaveLength(0)
   })
 
   it('sweeps a queued retirement even on a turn continuing from an answer', async () => {
@@ -1649,14 +1805,18 @@ describe('question queueing and retirement debt', () => {
     seedLive(h, 'sup3')
     const first = 'req_live'
 
-    h.recorder.failSubmits = true
-    await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 'sup3' }))
+    h.recorder.failCloses = true
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'sup3', prompt: 'done' }),
+    )
     expect(readSessionState('sup3', h.env).retiring).toHaveLength(1)
-    h.recorder.failSubmits = false
+    h.recorder.failCloses = false
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'sup3', stop_hook_active: true }))
 
-    expect(retirements(h)).toContainEqual({ state: 'answered_elsewhere', retires: first })
+    expect(retirements(h)).toContain(first)
     expect(readSessionState('sup3', h.env).retiring).toEqual([])
   })
 
@@ -1669,13 +1829,21 @@ describe('question queueing and retirement debt', () => {
 
     // The first return is offline: the wipe parks, the drain fails, and the
     // next prompt must still find the debt.
-    h.recorder.failSubmits = true
-    await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 'sup4' }))
-    h.recorder.failSubmits = false
+    h.recorder.failCloses = true
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'sup4', prompt: 'done' }),
+    )
+    h.recorder.failCloses = false
 
-    await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 'sup4' }))
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'sup4', prompt: 'ok' }),
+    )
 
-    expect(retirements(h)).toContainEqual({ state: 'answered_elsewhere', retires: first })
+    expect(retirements(h)).toContain(first)
     expect(readSessionState('sup4', h.env).retiring).toEqual([])
   })
 
@@ -1709,7 +1877,7 @@ describe('several questions in flight', () => {
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'multi1' }))
 
-    const questions = h.recorder.submitted.filter((s) => s.draft.event === 'agent_question')
+    const questions = h.recorder.submitted.filter((s) => isQuestionSubmit(s))
     expect(questions.map((s) => s.draft.presentation.body)).toEqual(['Ship it?', 'Deploy where?'])
     // Each is its own notification with its own collapse key — one ask never
     // stands in for, or replaces, another.
@@ -1753,7 +1921,7 @@ describe('several questions in flight', () => {
       'codex',
     )
 
-    expect(h.recorder.submitted.filter((s) => s.draft.event === 'agent_question')).toHaveLength(1)
+    expect(h.recorder.submitted.filter((s) => isQuestionSubmit(s))).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/)
@@ -1787,7 +1955,7 @@ describe('several questions in flight', () => {
 
     // 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')
+    const questions = h.recorder.submitted.filter((s) => isQuestionSubmit(s))
     expect(questions).toHaveLength(1)
     expect(h.recorder.receipts[0]).toMatch(/^req_[A-Za-z0-9_-]{22,24}$/)
     expect(polls).toBeGreaterThanOrEqual(3)
@@ -1927,13 +2095,10 @@ describe('several questions in flight', () => {
     )
     expect(h.io.outLines).toEqual([])
     expect(readSessionState('answer-handoff', h.env).accepted).toBeUndefined()
+    expect(h.recorder.closed).toContain('req_existing')
     expect(
-      h.recorder.submitted.find(
-        (entry) =>
-          entry.draft.event === 'question_retired' &&
-          entry.draft.lifecycle?.retires_request_id === 'req_existing',
-      )?.draft.lifecycle?.state,
-    ).toBe('answered')
+      h.recorder.submitted.filter((entry) => isRetirementSubmit(entry)),
+    ).toHaveLength(0)
   })
 
   it('blocks Stop with the exact command until a required Agent Acknowledgement is recorded', async () => {
@@ -2123,19 +2288,14 @@ describe('several questions in flight', () => {
     expect(followup.reason).toContain('Staging')
     expect(readSessionState('multi3', h.env).pending).toBeUndefined()
     expect(
-      h.recorder.submitted.filter((s) => s.draft.event === 'agent_question'),
+      h.recorder.submitted.filter((s) => isQuestionSubmit(s)),
     ).toHaveLength(2)
   })
 })
 
 describe('a question that outlives its session', () => {
-  function retirements(h: Harness): { state: unknown; retires: unknown }[] {
-    return h.recorder.submitted
-      .filter((s) => s.draft.event === 'question_retired')
-      .map((s) => ({
-        state: s.draft.lifecycle?.state,
-        retires: s.draft.lifecycle?.retires_request_id,
-      }))
+  function retirements(h: Harness): string[] {
+    return h.recorder.closed
   }
 
   /** State a still-owned request can have when SessionEnd races its Stop. */
@@ -2166,7 +2326,7 @@ describe('a question that outlives its session', () => {
     // A different session's next hook holds a client and inherits the debt.
     await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 'next1' }))
     expect(h.recorder.closed).toContain(first)
-    expect(retirements(h)).toContainEqual({ state: 'expired', retires: first })
+    expect(retirements(h)).toContain(first)
   })
 
   it('carries parked retirements across SessionEnd too', async () => {
@@ -2175,13 +2335,17 @@ describe('a question that outlives its session', () => {
 
     // Died while offline: the user came back, the wipe parked the
     // retirement, and the drain could not send it.
-    h.recorder.failSubmits = true
-    await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 'dead2' }))
-    h.recorder.failSubmits = false
+    h.recorder.failCloses = true
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'dead2', prompt: 'done' }),
+    )
+    h.recorder.failCloses = false
 
     await hookRunCommand(h.deps, 'session-end', stdin({ session_id: 'dead2' }))
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'next2' }))
-    expect(retirements(h)).toContainEqual({ state: 'answered_elsewhere', retires: first })
+    expect(retirements(h)).toContain(first)
   })
 
   it('keeps the debt when the drain fails, and drops entries past the TTL', async () => {
@@ -2190,16 +2354,16 @@ describe('a question that outlives its session', () => {
     await hookRunCommand(h.deps, 'session-end', stdin({ session_id: 'dead3' }))
 
     // Still offline: the queue must survive a failed drain.
-    h.recorder.failSubmits = true
+    h.recorder.failCloses = true
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'next3' }))
-    h.recorder.failSubmits = false
+    h.recorder.failCloses = false
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'next3' }))
-    expect(retirements(h)).toContainEqual({ state: 'expired', retires: first })
+    expect(retirements(h)).toContain(first)
 
     // And a second drain does not send it twice.
-    const count = retirements(h).filter((r) => r.retires === first).length
+    const count = retirements(h).filter((id) => id === first).length
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'next3' }))
-    expect(retirements(h).filter((r) => r.retires === first)).toHaveLength(count)
+    expect(retirements(h).filter((id) => id === first)).toHaveLength(count)
   })
 
   it('gives up on an orphan that outlived the longest answerable window', async () => {
@@ -2323,9 +2487,9 @@ describe('ask registration', () => {
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'form1' }))
     const draft = h.recorder.submitted[0]?.draft
     expect(draft?.presentation.title).toBe('Deploy where?')
-    expect(draft?.presentation.body).toBe(
-      '1. Deploy where?\n2. Anything to watch?\n\n## Context\nThe long story.',
-    )
+    // The questions travel structured and the first one is the title; the
+    // body carries only the context so nothing renders twice.
+    expect(draft?.presentation.body).toBe('## Context\nThe long story.')
     expect(draft?.reply?.questions).toEqual([
       {
         id: 'deploy-where',
@@ -2466,7 +2630,347 @@ describe('ask registration', () => {
   })
 })
 
+describe('session-start hook', () => {
+  it('adds proactive Notifai context before setup or machine authentication exists', async () => {
+    const h = harness()
+    h.deps.store.load = () => null
+
+    for (const hookHarness of ['claude-code', 'codex'] as const) {
+      h.io.outLines = []
+      await hookRunCommand(
+        h.deps,
+        'session-start',
+        stdin({ session_id: `proactive-guidance-${hookHarness}`, source: 'startup' }),
+        hookHarness,
+      )
+
+      const first = JSON.parse(h.io.outLines.at(-1)!) as {
+        hookSpecificOutput?: { hookEventName?: string; additionalContext?: string }
+      }
+      expect(first.hookSpecificOutput).toMatchObject({
+        hookEventName: 'SessionStart',
+      })
+      expect(first.hookSpecificOutput?.additionalContext).toMatch(/Notifai.*session/i)
+      expect(first.hookSpecificOutput?.additionalContext).toMatch(
+        /before beginning task work.*use the Notifai skill.*run `notifai guidance`/i,
+      )
+      expect(first.hookSpecificOutput?.additionalContext).toMatch(/`notifai guidance`/i)
+      expect(first.hookSpecificOutput?.additionalContext).toMatch(/did not mention/i)
+      expect(h.io.errLines.join('\n')).not.toMatch(/not paired/i)
+    }
+  })
+
+  it('uses each supported lifecycle output contract and gives workers deterministic ownership', async () => {
+    const h = harness()
+    h.deps.store.load = () => null
+
+    await hookRunCommand(
+      h.deps,
+      'session-start',
+      stdin({ conversation_id: 'cursor-session', workspace_roots: [h.deps.cwd] }),
+      'cursor',
+    )
+    expect(JSON.parse(h.io.outLines.at(-1) ?? '{}')).toMatchObject({
+      additional_context: expect.stringMatching(/Notifai.*session/i),
+    })
+
+    h.io.outLines = []
+    await hookRunCommand(
+      h.deps,
+      'subagent-start',
+      stdin({ session_id: 'subagent-session' }),
+      'claude-code',
+    )
+    expect(JSON.parse(h.io.outLines.at(-1) ?? '{}')).toMatchObject({
+      hookSpecificOutput: {
+        hookEventName: 'SubagentStart',
+        additionalContext: expect.stringMatching(
+          /parent owns.*unless it explicitly delegates.*workers.*do not send independently/i,
+        ),
+      },
+    })
+  })
+
+  it('uses Cursor native Stop follow-up once when its SessionStart context is lossy', async () => {
+    const h = harness()
+    h.deps.store.load = () => null
+    const input = stdin({
+      conversation_id: 'cursor-activation',
+      workspace_roots: [h.deps.cwd],
+      loop_count: 0,
+    })
+
+    await hookRunCommand(h.deps, 'activation-stop', input, 'cursor')
+    expect(JSON.parse(h.io.outLines.at(-1) ?? '{}')).toMatchObject({
+      followup_message: expect.stringMatching(/before finalizing.*turn that just ended.*notifai guidance/i),
+    })
+
+    h.io.outLines = []
+    await hookRunCommand(
+      h.deps,
+      'activation-stop',
+      stdin({
+        conversation_id: 'cursor-activation',
+        workspace_roots: [h.deps.cwd],
+        loop_count: 1,
+      }),
+      'cursor',
+    )
+    expect(h.io.outLines).toEqual([])
+    expect(readSessionState('cursor-activation', h.env).cursor_activation_confirmed_at).toBe(NOW)
+
+    await hookRunCommand(
+      h.deps,
+      'session-start',
+      stdin({ conversation_id: 'cursor-activation', workspace_roots: [h.deps.cwd] }),
+      'cursor',
+    )
+    h.io.outLines = []
+    await hookRunCommand(h.deps, 'activation-stop', input, 'cursor')
+    expect(JSON.parse(h.io.outLines.at(-1) ?? '{}')).toHaveProperty('followup_message')
+  })
+
+  it('does not let Cursor activation override cancellation or a live question continuation', async () => {
+    const h = harness()
+    const base = {
+      conversation_id: 'cursor-coexistence',
+      workspace_roots: [h.deps.cwd],
+      loop_count: 0,
+    }
+
+    await hookRunCommand(
+      h.deps,
+      'activation-stop',
+      stdin({ ...base, status: 'aborted' }),
+      'cursor',
+    )
+    expect(h.io.outLines).toEqual([])
+
+    registerQuestion('cursor-coexistence', h.env, { question: 'Choose a path?' })
+    await hookRunCommand(
+      h.deps,
+      'activation-stop',
+      stdin({ ...base, status: 'completed' }),
+      'cursor',
+    )
+    expect(h.io.outLines).toEqual([])
+    expect(readSessionState('cursor-coexistence', h.env).cursor_activation_claimed_at).toBeUndefined()
+
+    await hookRunCommand(
+      h.deps,
+      'activation-stop',
+      stdin({ ...base, status: 'completed', loop_count: 1 }),
+      'cursor',
+    )
+    expect(h.io.outLines).toEqual([])
+    expect(readSessionState('cursor-coexistence', h.env).cursor_activation_confirmed_at).toBeUndefined()
+  })
+
+  it('retries an unconfirmed Cursor activation claim after the crash guard expires', async () => {
+    const h = harness()
+    const input = stdin({
+      conversation_id: 'cursor-activation-retry',
+      workspace_roots: [h.deps.cwd],
+      status: 'completed',
+      loop_count: 0,
+    })
+
+    await hookRunCommand(h.deps, 'activation-stop', input, 'cursor')
+    expect(JSON.parse(h.io.outLines.at(-1) ?? '{}')).toHaveProperty('followup_message')
+
+    h.io.outLines = []
+    await hookRunCommand(h.deps, 'activation-stop', input, 'cursor')
+    expect(h.io.outLines).toEqual([])
+
+    h.advanceClock(30_001)
+    await hookRunCommand(h.deps, 'activation-stop', input, 'cursor')
+    expect(JSON.parse(h.io.outLines.at(-1) ?? '{}')).toHaveProperty('followup_message')
+  })
+
+  it('fails closed without a Cursor conversation id and still activates after an errored turn', async () => {
+    const h = harness()
+
+    await hookRunCommand(
+      h.deps,
+      'activation-stop',
+      stdin({ workspace_roots: [h.deps.cwd], status: 'completed', loop_count: 0 }),
+      'cursor',
+    )
+    expect(h.io.outLines).toEqual([])
+
+    await hookRunCommand(
+      h.deps,
+      'activation-stop',
+      stdin({
+        conversation_id: 'cursor-error-activation',
+        workspace_roots: [h.deps.cwd],
+        status: 'error',
+        loop_count: 0,
+      }),
+      'cursor',
+    )
+    expect(JSON.parse(h.io.outLines.at(-1) ?? '{}')).toHaveProperty('followup_message')
+  })
+
+  it('makes a Claude compatibility copy inside Cursor a no-op', async () => {
+    const h = harness()
+    h.deps.env['CURSOR_PROJECT_DIR'] = h.deps.cwd
+
+    await hookRunCommand(
+      h.deps,
+      'session-start',
+      stdin({ session_id: 'cursor-compat-copy', source: 'startup' }),
+      'claude-code',
+    )
+
+    expect(h.io.outLines).toEqual([])
+  })
+})
+
 describe('user-prompt-submit hook', () => {
+  it('activates once as a compatibility fallback when SessionStart was absent', async () => {
+    const h = harness()
+
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'presence-only' }),
+      'claude-code',
+    )
+
+    expect(h.io.outLines).toHaveLength(1)
+    expect(JSON.parse(h.io.outLines[0] ?? '{}')).toMatchObject({
+      hookSpecificOutput: {
+        hookEventName: 'UserPromptSubmit',
+        additionalContext: expect.stringMatching(/Notifai.*session/i),
+      },
+    })
+    expect(readSessionState('presence-only', h.env).last_prompt_at).toBe(NOW)
+
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'presence-only' }),
+      'claude-code',
+    )
+    expect(h.io.outLines).toHaveLength(1)
+  })
+
+  it('stays silent when SessionStart already delivered activation', async () => {
+    const h = harness()
+    h.deps.codexSourcePid = 4242
+
+    await hookRunCommand(
+      h.deps,
+      'session-start',
+      stdin({ session_id: 'lifecycle-owned' }),
+      'codex',
+    )
+    h.io.outLines = []
+
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'lifecycle-owned' }),
+      'codex',
+    )
+
+    expect(h.io.outLines).toEqual([])
+  })
+
+  it('reactivates a resumed session owned by a new harness process', async () => {
+    const h = harness()
+    h.deps.codexSourcePid = 4242
+    await hookRunCommand(
+      h.deps,
+      'session-start',
+      stdin({ session_id: 'resumed-owner' }),
+      'codex',
+    )
+    h.io.outLines = []
+    h.deps.codexSourcePid = 4343
+
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'resumed-owner' }),
+      'codex',
+    )
+
+    expect(JSON.parse(h.io.outLines[0] ?? '{}')).toMatchObject({
+      hookSpecificOutput: { hookEventName: 'UserPromptSubmit' },
+    })
+  })
+
+  it('uses the adapter-propagated harness owner across per-hook CLI processes', async () => {
+    const h = harness()
+    h.env['NOTIFAI_HOOK_SOURCE_PID'] = '5252'
+
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'adapter-owned' }),
+      'codex',
+    )
+    h.io.outLines = []
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'adapter-owned' }),
+      'codex',
+    )
+    expect(h.io.outLines).toEqual([])
+
+    h.env['NOTIFAI_HOOK_SOURCE_PID'] = '5353'
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'adapter-owned' }),
+      'codex',
+    )
+    expect(h.io.outLines).toHaveLength(1)
+  })
+
+  it('does not let a worker lifecycle suppress parent prompt activation', async () => {
+    const h = harness()
+    h.deps.codexSourcePid = 4242
+    await hookRunCommand(
+      h.deps,
+      'subagent-start',
+      stdin({ session_id: 'shared-parent-worker' }),
+      'codex',
+    )
+    h.io.outLines = []
+
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'shared-parent-worker' }),
+      'codex',
+    )
+
+    expect(JSON.parse(h.io.outLines[0] ?? '{}')).toMatchObject({
+      hookSpecificOutput: { hookEventName: 'UserPromptSubmit' },
+    })
+  })
+
+  it('activates before config and authentication readiness', async () => {
+    const h = harness()
+    h.deps.cwd = path.join(h.deps.cwd, 'missing-project')
+    h.deps.store.load = () => null
+
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'first-run', cwd: h.deps.cwd }),
+      'codex',
+    )
+
+    expect(JSON.parse(h.io.outLines[0] ?? '{}')).toMatchObject({
+      hookSpecificOutput: { hookEventName: 'UserPromptSubmit' },
+    })
+  })
+
   it('records presence', async () => {
     const h = harness()
     await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 's10' }))
@@ -2532,7 +3036,7 @@ describe('user-prompt-submit hook', () => {
     expect(h.io.errLines.join('\n')).toMatch(/not paired|credential/i)
   })
 
-  it('preserves a delivered question through a second ask and the prompt transition', async () => {
+  it('preserves a delivered question through a second ask and an unrelated prompt', async () => {
     const h = harness([])
     const live = {
       question: 'Ship it?',
@@ -2543,10 +3047,6 @@ describe('user-prompt-submit hook', () => {
     }
     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.
     registerQuestion('transition', h.env, { question: 'Deploy it?' })
     const queued = readSessionState('transition', h.env)
     expect(queued.retiring ?? []).toEqual([])
@@ -2555,35 +3055,22 @@ describe('user-prompt-submit hook', () => {
     await hookRunCommand(
       h.deps,
       'user-prompt-submit',
-      stdin({ session_id: 'transition', cwd: h.deps.cwd }),
+      stdin({
+        session_id: 'transition',
+        cwd: h.deps.cwd,
+        prompt: 'keep going on the billing work',
+      }),
       'claude-code',
     )
 
-    // 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?.lifecycle).toEqual({
-      tier: 'done',
-      state: 'answered_elsewhere',
-      retires_request_id: live.request_id,
-    })
-    expect(retirement?.targets).toEqual({
-      mode: 'selected',
-      device_ids: ['dev_iphone', 'dev_mac'],
-    })
+    expect(h.recorder.closed).toEqual([])
     expect(
-      h.recorder.submitted.filter((s) => s.draft.event === 'question_retired'),
-    ).toHaveLength(1)
+      h.recorder.submitted.filter((s) => isRetirementSubmit(s)),
+    ).toHaveLength(0)
     expect(readSessionState('transition', h.env).pending?.map((entry) => entry.question)).toEqual([
+      'Ship it?',
       '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 real timed-out Stop before a later prompt can accept an answer', async () => {
@@ -2593,14 +3080,14 @@ describe('user-prompt-submit hook', () => {
 
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 's11' }))
     expect(readSessionState('s11', h.env).pending).toBeUndefined()
-    const retirementCount = h.recorder.submitted.filter(
-      (entry) => entry.draft.event === 'question_retired',
-    ).length
+    expect(h.recorder.closed).toContain(h.recorder.receipts[0])
 
     await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 's11', cwd: '/repo' }))
 
     expect(h.recorder.closed).toContain(h.recorder.receipts[0])
-    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'question_retired')).toHaveLength(retirementCount + 1)
+    expect(
+      h.recorder.submitted.filter((entry) => isRetirementSubmit(entry)),
+    ).toHaveLength(0)
   })
 
   it('marks the retirement done/answered_elsewhere so it ships silently', async () => {
@@ -2619,16 +3106,16 @@ describe('user-prompt-submit hook', () => {
       }],
     })
 
-    await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 's15', cwd: '/repo' }))
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 's15', cwd: '/repo', prompt: 'done' }),
+    )
 
-    const retirement = h.recorder.submitted.at(-1)?.draft
-    expect(retirement?.lifecycle).toEqual({
-      tier: 'done',
-      state: 'answered_elsewhere',
-      // The history-entry correlation id: companions key entries by request
-      // id and never persisted the collapse key.
-      retires_request_id: 'req_live',
-    })
+    expect(h.recorder.closed).toContain('req_live')
+    expect(
+      h.recorder.submitted.filter((entry) => isRetirementSubmit(entry)),
+    ).toHaveLength(0)
   })
 
   it('retires as done/answered when the answer came from a device', async () => {
@@ -2644,12 +3131,71 @@ describe('user-prompt-submit hook', () => {
       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: h.recorder.receipts[0],
+    expect(h.recorder.closed).toContain(h.recorder.receipts[0])
+    expect(
+      h.recorder.submitted.filter((entry) => isRetirementSubmit(entry)),
+    ).toHaveLength(0)
+  })
+
+  it('retires only the outstanding question a prompt uniquely answers', async () => {
+    const h = harness([])
+    writeSessionState('prompt-match', h.env, {
+      last_prompt_at: AWAY,
+      pending: [
+        {
+          question: 'Ship it?',
+          questions: [
+            {
+              id: 'q1',
+              text: 'Ship it?',
+              choices: [
+                { id: 'ship', label: 'Ship it' },
+                { id: 'wait', label: 'Wait' },
+              ],
+            },
+          ],
+          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: 'prompt-match', prompt: 'Ship it' }),
+    )
+
+    expect(h.recorder.closed).toContain('req_live')
+    expect(readSessionState('prompt-match', h.env).pending).toBeUndefined()
+  })
+
+  it('leaves an unrelated prompt’s live question open for the reply window', async () => {
+    const h = harness([])
+    writeSessionState('prompt-unrelated', h.env, {
+      last_prompt_at: AWAY,
+      pending: [{
+        question: 'Ship it?',
+        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: 'prompt-unrelated',
+        prompt: 'continue investigating the billing failure on staging',
+      }),
+    )
+
+    expect(h.recorder.closed).toEqual([])
+    expect(readSessionState('prompt-unrelated', h.env).pending?.[0]?.request_id).toBe('req_live')
   })
 
   it('publishes a session pointer so a plain `notifai ask` can find itself', async () => {
@@ -2730,6 +3276,83 @@ describe('user-prompt-submit hook', () => {
   })
 })
 
+describe('reconciling a conversation answer', () => {
+  it('matches a unique closed choice and a lone short confirmation', () => {
+    const choiceQuestion: PendingQuestion = {
+      question: 'Ship it?',
+      questions: [
+        {
+          id: 'q1',
+          text: 'Ship it?',
+          choices: [
+            { id: 'ship', label: 'Ship it' },
+            { id: 'wait', label: 'Wait' },
+          ],
+        },
+      ],
+    }
+    const freeText: PendingQuestion = { question: 'Create the key?' }
+    expect(pendingAnsweredByPrompt('Ship it', [choiceQuestion]).map((entry) => entry.question)).toEqual([
+      'Ship it?',
+    ])
+    expect(pendingAnsweredByPrompt('done', [freeText])).toEqual([freeText])
+    expect(pendingAnsweredByPrompt('done', [choiceQuestion, freeText])).toEqual([])
+    expect(pendingAnsweredByPrompt('keep going on the billing work', [freeText])).toEqual([])
+  })
+
+  it('does not push a conversation-answered question after a newer one is registered', async () => {
+    const h = harness([])
+    writeSessionState('stale-then-new', h.env, { last_prompt_at: AWAY })
+    registerQuestion('stale-then-new', h.env, { question: 'Create the Apple IAP key?' })
+
+    await hookRunCommand(
+      h.deps,
+      'user-prompt-submit',
+      stdin({ session_id: 'stale-then-new', prompt: 'done' }),
+    )
+    expect(readSessionState('stale-then-new', h.env).pending).toBeUndefined()
+
+    registerQuestion('stale-then-new', h.env, { question: 'Which ASN endpoint?' })
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'stale-then-new' }))
+
+    const questions = h.recorder.submitted.filter((entry) => isQuestionSubmit(entry))
+    expect(questions.map((entry) => entry.draft.presentation.body)).toEqual(['Which ASN endpoint?'])
+  })
+
+  it('reserves a close-fence budget when the owner deadline is nearly now', async () => {
+    const h = harness([])
+    const dir = path.join(h.env['XDG_CONFIG_HOME'] as string, 'notifai')
+    mkdirSync(dir, { recursive: true })
+    writeFileSync(path.join(dir, 'config.toml'), 'ask_grace_seconds = 0\n')
+    writeSessionState('near-zero', h.env, {
+      last_prompt_at: AWAY,
+      pending: [{
+        question: 'Ship it?',
+        asked_at: NOW - 60_000,
+        request_id: 'req_live',
+        collapse_key: 'collapse-live',
+        device_ids: ['dev_iphone'],
+        reply_deadline_at: NOW + 4_001,
+        owner_deadline_at: NOW + 4_001,
+      }],
+    })
+
+    await hookRunCommand(
+      { ...h.deps, logger: createLogger({ env: h.env, cmd: 'hook stop' }) },
+      'stop',
+      stdin({ session_id: 'near-zero', cwd: h.deps.cwd }),
+    )
+
+    expect(h.recorder.closed).toContain('req_live')
+    expect(
+      h.recorder.submitted.filter((entry) => isRetirementSubmit(entry)),
+    ).toHaveLength(0)
+    expect(h.deps.now?.()).toBeLessThan(NOW + 10_000)
+    const records = readLogRecords(h.env, { event: ['hook.retirement'] }).records
+    expect(records.some((record) => record.data?.['proven'] === true)).toBe(true)
+  })
+})
+
 describe('session-end hook', () => {
   it('drops local state without touching the network and records the lifecycle', async () => {
     const h = harness()
@@ -2818,7 +3441,7 @@ describe('session-end hook', () => {
         'the real Codex hook did not reach contended diagnostics before its deadline',
       )
 
-      // Reaching the second bakery ticket proves main.ts preAction did not write
+      // Reaching the second bakery ticket proves program.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)
@@ -2997,7 +3620,7 @@ describe('telling concurrent agents apart', () => {
       'claude-code',
     )
 
-    const question = h.recorder.submitted.find((entry) => entry.draft.event === 'agent_question')
+    const question = h.recorder.submitted.find((entry) => isQuestionSubmit(entry))
     expect(question?.draft.source).toEqual({
       session_id: 'session-branch-transition',
       session_label: 'Branch transition',
@@ -3019,15 +3642,10 @@ describe('telling concurrent agents apart', () => {
       'claude-code',
     )
 
-    const retirement = h.recorder.submitted.find(
-      (entry) => entry.draft.event === 'question_retired',
-    )
-    expect(retirement?.draft.source).toEqual({
-      session_id: 'session-branch-transition',
-      session_label: 'Branch transition',
-      harness: 'claude-code',
-      branch: 'branch-a',
-    })
+    expect(h.recorder.closed).toContain(h.recorder.receipts[0])
+    expect(
+      h.recorder.submitted.filter((entry) => isRetirementSubmit(entry)),
+    ).toHaveLength(0)
   })
 
   it('clears registration-time branch and worktree on a detached-HEAD hook event', async () => {
@@ -3057,7 +3675,7 @@ describe('telling concurrent agents apart', () => {
       'claude-code',
     )
 
-    const question = h.recorder.submitted.find((entry) => entry.draft.event === 'agent_question')
+    const question = h.recorder.submitted.find((entry) => isQuestionSubmit(entry))
     expect(question?.draft.source).toEqual({
       session_id: 'session-detached',
       session_label: 'Detached review',
@@ -3093,7 +3711,7 @@ describe('telling concurrent agents apart', () => {
         'claude-code',
       )
       const question = h.recorder.submitted.find(
-        (entry) => entry.draft.event === 'agent_question',
+        (entry) => isQuestionSubmit(entry),
       )
       expect(question?.draft.source).toEqual({
         session_id: 'session-worktree-transition',
@@ -3115,15 +3733,10 @@ describe('telling concurrent agents apart', () => {
         }),
         'claude-code',
       )
-      const retirement = h.recorder.submitted.find(
-        (entry) => entry.draft.event === 'question_retired',
-      )
-      expect(retirement?.draft.source).toEqual({
-        session_id: 'session-worktree-transition',
-        session_label: 'Worktree transition',
-        harness: 'claude-code',
-        branch: 'main',
-      })
+      expect(h.recorder.closed).toContain(h.recorder.receipts[0])
+      expect(
+        h.recorder.submitted.filter((entry) => isRetirementSubmit(entry)),
+      ).toHaveLength(0)
     } finally {
       runFixtureGit(h.deps.cwd, 'worktree', 'remove', '--force', linked)
     }
@@ -3179,12 +3792,10 @@ describe('telling concurrent agents apart', () => {
       stdin({ session_id: 'sess-abc', stop_hook_active: true }),
     )
 
-    const retirement = h.recorder.submitted.find((s) => s.draft.event === 'question_retired')
-    expect(retirement?.draft.source).toEqual({
-      session_id: 'sess-abc',
-      session_label: 'Semantic session',
-      harness: 'claude-code',
-    })
+    expect(h.recorder.closed).toContain(h.recorder.receipts[0])
+    expect(
+      h.recorder.submitted.filter((entry) => isRetirementSubmit(entry)),
+    ).toHaveLength(0)
   })
 
   it('preserves a human session label without displaying the opaque id', async () => {
@@ -3362,7 +3973,7 @@ describe('durable state writes', () => {
     expect(readFileSync(queueTarget, 'utf8')).toBe('[]\n')
   })
 
-  it('persists each successful retirement before a later corrupt entry interrupts the drain', async () => {
+  it('persists each successful retirement before a later close failure interrupts the drain', async () => {
     const h = harness()
     writeSessionState('partial-drain', h.env, {
       retiring: [
@@ -3376,24 +3987,30 @@ describe('durable state writes', () => {
         {
           request_id: 'req_bad',
           collapse_key: 'collapse-bad',
-          device_ids: [],
+          device_ids: ['dev_iphone'],
           question: 'Second?',
           state: 'expired',
         },
       ],
     })
+    const base = h.deps.clientFactory!('https://test.notifai.invalid', 'Bearer x')
     const ctx = {
-      client: h.deps.clientFactory('https://test.notifai.invalid', 'Bearer x'),
+      client: {
+        ...base,
+        closeReplies: async (requestId: string) => {
+          if (requestId === 'req_bad') throw new Error('offline')
+          return base.closeReplies(requestId)
+        },
+      },
       config: loadConfig({ cwd: h.deps.cwd, env: h.env }),
     }
 
-    await expect(drainRetirements(ctx, 'partial-drain', h.env)).rejects.toThrow(
-      /missing its device identifiers/,
-    )
+    await drainRetirements(ctx, 'partial-drain', h.env)
 
     expect(readSessionState('partial-drain', h.env).retiring?.map((entry) => entry.request_id)).toEqual([
       'req_bad',
     ])
+    expect(h.recorder.closed).toEqual(['req_good'])
   })
 })
 
@@ -3716,14 +4333,10 @@ describe('Claude Code Stop wake route', () => {
     expect(wake.sent).toHaveLength(1)
     expect(wake.resumed).toEqual([])
     expect(readSessionState('claude-route', h.env).accepted).toBeUndefined()
-    // Settled, not merely dropped: the answered question is retired truthfully.
+    expect(h.recorder.closed).toContain('req_existing')
     expect(
-      h.recorder.submitted.find(
-        (entry) =>
-          entry.draft.event === 'question_retired' &&
-          entry.draft.lifecycle?.retires_request_id === 'req_existing',
-      )?.draft.lifecycle?.state,
-    ).toBe('answered')
+      h.recorder.submitted.filter((entry) => isRetirementSubmit(entry)),
+    ).toHaveLength(0)
   })
 
   it('applies the continuation cap to a woken turn that never sets stop_hook_active', async () => {
@@ -3751,7 +4364,7 @@ describe('Claude Code Stop wake route', () => {
       'claude-code',
     )
 
-    expect(h.recorder.submitted.filter((entry) => entry.draft.event === 'agent_question')).toEqual(
+    expect(h.recorder.submitted.filter((entry) => isQuestionSubmit(entry))).toEqual(
       [],
     )
     expect(readSessionState('claude-route', h.env).pending?.[0]?.question).toBe('And after that?')