@raidiant/notifai 4.0.0 → 6.0.0

package/src/hooks.ts

@@ -11,6 +11,7 @@ import {
   writeFileSync,
 } from 'node:fs'
 import path from 'node:path'
+import { REPLY_MAX_WINDOW_SECONDS } from '@raidiant/notifai-protocol'
 import type {
   LifecycleEndState,
   ListRepliesResponse,
@@ -37,6 +38,7 @@ import {
 import { buildDraft } from './send.js'
 import { atomicWriteFileSync } from './atomic-file.js'
 import { withFileLock } from './file-lock.js'
+import { inferInvocationContext } from './invocation-context.js'
 import type { Logger } from './logging.js'
 import {
   HARNESS_CAPABILITIES,
@@ -127,11 +129,19 @@ export interface SessionState {
    * the service confirms the agent-authored follow-up exists.
    */
   acknowledgement_due?: AcknowledgementDue[]
+  /** Consecutive turns this session has been held for an acknowledgement. */
+  acknowledgement_blocks?: number
 }
 
 export interface AcknowledgementDue {
   request_id: string
   recorded_at: number
+  /**
+   * Whether this request's acknowledgement must carry text. Absent on state
+   * written before the obligation started recording it; treated as true, which
+   * is the default the service ships.
+   */
+  text_required?: boolean
 }
 
 interface AcceptedAnswerDelivery {
@@ -152,6 +162,8 @@ interface AcceptedAnswerDelivery {
    * passes through.
    */
   delivery_attempts?: number
+  /** Turns this answer has been held without being handed to the agent. */
+  held_deliveries?: number
 }
 
 /** A delivered question awaiting its retirement push. */
@@ -184,12 +196,15 @@ export interface OrphanRetirement extends RetiringQuestion {
 }
 
 /**
- * Past this, the question's reply window (3600s) has long expired server-side
- * and the companion shows it as dead on next open anyway; pushing a retirement
- * sync for it is noise. Also the backstop that keeps an unreachable server
- * from growing the queue for ever.
+ * A retirement is only worth syncing while the question it retires could still
+ * be answered, so this has to outlive the longest reply window a user can
+ * choose — it is derived from that bound rather than from a guess about how
+ * long questions stay open, which is exactly the assumption that broke when
+ * the window stopped being one hour. Past it the companion shows the question
+ * as dead on next open anyway. Also the backstop that keeps an unreachable
+ * server from growing the queue for ever.
  */
-const ORPHAN_TTL_MS = 24 * 3600 * 1000
+const ORPHAN_TTL_MS = (REPLY_MAX_WINDOW_SECONDS + 3600) * 1000
 
 /** More orphans than this means something is looping; keep the newest. */
 const ORPHAN_QUEUE_CAP = 50
@@ -228,6 +243,22 @@ export interface PendingQuestion {
   submission?: PendingSubmissionIntent
 }
 
+/** Keep immutable session grouping while replacing per-event Git location authoritatively. */
+function sourceContextAtHookEvent(
+  source: SourceContextT | undefined,
+  cwd: string | undefined,
+): SourceContextT | undefined {
+  const invocation = cwd === undefined ? null : inferInvocationContext(cwd)
+  const current: SourceContextT = {
+    ...(source?.session_id !== undefined ? { session_id: source.session_id } : {}),
+    ...(source?.session_label !== undefined ? { session_label: source.session_label } : {}),
+    ...(source?.harness !== undefined ? { harness: source.harness } : {}),
+    ...(invocation?.branch !== undefined ? { branch: invocation.branch } : {}),
+    ...(invocation?.worktree !== undefined ? { worktree: invocation.worktree } : {}),
+  }
+  return Object.keys(current).length === 0 ? undefined : current
+}
+
 interface PendingSubmissionIntent {
   request_id: string
   idempotency_key: string
@@ -258,12 +289,35 @@ function summarizeRequestIds(entries: readonly PendingQuestion[]): {
  */
 export const WAITER_CEILING_SECONDS = 480
 
+/**
+ * The same wall clock where the waiter runs in the background instead of
+ * inside a held turn.
+ *
+ * On a host that holds its turn, 480 s is a real cost to the person sitting in
+ * front of it, and the number above is right. On Claude Code the Stop hook
+ * returns at once and the waiter is detached, so the same 480 s buys nothing
+ * and costs a direct wake: an answer arriving at minute nine had to wait for
+ * the session's next turn even though nothing was blocked.
+ *
+ * This sits under `CLAUDE_ASYNC_STOP_TIMEOUT_SECONDS` (3600) with headroom,
+ * because that declaration's kill is silent, and under the reply window the
+ * question was pushed with. Past it the journal still delivers at the next
+ * turn — the ceiling decides how long a *direct* wake stays possible, never
+ * whether the answer survives.
+ */
+export const DETACHED_WAITER_CEILING_SECONDS = 3300
+
+/** The waiter's wall clock, which depends on whether a turn is held open for it. */
+export function waiterCeilingSeconds(detached: boolean): number {
+  return detached ? DETACHED_WAITER_CEILING_SECONDS : WAITER_CEILING_SECONDS
+}
+
 /**
  * The wire contract's shortest reply window. A question submitted with less
  * than this is rejected outright, and accepting one would in any case let the
  * server go on taking an answer after the waiter that owns it has returned.
  */
-const MIN_REPLY_WINDOW_SECONDS = 60
+export const MIN_REPLY_WINDOW_SECONDS = 60
 
 /**
  * The terminal-first wait: the question sits in the terminal for
@@ -476,6 +530,17 @@ export function pruneAbandonedSessions(
  * no trustworthy PID fall back to an age limit.
  */
 const CLAIM_TTL_MS = WAITER_CEILING_SECONDS * 1000
+
+/**
+ * How long a crashed claim *guard* blocks the next hook.
+ *
+ * The claim itself may legitimately be held for the whole waiter, so it takes
+ * that ceiling. The guard is a short lock around the claim's own bookkeeping —
+ * a few file operations — and borrowing the waiter's ceiling for it meant a
+ * hook killed at exactly the wrong moment wedged this session's Stop path for
+ * eight minutes, for a critical section that never runs longer than a second.
+ */
+const CLAIM_GUARD_TTL_MS = 30_000
 const heldClaims = new Map<string, string>()
 
 export function claimQuestionPush(
@@ -569,7 +634,7 @@ function acquireClaimGuard(file: string): boolean {
     } catch (err) {
       if ((err as NodeJS.ErrnoException).code !== 'EEXIST') return false
       try {
-        if (Date.now() - statSync(file).mtimeMs < CLAIM_TTL_MS) return false
+        if (Date.now() - statSync(file).mtimeMs < CLAIM_GUARD_TTL_MS) return false
       } catch {
         // A vanished/corrupt guard is safe to retry once.
       }
@@ -595,6 +660,50 @@ interface StoredProjectSessionPointer extends ProjectSessionPointer {
   updatedAt: number
 }
 
+interface StoredProjectSessionDocument {
+  root: Record<string, unknown>
+  sessions: unknown[]
+}
+
+export interface ProjectSessionPointer {
+  sessionId: string
+  harness: HookHarness
+}
+
+function storedProjectSessionPointer(candidate: unknown): StoredProjectSessionPointer | null {
+  if (typeof candidate !== 'object' || candidate === null || Array.isArray(candidate)) return null
+  const entry = candidate as {
+    session_id?: unknown
+    updated_at?: unknown
+    harness?: unknown
+  }
+  if (typeof entry.session_id !== 'string' || entry.session_id === '') return null
+  if (typeof entry.updated_at !== 'number') return null
+  if (!(HARNESSES as readonly unknown[]).includes(entry.harness)) return null
+  return {
+    sessionId: entry.session_id,
+    updatedAt: entry.updated_at,
+    harness: entry.harness as HookHarness,
+  }
+}
+
+function readStoredProjectSessionDocument(file: string): StoredProjectSessionDocument {
+  if (!existsSync(file)) return { root: {}, sessions: [] }
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(file, 'utf8'))
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+      return { root: {}, sessions: [] }
+    }
+    const root = parsed as Record<string, unknown>
+    return {
+      root,
+      sessions: Array.isArray(root['sessions']) ? root['sessions'] : [],
+    }
+  } catch {
+    return { root: {}, sessions: [] }
+  }
+}
+
 /** Records every live session working in a directory, for `notifai ask`. */
 export function writeProjectSession(
   cwd: string,
@@ -605,56 +714,37 @@ export function writeProjectSession(
 ): void {
   const file = projectSessionPointerPath(cwd, env)
   withFileLock(`${file}.lock`, () => {
-    const existing = readStoredProjectSessionPointers(file).filter(
-      (entry) => entry.sessionId !== sessionId && now - entry.updatedAt <= 24 * 3600 * 1000,
-    )
+    const stored = readStoredProjectSessionDocument(file)
+    const existing: unknown[] = []
+    let refreshed: Record<string, unknown> = {}
+    for (const candidate of stored.sessions) {
+      const entry = storedProjectSessionPointer(candidate)
+      if (entry?.sessionId === sessionId) {
+        refreshed = { ...refreshed, ...(candidate as Record<string, unknown>) }
+      } else if (entry === null || now - entry.updatedAt <= 24 * 3600 * 1000) {
+        existing.push(candidate)
+      }
+    }
     atomicWriteFileSync(
       file,
       `${JSON.stringify({
+        ...stored.root,
         sessions: [
-          ...existing.map((entry) => ({
-            session_id: entry.sessionId,
-            updated_at: entry.updatedAt,
-            harness: entry.harness,
-          })),
-          { session_id: sessionId, updated_at: now, harness },
+          ...existing,
+          { ...refreshed, session_id: sessionId, updated_at: now, harness },
         ],
       })}\n`,
     )
   })
 }
 
-export interface ProjectSessionPointer {
-  sessionId: string
-  harness: HookHarness
-}
-
 function readStoredProjectSessionPointers(file: string): StoredProjectSessionPointer[] {
-  if (!existsSync(file)) return []
-  try {
-    const parsed = JSON.parse(readFileSync(file, 'utf8')) as { sessions?: unknown }
-    if (!Array.isArray(parsed.sessions)) return []
-    return parsed.sessions.flatMap((candidate): StoredProjectSessionPointer[] => {
-      if (typeof candidate !== 'object' || candidate === null || Array.isArray(candidate)) return []
-      const entry = candidate as {
-        session_id?: unknown
-        updated_at?: unknown
-        harness?: unknown
-      }
-      if (typeof entry.session_id !== 'string' || entry.session_id === '') return []
-      if (typeof entry.updated_at !== 'number') return []
-      if (!(HARNESSES as readonly unknown[]).includes(entry.harness)) return []
-      return [
-        {
-          sessionId: entry.session_id,
-          updatedAt: entry.updated_at,
-          harness: entry.harness as HookHarness,
-        },
-      ]
-    })
-  } catch {
-    return []
-  }
+  return readStoredProjectSessionDocument(file).sessions.flatMap(
+    (candidate): StoredProjectSessionPointer[] => {
+      const entry = storedProjectSessionPointer(candidate)
+      return entry === null ? [] : [entry]
+    },
+  )
 }
 
 /**
@@ -744,21 +834,21 @@ function clearMatchingProjectSession(
 ): void {
   const file = projectSessionPointerPath(cwd, env)
   withFileLock(`${file}.lock`, () => {
-    const remaining = readStoredProjectSessionPointers(file).filter(
-      (entry) => entry.sessionId !== sessionId,
-    )
-    if (remaining.length === 0) {
+    const stored = readStoredProjectSessionDocument(file)
+    const remaining = stored.sessions.filter((candidate) => {
+      const entry = storedProjectSessionPointer(candidate)
+      return entry === null || entry.sessionId !== sessionId
+    })
+    const hasUnknownRootFields = Object.keys(stored.root).some((key) => key !== 'sessions')
+    if (remaining.length === 0 && !hasUnknownRootFields) {
       rmSync(file, { force: true })
       return
     }
     atomicWriteFileSync(
       file,
       `${JSON.stringify({
-        sessions: remaining.map((entry) => ({
-          session_id: entry.sessionId,
-          updated_at: entry.updatedAt,
-          harness: entry.harness,
-        })),
+        ...stored.root,
+        sessions: remaining,
       })}\n`,
     )
   })
@@ -795,19 +885,29 @@ export interface HookContext {
  * the user sees in the terminal — but it is free to be rewritten, and a log a
  * filter cannot rely on is a log nobody filters.
  */
-export type GateReason =
-  | 'no-session'
-  | 'no-question'
-  | 'answered'
-  | 'already-asked'
-  | 'continuation-repeat'
-  | 'continuation-limit'
-  | 'delivery-limit'
-  | 'acknowledgement-required'
-  | 'notifications-off'
-  | 'claimed-elsewhere'
-  | 'no-devices'
-  | 'proceeding'
+export const GATE_REASONS = [
+  'no-session',
+  'no-question',
+  'answered',
+  'continuation-repeat',
+  'continuation-limit',
+  'delivery-limit',
+  'acknowledgement-required',
+  'acknowledgement-abandoned',
+  'harness-cannot-continue',
+  'notifications-off',
+  'claimed-elsewhere',
+  'elapsed',
+  'proceeding',
+] as const
+
+/**
+ * A runtime list rather than a bare type, so the guidance that tells agents to
+ * filter on these can be tested against the set the code can actually emit.
+ * `already-asked` and `no-devices` were declared here for a long time and never
+ * emitted once; documenting them taught agents to filter for silence.
+ */
+export type GateReason = (typeof GATE_REASONS)[number]
 
 function gate(
   ctx: HookContext,
@@ -875,7 +975,7 @@ async function prepareQuestionSubmission(
       ...(options.media !== undefined ? { media: options.media } : {}),
       device: answerable,
       reply: true,
-      replyWindow: Math.max(60, options.windowSeconds),
+      replyWindow: Math.max(MIN_REPLY_WINDOW_SECONDS, options.windowSeconds),
       questions: options.questions,
       collapseKey,
     },
@@ -1001,7 +1101,8 @@ async function answerableDevices(ctx: HookContext): Promise<string[]> {
       (device) =>
         (device.platform === 'ios' || device.platform === 'macos') &&
         device.registration_healthy &&
-        device.reply_protocol_version === 2,
+        device.capabilities?.includes('answer') === true &&
+        device.derived_status !== 'must_update',
     )
     .filter((device) => configured === null || configured.includes(device.device_id))
     .map((device) => device.device_id)
@@ -1091,7 +1192,6 @@ const RETIREMENT_TITLES: Record<LifecycleEndState, string> = {
   answered: 'Answered',
   answered_elsewhere: 'Answered in the terminal',
   expired: 'Question expired',
-  superseded: 'Replaced by a newer question',
 }
 
 /**
@@ -1134,6 +1234,7 @@ export function parkForRetirement(
 function retiringQuestion(
   pending: PendingQuestion,
   state: LifecycleEndState,
+  cwd?: string,
 ): RetiringQuestion | null {
   const hasRequest = pending.request_id !== undefined
   const hasCollapse = pending.collapse_key !== undefined
@@ -1144,13 +1245,14 @@ function retiringQuestion(
       'live question state is incomplete; refusing to retire it without request, collapse, and device identifiers',
     )
   }
+  const source = sourceContextAtHookEvent(pending.source, cwd)
   return {
     request_id: pending.request_id!,
     collapse_key: pending.collapse_key!,
     device_ids: [...pending.device_ids!],
     question: pending.question,
     ...(pending.project !== undefined ? { project: pending.project } : {}),
-    ...(pending.source !== undefined ? { source: pending.source } : {}),
+    ...(source !== undefined ? { source } : {}),
     state,
   }
 }
@@ -1312,6 +1414,21 @@ const LATE_PROMPT_POLL_SECONDS = 3
  */
 export const MAX_CONTINUATION_COUNT = 3
 
+/**
+ * How many turns an answer may be *held* before it is settled unread.
+ *
+ * A hold is not a delivery: the route reported that it handed nothing over, so
+ * the agent has not seen the answer and the wake-loop the continuation cap
+ * exists to stop has not happened. Counting holds against that cap meant three
+ * turns where a liveness probe could not reach a busy session were enough to
+ * discard an answer the user had already given.
+ *
+ * It still has to end. A route that can never deliver would otherwise retry
+ * every turn for the life of the session, so holds get their own, far looser
+ * bound — loose because each one costs nothing and the answer is still wanted.
+ */
+export const MAX_HELD_DELIVERIES = 20
+
 interface PendingPoll {
   /** The answer to act on: the latest reply, because a later one corrects. */
   reply: ReplyView | null
@@ -1352,6 +1469,8 @@ interface AnsweredPending {
   replies: ReplyView[]
   /** Immutable server snapshot for this request, known after a replies/close response. */
   agent_acknowledgement_required?: boolean | undefined
+  /** Whether that acknowledgement must carry text; the account's snapshot. */
+  agent_acknowledgement_text_required?: boolean | undefined
 }
 
 interface FinalizedPending {
@@ -1384,6 +1503,8 @@ function finalizedAnswer(finalized: FinalizedPending): AnsweredPending | null {
         replies,
         agent_acknowledgement_required:
           finalized.response?.agent_acknowledgement_required,
+        agent_acknowledgement_text_required:
+          finalized.response?.agent_acknowledgement_text_required,
       }
 }
 
@@ -1449,6 +1570,46 @@ function isSamePending(a: PendingQuestion, b: PendingQuestion): boolean {
   return a.question === b.question && a.asked_at === b.asked_at
 }
 
+/**
+ * The frozen draft itself will never be accepted. Replaying it forever hides a
+ * contract-skew (deleted fields, unexpected properties) as a recoverable wait.
+ * Auth, conflicts, and timeouts are not this class.
+ */
+function isTerminalDraftRejection(err: ApiCallError): boolean {
+  return err.status === 422 || (err.status === 400 && err.code === 'invalid_request')
+}
+
+function dropPendingQuestion(
+  sessionId: string,
+  env: NodeJS.ProcessEnv,
+  entry: PendingQuestion,
+): void {
+  updateSessionState(sessionId, env, (current) => {
+    const pending = pendingList(current).filter((candidate) => !isSamePending(candidate, entry))
+    const next: SessionState = { ...current }
+    if (pending.length > 0) next.pending = pending
+    else delete next.pending
+    return next
+  })
+}
+
+function clearFrozenSubmission(
+  sessionId: string,
+  env: NodeJS.ProcessEnv,
+  entry: PendingQuestion,
+): void {
+  updateSessionState(sessionId, env, (current) => {
+    const list = pendingList(current)
+    const index = list.findIndex((candidate) => isSamePending(candidate, entry))
+    if (index < 0) return current
+    const next = [...list]
+    const copy = { ...next[index]! }
+    delete copy.submission
+    next[index] = copy
+    return { ...current, pending: next }
+  })
+}
+
 /** The question set this pending record pushes, however it was registered. */
 function pendingQuestions(pending: PendingQuestion): QuestionT[] {
   return pending.questions ?? [{ id: 'q1', text: pending.question }]
@@ -1496,8 +1657,20 @@ function answerContext(answered: AnsweredPending): string {
  * tied to the question that asked it, with a truthful note about anything
  * still waiting.
  */
-function acknowledgementCommand(requestId: string): string {
-  return `notifai acknowledge ${requestId} --text <text>`
+function acknowledgementCommand(requestId: string, textRequired = true): string {
+  return textRequired
+    ? `notifai acknowledge ${requestId} --text <text>`
+    : `notifai acknowledge ${requestId}`
+}
+
+/**
+ * The acknowledgement is owed either way; only its text is conditional. So the
+ * instruction never says "you may skip this" — it says what to run.
+ */
+function acknowledgementDemand(textRequired: boolean): string {
+  return textRequired
+    ? ' with non-empty text saying what concrete work you will do because of the reply; a bare acknowledgement is insufficient'
+    : ' exactly as shown; this account turned acknowledgement text off, so the receipt carries no words'
 }
 
 function acknowledgementContext(answered: AnsweredPending[]): string {
@@ -1509,20 +1682,23 @@ function acknowledgementContext(answered: AnsweredPending[]): string {
     return ' Agent Acknowledgement is not required for the answered request(s).'
   }
   if (due.length === 1) {
-    const requestId = due[0]!.pending.request_id!
+    const entry = due[0]!
+    const requestId = entry.pending.request_id!
+    const textRequired = entry.agent_acknowledgement_text_required !== false
     return (
       ` Agent Acknowledgement is required for request ${requestId}. Immediately, before doing the resumed work or ending this turn, run ` +
-      `\`${acknowledgementCommand(requestId)}\` with non-empty text saying what concrete work you will do because of the reply; a bare acknowledgement is insufficient.`
+      `\`${acknowledgementCommand(requestId, textRequired)}\`${acknowledgementDemand(textRequired)}.`
     )
   }
+  const anyTextRequired = due.some((entry) => entry.agent_acknowledgement_text_required !== false)
   const commands = due
     .map((entry) => {
       const requestId = entry.pending.request_id!
-      return `- ${requestId}: \`${acknowledgementCommand(requestId)}\``
+      return `- ${requestId}: \`${acknowledgementCommand(requestId, entry.agent_acknowledgement_text_required !== false)}\``
     })
     .join('\n')
   return (
-    ` Agent Acknowledgement is required for ${due.length} requests. Immediately, before doing the resumed work or ending this turn, run every command below with non-empty text saying what concrete work you will do because of that reply; a bare acknowledgement is insufficient:\n` +
+    ` Agent Acknowledgement is required for ${due.length} requests. Immediately, before doing the resumed work or ending this turn, run every command below${acknowledgementDemand(anyTextRequired)}:\n` +
     commands
   )
 }
@@ -1585,7 +1761,11 @@ function stageAcceptedAnswers(
         requestId !== undefined &&
         !acknowledgementDue.some((entry) => entry.request_id === requestId)
       ) {
-        acknowledgementDue.push({ request_id: requestId, recorded_at: accepted.recorded_at })
+        acknowledgementDue.push({
+          request_id: requestId,
+          recorded_at: accepted.recorded_at,
+          text_required: answer.agent_acknowledgement_text_required !== false,
+        })
       }
     }
     const next: SessionState = {
@@ -1633,14 +1813,83 @@ export function clearAcknowledgementObligation(
 
 function acknowledgementBlockContext(due: readonly AcknowledgementDue[]): string {
   const commands = due
-    .map((entry) => `- ${entry.request_id}: \`${acknowledgementCommand(entry.request_id)}\``)
+    .map(
+      (entry) =>
+        `- ${entry.request_id}: \`${acknowledgementCommand(entry.request_id, entry.text_required !== false)}\``,
+    )
     .join('\n')
+  const anyTextRequired = due.some((entry) => entry.text_required !== false)
   return (
     `Notifai — required Agent Acknowledgement${due.length === 1 ? '' : 's'} still missing for request${due.length === 1 ? '' : 's'} ${due.map((entry) => entry.request_id).join(', ')}. ` +
-    `Before doing more resumed work or ending this turn, run ${due.length === 1 ? 'this command' : 'every command'} with non-empty text saying what concrete work you will do because of the reply; a bare acknowledgement is insufficient:\n${commands}`
+    `Before doing more resumed work or ending this turn, run ${due.length === 1 ? 'this command' : 'every command'}${acknowledgementDemand(anyTextRequired)}:\n${commands}`
   )
 }
 
+/**
+ * How many turns in a row a session may be held waiting for an acknowledgement.
+ *
+ * The gate is the one place hooks deliberately break the fail-open rule, and it
+ * had no bound at all: an agent that could not or would not acknowledge — or a
+ * server that stayed unreachable, since an error here counts as unresolved —
+ * held every turn of that session for ever. Blocking a user's agent
+ * indefinitely does not get them an acknowledgement; it costs them the agent as
+ * well as the acknowledgement.
+ */
+const MAX_ACKNOWLEDGEMENT_BLOCKS = 3
+
+/**
+ * Hold the turn for an outstanding acknowledgement, or give up and let it
+ * through once holding has stopped being worth its cost.
+ *
+ * Returns the outcome that blocks the turn, or `null` to carry on.
+ */
+function holdForAcknowledgement(
+  ctx: HookContext,
+  sessionId: string,
+  due: readonly AcknowledgementDue[],
+  notes: string[],
+): HookOutcome | null {
+  if (due.length === 0) return null
+  const requestIds = due.map((entry) => entry.request_id)
+  const blocks = (readSessionState(sessionId, ctx.env).acknowledgement_blocks ?? 0) + 1
+  if (blocks > MAX_ACKNOWLEDGEMENT_BLOCKS) {
+    // Drop the obligation with the reason recorded. The answer was already
+    // delivered; what is lost is the agent's receipt for it, and the log is
+    // where that loss stays visible.
+    for (const requestId of requestIds) clearAcknowledgementObligation(sessionId, ctx.env, requestId)
+    resetAcknowledgementBlocks(sessionId, ctx.env)
+    gate(ctx, 'proceeding', 'acknowledgement-abandoned', {
+      request_ids: requestIds,
+      blocks: blocks - 1,
+      limit: MAX_ACKNOWLEDGEMENT_BLOCKS,
+    })
+    notes.push(
+      `no acknowledgement after ${MAX_ACKNOWLEDGEMENT_BLOCKS} turns; continuing without one rather than holding this session for ever`,
+    )
+    return null
+  }
+  updateSessionState(sessionId, ctx.env, (current) => ({
+    ...current,
+    acknowledgement_blocks: blocks,
+  }))
+  gate(ctx, 'held', 'acknowledgement-required', { request_ids: requestIds, blocks })
+  return {
+    stdout: stopAnswerOutput(acknowledgementBlockContext(due)),
+    notes,
+    log: { stage: 'acknowledgement-required', request_ids: requestIds },
+  }
+}
+
+/** A turn that was not held resets the streak; only consecutive holds count. */
+function resetAcknowledgementBlocks(sessionId: string, env: NodeJS.ProcessEnv): void {
+  updateSessionState(sessionId, env, (current) => {
+    if (current.acknowledgement_blocks === undefined) return current
+    const next = { ...current }
+    delete next.acknowledgement_blocks
+    return next
+  })
+}
+
 async function reconcileAcknowledgementObligations(
   ctx: HookContext,
   sessionId: string,
@@ -1686,9 +1935,10 @@ function settleAcceptedAnswers(
   ctx: HookContext,
   sessionId: string,
   accepted: AcceptedAnswerDelivery,
+  cwd?: string,
 ): void {
   const retirements = accepted.answers
-    .map(({ pending }) => retiringQuestion(pending, 'answered'))
+    .map(({ pending }) => retiringQuestion(pending, 'answered', cwd))
     .filter((entry): entry is RetiringQuestion => entry !== null)
   updateSessionState(sessionId, ctx.env, (current) => {
     const retiring = [...(current.retiring ?? [])]
@@ -1717,7 +1967,7 @@ async function retirePendings(
   updateSessionState(sessionId, ctx.env, (current) => {
     const retiring = [...(current.retiring ?? [])]
     for (const entry of entries) {
-      const retirement = retiringQuestion(entry, state)
+      const retirement = retiringQuestion(entry, state, envelope.cwd)
       if (retirement !== null && !retiring.some((item) => item.request_id === retirement.request_id)) {
         retiring.push(retirement)
       }
@@ -1800,6 +2050,9 @@ export async function handleUserPromptSubmit(
         agent_acknowledgement_required:
           response?.agent_acknowledgement_required ??
           entry.agent_acknowledgement_required,
+        agent_acknowledgement_text_required:
+          response?.agent_acknowledgement_text_required ??
+          entry.agent_acknowledgement_text_required,
       }
     })
     if (answered.length > 0) {
@@ -1824,7 +2077,7 @@ export async function handleUserPromptSubmit(
     const retiring = [...(current.retiring ?? [])]
     const unasked = pendingList(current).filter((entry) => entry.request_id === undefined)
     for (const entry of pendingList(current).filter((entry) => entry.request_id !== undefined)) {
-      const retirement = retiringQuestion(entry, 'answered_elsewhere')
+      const retirement = retiringQuestion(entry, 'answered_elsewhere', envelope.cwd)
       if (
         retirement !== null &&
         !retiring.some((parked) => parked.request_id === retirement.request_id)
@@ -1832,21 +2085,24 @@ export async function handleUserPromptSubmit(
         retiring.push(retirement)
       }
     }
-    return {
-      last_prompt_at: ctx.now(),
-      ...(current.last_stop_at === undefined ? {} : { last_stop_at: current.last_stop_at }),
-      ...(unasked.length > 0 ? { pending: unasked } : {}),
-      ...(retiring.length > 0 ? { retiring } : {}),
-      ...(current.accepted === undefined ? {} : { accepted: current.accepted }),
-      // The user typed, so whatever chain of answer-driven continuations was
-      // running, a human has taken the turn and the consecutive count starts
-      // over. Only a real prompt reaches here: the journal branch above returns
-      // first, and a wake route's injected message always arrives while its own
-      // answer is still journaled, so it can never pass for the user's presence.
-      ...(current.continuation === undefined
-        ? {}
-        : { continuation: { ...current.continuation, count: 0 } }),
+
+    // Start from the whole document so fields introduced by a newer CLI remain
+    // attached while this older writer applies the prompt transition it knows.
+    const next: SessionState = { ...current, last_prompt_at: ctx.now() }
+    if (unasked.length > 0) next.pending = unasked
+    else delete next.pending
+    if (retiring.length > 0) next.retiring = retiring
+    else delete next.retiring
+
+    // The user typed, so whatever chain of answer-driven continuations was
+    // running, a human has taken the turn and the consecutive count starts
+    // over. Only a real prompt reaches here: the journal branch above returns
+    // first, and a wake route's injected message always arrives while its own
+    // answer is still journaled, so it can never pass for the user's presence.
+    if (current.continuation !== undefined) {
+      next.continuation = { ...current.continuation, count: 0 }
     }
+    return next
   })
   // The bridge that lets a plain `notifai ask` find the hook's canonical
   // session: an agent shell command gets no hook payload, and not every
@@ -1970,9 +2226,16 @@ export async function runEscalationWaiter(
         accepted.delivered_at !== undefined || envelope.stop_hook_active === true
       if (!deliveryProven) {
         for (const answer of accepted.answers) reportAnswer(ctx, notes, answer, true)
-        return await deliverAcceptedAnswers(ctx, sessionId, options.route, accepted, notes)
+        return await deliverAcceptedAnswers(
+          ctx,
+          sessionId,
+          options.route,
+          accepted,
+          notes,
+          envelope.cwd,
+        )
       }
-      settleAcceptedAnswers(ctx, sessionId, accepted)
+      settleAcceptedAnswers(ctx, sessionId, accepted, envelope.cwd)
       settledAnswerThisPass = true
       state = readSessionState(sessionId, ctx.env)
       const currentAcceptedIds = new Set(
@@ -1987,19 +2250,8 @@ export async function runEscalationWaiter(
           currentAcceptedIds.has(entry.request_id),
         ),
       )
-      if (due.length > 0) {
-        gate(ctx, 'held', 'acknowledgement-required', {
-          request_ids: due.map((entry) => entry.request_id),
-        })
-        return {
-          stdout: stopAnswerOutput(acknowledgementBlockContext(due)),
-          notes,
-          log: {
-            stage: 'acknowledgement-required',
-            request_ids: due.map((entry) => entry.request_id),
-          },
-        }
-      }
+      const held = holdForAcknowledgement(ctx, sessionId, due, notes)
+      if (held !== null) return held
       state = readSessionState(sessionId, ctx.env)
     }
 
@@ -2009,19 +2261,9 @@ export async function runEscalationWaiter(
         sessionId,
         state.acknowledgement_due!,
       )
-      if (due.length > 0) {
-        gate(ctx, 'held', 'acknowledgement-required', {
-          request_ids: due.map((entry) => entry.request_id),
-        })
-        return {
-          stdout: stopAnswerOutput(acknowledgementBlockContext(due)),
-          notes,
-          log: {
-            stage: 'acknowledgement-required',
-            request_ids: due.map((entry) => entry.request_id),
-          },
-        }
-      }
+      const held = holdForAcknowledgement(ctx, sessionId, due, notes)
+      if (held !== null) return held
+      resetAcknowledgementBlocks(sessionId, ctx.env)
       state = readSessionState(sessionId, ctx.env)
     }
 
@@ -2089,9 +2331,24 @@ async function deliverAcceptedAnswers(
   route: EscalationDeliveryRoute,
   accepted: AcceptedAnswerDelivery,
   notes: string[],
+  cwd?: string,
 ): Promise<HookOutcome> {
   const { answers: answered, remaining } = accepted
   const requestIds = summarizeRequestIds(answered.map((entry) => entry.pending)).ids
+  const held = accepted.held_deliveries ?? 0
+  if (held >= MAX_HELD_DELIVERIES) {
+    gate(ctx, 'held', 'delivery-limit', {
+      route: route.kind,
+      held,
+      limit: MAX_HELD_DELIVERIES,
+      request_ids: requestIds,
+    })
+    settleAcceptedAnswers(ctx, sessionId, accepted, cwd)
+    notes.push(
+      `no route could hand the user's answer over in ${MAX_HELD_DELIVERIES} turns; not holding it any longer`,
+    )
+    return { notes }
+  }
   const attempt = (accepted.delivery_attempts ?? 0) + 1
   if (attempt > MAX_CONTINUATION_COUNT) {
     gate(ctx, 'held', 'delivery-limit', {
@@ -2103,7 +2360,7 @@ async function deliverAcceptedAnswers(
     // Settle rather than journal for ever. The answer has been offered as often
     // as any working route could need, it is already in the notes of each of
     // those turns, and the questions it answered still deserve retirement.
-    settleAcceptedAnswers(ctx, sessionId, accepted)
+    settleAcceptedAnswers(ctx, sessionId, accepted, cwd)
     notes.push(
       `the user's answer reached the ${route.kind} route ${MAX_CONTINUATION_COUNT} times without being acknowledged; not delivering it again`,
     )
@@ -2142,6 +2399,17 @@ async function deliverAcceptedAnswers(
       delivered_at: ctx.now(),
       delivered_route: deliveredRoute,
     }))
+  } else if (delivered.acknowledgement === 'held') {
+    // Give the delivery attempt back and count the hold instead. The attempt
+    // was counted before the call because one that dies mid-delivery still
+    // happened and a counter written afterwards could be evaded by crashing —
+    // but a route that *returns* `held` proves both that this process survived
+    // and that nothing was handed over.
+    amendAcceptedAnswers(ctx, sessionId, (current) => ({
+      ...current,
+      delivery_attempts: accepted.delivery_attempts ?? 0,
+      held_deliveries: (current.held_deliveries ?? 0) + 1,
+    }))
   }
   ctx.log?.info('hook.answer', {
     answered: true,
@@ -2182,7 +2450,11 @@ async function handleClaimedStop(
   ) {
     for (const entry of live) await closeQuietly(ctx, entry.request_id!)
     await retirePendings(ctx, envelope, sessionId, pending, 'expired')
-    gate(ctx, 'held', 'no-question')
+    // Not `no-question`: there was a question, and this says so. Reading the
+    // log to find out why an ask never travelled is the whole reason these
+    // reasons exist, and the wrong one sent that reader looking for a question
+    // that was right there.
+    gate(ctx, 'held', 'harness-cannot-continue', { harness: ctx.harness })
     notes.push(`${HARNESS_CAPABILITIES[ctx.harness].deliveryContract}; use a blocking \`notifai send --reply\` question`)
     return { notes }
   }
@@ -2224,6 +2496,9 @@ async function handleClaimedStop(
         agent_acknowledgement_required:
           response?.agent_acknowledgement_required ??
           entry.agent_acknowledgement_required,
+        agent_acknowledgement_text_required:
+          response?.agent_acknowledgement_text_required ??
+          entry.agent_acknowledgement_text_required,
       }
       })
       const accepted = stageAcceptedAnswers(
@@ -2235,7 +2510,7 @@ async function handleClaimedStop(
       for (const answer of authoritative) reportAnswer(ctx, notes, answer, true)
       // Anything still unasked rides the next Stop: the agent is being resumed
       // with answers right now, and may not even need the rest afterwards.
-      return deliverAcceptedAnswers(ctx, sessionId, route, accepted, notes)
+      return deliverAcceptedAnswers(ctx, sessionId, route, accepted, notes, envelope.cwd)
     }
     const recoverableLive = live.filter(
       (entry) => !permanentFailures.has(entry.request_id!),
@@ -2352,7 +2627,7 @@ async function escalate(
     await awaitTerminalFirstWindow(ctx, oldest, ceilingAt)
     ctx.log?.debug('hook.gate', {
       verdict: 'grace',
-      reason: 'elapsed',
+      reason: 'elapsed' satisfies GateReason,
       waited_from: oldest,
       grace_seconds: ctx.config.ask_grace_seconds.value,
     })
@@ -2361,18 +2636,28 @@ async function escalate(
   // its own notification — one ask never stands in for another.
   const submitted: PendingQuestion[] = []
   for (const entry of unasked) {
-    // The reply window is the question's own: whatever is left of the waiter's
-    // ceiling, granted to the server so it stops accepting answers at the same
-    // moment this owner stops listening for them.
-    const replyWindowSeconds = Math.floor((ceilingAt - ctx.now()) / 1000)
-    if (replyWindowSeconds < MIN_REPLY_WINDOW_SECONDS) {
+    // How long the answer is accepted, and how long this owner listens for it,
+    // are two different spans. They used to be one: the window was whatever
+    // remained of the waiter's ceiling, so a question asked at a turn's end
+    // stopped being answerable about eight minutes later, whatever the user
+    // had configured.
+    //
+    // That was right when the waiter was the only way an answer came back. It
+    // is not any more: a late answer is found by the next turn's poll or
+    // replayed from the journal, so this owner giving up listening says
+    // nothing about whether the user's answer is still wanted.
+    const replyWindowSeconds = ctx.config.reply_window_seconds.value
+    if (ceilingAt - ctx.now() < MIN_REPLY_WINDOW_SECONDS * 1000) {
       notes.push(
-        'too little of the waiter ceiling is left for a reply window the server would accept; leaving this question in the terminal',
+        'too little of the waiter ceiling is left to submit and confirm this question; leaving it in the terminal',
       )
       continue
     }
+    // The owner still stops listening at its own ceiling. Only the span the
+    // server accepts answers into changed.
     const ownerDeadlineAt = ceilingAt
     const questions = pendingQuestions(entry)
+    const eventSource = sourceContextAtHookEvent(entry.source, envelope.cwd)
     let intent = entry.submission
     if (intent === undefined) {
       if (entry.body === undefined) {
@@ -2386,7 +2671,7 @@ async function escalate(
         questions,
         ...(entry.media !== undefined ? { media: entry.media } : {}),
         ...(entry.project !== undefined ? { project: entry.project } : {}),
-        ...(entry.source !== undefined ? { source: entry.source } : {}),
+        ...(eventSource !== undefined ? { source: eventSource } : {}),
         event: 'agent_question',
         windowSeconds: replyWindowSeconds,
         ownerDeadlineAt,
@@ -2439,12 +2724,80 @@ async function escalate(
     try {
       receipt = await submitQuestion(ctx, intent)
       admissionConfirmed = true
-    } catch (err) {
-      if (err instanceof ApiCallError && err.status < 500 && err.status !== 408) {
-        // A concrete client response is an admission rejection, not an
-        // ambiguous commit. Keep the frozen intent for a later retry and leave
-        // the question in the terminal; polling a request the server says it
-        // did not accept only burns the owner window and hides the real fault.
+    } catch (caught) {
+      let err: unknown = caught
+      if (err instanceof ApiCallError && isTerminalDraftRejection(err)) {
+        ctx.log?.error('hook.pushed', {
+          ok: false,
+          request_id: intent.request_id,
+          status: err.status,
+          code: err.code,
+          message: err.message,
+        })
+        if (entry.submission !== undefined) {
+          notes.push(
+            `question submission was rejected (${err.code}, HTTP ${err.status}); reminting the draft in the current contract instead of replaying the frozen one`,
+          )
+          clearFrozenSubmission(sessionId, ctx.env, entry)
+          if (entry.body === undefined) {
+            dropPendingQuestion(sessionId, ctx.env, entry)
+            notes.push('registered question has no canonical body; retired the frozen draft instead of retrying it')
+            continue
+          }
+          const reminted = await prepareQuestionSubmission(ctx, {
+            title: questions[0]!.text,
+            body: entry.body,
+            questions,
+            ...(entry.media !== undefined ? { media: entry.media } : {}),
+            ...(entry.project !== undefined ? { project: entry.project } : {}),
+            ...(eventSource !== undefined ? { source: eventSource } : {}),
+            event: 'agent_question',
+            windowSeconds: replyWindowSeconds,
+            ownerDeadlineAt,
+          })
+          if ('error' in reminted) {
+            dropPendingQuestion(sessionId, ctx.env, entry)
+            notes.push(reminted.error)
+            continue
+          }
+          intent = reminted
+          updateSessionState(sessionId, ctx.env, (current) => {
+            const list = pendingList(current)
+            const index = list.findIndex((candidate) => isSamePending(candidate, entry))
+            if (index < 0) return current
+            const next = [...list]
+            next[index] = { ...next[index]!, submission: reminted }
+            return { ...current, pending: next }
+          })
+          try {
+            receipt = await submitQuestion(ctx, intent)
+            admissionConfirmed = true
+          } catch (retryErr) {
+            if (retryErr instanceof ApiCallError && isTerminalDraftRejection(retryErr)) {
+              dropPendingQuestion(sessionId, ctx.env, entry)
+              notes.push(
+                `reminted draft was also rejected (${retryErr.code}, HTTP ${retryErr.status}); retiring the question so it is not retried forever`,
+              )
+              ctx.log?.error('hook.pushed', {
+                ok: false,
+                request_id: intent.request_id,
+                status: retryErr.status,
+                code: retryErr.code,
+                message: retryErr.message,
+              })
+              continue
+            }
+            err = retryErr
+          }
+        } else {
+          dropPendingQuestion(sessionId, ctx.env, entry)
+          notes.push(
+            `question submission was rejected (${err.code}, HTTP ${err.status}); retiring it because the current draft will never be accepted`,
+          )
+          continue
+        }
+      }
+      if (!admissionConfirmed && err instanceof ApiCallError && err.status < 500 && err.status !== 408) {
         notes.push(
           `question submission was rejected (${err.code}, HTTP ${err.status}); preserving it for recovery`,
         )
@@ -2457,11 +2810,10 @@ async function escalate(
         })
         continue
       }
-      // This is deliberately not a fail-open return. A transport failure is
-      // ambiguous: the server may already have dispatched the card. The
-      // client-generated request id keeps polling/finalization possible.
-      notes.push(`question submission response was ambiguous; recovering ${intent.request_id}`)
-      ctx.log?.error('hook.pushed', { ok: false, request_id: intent.request_id, message: String(err) })
+      if (!admissionConfirmed) {
+        notes.push(`question submission response was ambiguous; recovering ${intent.request_id}`)
+        ctx.log?.error('hook.pushed', { ok: false, request_id: intent.request_id, message: String(err) })
+      }
     }
     if (admissionConfirmed) {
       ctx.log?.info('hook.pushed', {
@@ -2478,20 +2830,27 @@ async function escalate(
         : Date.parse(receipt.reply_expires_at)
     const live: PendingQuestion = {
       ...entry,
+      ...(intent.draft.source !== undefined ? { source: intent.draft.source } : {}),
       request_id: intent.request_id,
       collapse_key: intent.collapse_key,
       device_ids: intent.device_ids,
-      // Submission and every later poll share one wall-clock owner. The
-      // server may start its relative window a little later while the submit
-      // response is in flight; closing at this deadline is therefore the
-      // authoritative backstop against accepting an answer into a void.
-      reply_deadline_at: Math.min(
-        intent.owner_deadline_at,
-        Number.isFinite(committedReplyDeadline)
-          ? committedReplyDeadline
-          : intent.owner_deadline_at,
-      ),
+      // When the server stops accepting an answer — not when this owner stops
+      // waiting for one. Those were the same number until the window became a
+      // setting, and taking the minimum silently capped every question at the
+      // waiter's ceiling: a question asked with a day-long window was swept as
+      // stale about eight minutes later and retired, so the answer given over
+      // lunch met a closed question.
+      //
+      // Both consumers of this field already clamp to the owner's own ceiling
+      // (`Math.min(hardDeadlineAt, …)` when deriving the ceiling, and
+      // `Math.min(ceilingAt, …)` when deriving the wait), so recording the
+      // real expiry here lengthens what the user gets without lengthening what
+      // this process waits.
+      reply_deadline_at: Number.isFinite(committedReplyDeadline)
+        ? committedReplyDeadline
+        : intent.owner_deadline_at,
     }
+    if (intent.draft.source === undefined) delete live.source
     delete live.submission
     submitted.push(live)
     // Record what is now live on the user's devices BEFORE any wait. If we
@@ -2513,7 +2872,7 @@ async function escalate(
         // The entry vanished while the submit was in flight (the user's prompt
         // wiped the queue). The delivered notification must still be retirable,
         // so park it rather than lose its only identifiers.
-        const retirement = retiringQuestion(live, 'answered_elsewhere')!
+        const retirement = retiringQuestion(live, 'answered_elsewhere', envelope.cwd)!
         const retiring = [...(current.retiring ?? [])]
         if (!retiring.some((parked) => parked.request_id === retirement.request_id)) {
           retiring.push(retirement)
@@ -2553,7 +2912,7 @@ async function escalate(
     )
     const accepted = stageAcceptedAnswers(ctx, sessionId, staleAnswers, remaining)
     for (const answer of staleAnswers) reportAnswer(ctx, notes, answer, true)
-    return deliverAcceptedAnswers(ctx, sessionId, route, accepted, notes)
+    return deliverAcceptedAnswers(ctx, sessionId, route, accepted, notes, envelope.cwd)
   }
   const waitingOn = [
     ...alreadyLive.filter(
@@ -2578,10 +2937,37 @@ async function escalate(
   if (permanentFailure !== null) notes.push(permanentFailure)
 
   if (waited.byRequest.size === 0) {
-    // Once this owner returns, no shipped command-hook harness can guarantee
-    // a later answer reaches the same agent turn. Close first, then retire the
-    // local records, so the Companion never accepts an answer into a void.
-    const finalized = await finalizePendings(ctx, waitingOn)
+    // This owner is done listening. That used to mean the question was over:
+    // it closed the window server-side and retired the record, on the reasoning
+    // that no later answer could reach the same agent turn.
+    //
+    // The reaching was never the point — the *accepting* is. A question whose
+    // window is still open is polled again by the next prompt and the next
+    // Stop, and an answer found there is journaled and replayed. Closing here
+    // capped every question at this owner's ceiling however long a window the
+    // user had configured, which is what made a day-long window mean eight
+    // minutes.
+    //
+    // So: finalize only what the server has genuinely stopped accepting, and
+    // leave the rest live for the turn that comes next. A session that truly
+    // ends still retires its questions — that is what the session-end hook is
+    // for, and it is the honest place for it.
+    const expired = waitingOn.filter(
+      (entry) =>
+        entry.reply_deadline_at === undefined ||
+        entry.reply_deadline_at <= ctx.now() ||
+        // A permanent rejection is the server saying this question can never be
+        // answered, whatever its window says. Leaving it open would strand a
+        // dead question on the user's devices.
+        waited.permanentFailures.has(entry.request_id!),
+    )
+    const stillAnswerable = waitingOn.filter((entry) => !expired.includes(entry))
+    if (stillAnswerable.length > 0) {
+      notes.push(
+        `${stillAnswerable.length} question${stillAnswerable.length === 1 ? ' is' : 's are'} still answerable; leaving ${stillAnswerable.length === 1 ? 'it' : 'them'} open for the next turn rather than closing ${stillAnswerable.length === 1 ? 'it' : 'them'} with this waiter`,
+      )
+    }
+    const finalized = await finalizePendings(ctx, expired)
     const finalAnswers = finalized
       .map(finalizedAnswer)
       .filter((entry): entry is AnsweredPending => entry !== null)
@@ -2604,7 +2990,7 @@ async function escalate(
       )
       const accepted = stageAcceptedAnswers(ctx, sessionId, finalAnswers, remaining)
       for (const answer of finalAnswers) reportAnswer(ctx, notes, answer, false)
-      return deliverAcceptedAnswers(ctx, sessionId, route, accepted, notes)
+      return deliverAcceptedAnswers(ctx, sessionId, route, accepted, notes, envelope.cwd)
     }
     const requestIdSummary = summarizeRequestIds(waitingOn)
     ctx.log?.info('hook.answer', {
@@ -2643,6 +3029,8 @@ async function escalate(
       replies: authoritative,
       agent_acknowledgement_required:
         finalized.response?.agent_acknowledgement_required,
+      agent_acknowledgement_text_required:
+        finalized.response?.agent_acknowledgement_text_required,
     })
     if (finalized.response === null) {
       notes.push(
@@ -2657,7 +3045,7 @@ async function escalate(
     waitingOn.length - answered.length,
   )
   for (const answer of answered) reportAnswer(ctx, notes, answer, false)
-  return deliverAcceptedAnswers(ctx, sessionId, route, accepted, notes)
+  return deliverAcceptedAnswers(ctx, sessionId, route, accepted, notes, envelope.cwd)
 }
 
 // ---------------------------------------------------------------------------
@@ -2686,7 +3074,7 @@ export function handleSessionEnd(
   const orphans: RetiringQuestion[] = [...(state.retiring ?? [])]
   for (const entry of pendingList(state)) {
     try {
-      const orphan = retiringQuestion(entry, 'expired')
+      const orphan = retiringQuestion(entry, 'expired', envelope.cwd)
       if (orphan !== null) orphans.push(orphan)
     } catch (err) {
       notes.push(err instanceof Error ? err.message : String(err))
@@ -2705,14 +3093,13 @@ export function handleSessionEnd(
     )
   }
   if (state.accepted !== undefined || (state.acknowledgement_due?.length ?? 0) > 0) {
-    const preserved: SessionState = {}
-    if (state.accepted !== undefined) preserved.accepted = state.accepted
-    if (state.acknowledgement_due !== undefined && state.acknowledgement_due.length > 0) {
-      preserved.acknowledgement_due = state.acknowledgement_due
+    const preserved: SessionState = { ...state }
+    delete preserved.pending
+    delete preserved.retiring
+    delete preserved.acknowledgement_blocks
+    if ((preserved.acknowledgement_due?.length ?? 0) === 0) {
+      delete preserved.acknowledgement_due
     }
-    if (state.last_prompt_at !== undefined) preserved.last_prompt_at = state.last_prompt_at
-    if (state.last_stop_at !== undefined) preserved.last_stop_at = state.last_stop_at
-    if (state.continuation !== undefined) preserved.continuation = state.continuation
     writeSessionState(sessionId, env, preserved)
     notes.push(
       state.accepted !== undefined
@@ -2738,13 +3125,23 @@ export function handleSessionEnd(
 // ---------------------------------------------------------------------------
 
 /**
- * More pending questions than this means an agent is looping, not asking.
- * Related questions belong in one `ask --form` (the wire carries up to four
- * questions per notification); four separate pushes is already a lot of lock
- * screen.
+ * Registrations still waiting for their first push. More than this in one turn
+ * means an agent is looping, not asking, and related questions belong in one
+ * `ask --form` instead.
+ *
+ * Deliberately counts only unasked entries. A question already on the user's
+ * devices is waiting on a person, not on the agent, and an answer stays
+ * accepted for a day — so counting live questions here would have turned a
+ * patient user into a reason the agent could no longer ask anything.
  */
 export const MAX_PENDING_QUESTIONS = 4
 
+/**
+ * Everything this session has open at once, asked or not. The lock screen is
+ * the shared resource being protected here, not the agent's turn.
+ */
+export const MAX_LIVE_QUESTIONS = 10
+
 /**
  * A session may hold several registered questions at once: a new `ask` never
  * ends an earlier one. Each reaches the user as its own notification and is
@@ -2763,11 +3160,16 @@ export function registerQuestion(
   question: PendingQuestion,
   now: number = Date.now(),
 ): void {
-  let full = false
+  let full: 'unasked' | 'live' | null = null
   updateSessionState(sessionId, env, (state) => {
     const pending = pendingList(state)
-    if (pending.length >= MAX_PENDING_QUESTIONS) {
-      full = true
+    const unasked = pending.filter((entry) => entry.request_id === undefined)
+    if (unasked.length >= MAX_PENDING_QUESTIONS) {
+      full = 'unasked'
+      return state
+    }
+    if (pending.length >= MAX_LIVE_QUESTIONS) {
+      full = 'live'
       return state
     }
     return {
@@ -2783,12 +3185,18 @@ export function registerQuestion(
       ],
     }
   })
-  if (full) {
+  if (full === 'unasked') {
     throw new Error(
       `${MAX_PENDING_QUESTIONS} questions are already waiting to be asked. ` +
         'Combine related questions into one `notifai ask --form` instead of registering more.',
     )
   }
+  if (full === 'live') {
+    throw new Error(
+      `${MAX_LIVE_QUESTIONS} questions from this session are already open. ` +
+        'Retire the ones you no longer need with `notifai close <request_id>` before asking another.',
+    )
+  }
 }
 
 /** Parses hook JSON from stdin, tolerating an empty or malformed body. */