@raidiant/notifai 10.1.0 → 10.1.1

package/src/commands-core.ts

@@ -14,8 +14,10 @@ import { type HookAdapterTarget } from './hook-adapter.js'
 import { logConfigResolved, logSettingsFrom, nullLogger, type Logger } from './logging.js'
 import type { NativeSkills } from './native-skills.js'
 import type { OrcaSessionTitleLookup } from './orca-session-title.js'
+import type { QuestionSettlementLaunch } from './question-settlement-process.js'
 import { packageVersion } from './release.js'
 import type { Tone } from './ui/theme.js'
+import { cliUpdateRecoveryCommand } from './cli-update-contract.js'
 
 export interface CommandIo {
   out(line: string): void
@@ -80,6 +82,8 @@ export interface CommandDeps {
   /** Test seams for the Codex thread-writer probe and cold resume. */
   codexWake?: CodexWakeAdapters
   codexSourcePid?: number
+  /** Test seam for the detached owner recovered from a pre-Stop User prompt. */
+  spawnQuestionSettlement?: (launch: QuestionSettlementLaunch) => void
   /** Test seam and production adapter for the external native skills installer. */
   nativeSkills?: NativeSkills
   /** Test seam for Orca's exact-worktree task/session title lookup. */
@@ -184,7 +188,13 @@ export function authedClient(deps: CommandDeps, config: CliConfig): { client: Ap
   }
 }
 
-export const UPDATE_CLI_COMMAND = 'npm install -g @raidiant/notifai'
+/**
+ * Resolve a current CLI independently of PATH. A bare `notifai update` would
+ * be captured by the stale winner this action is meant to repair.
+ */
+export function updateCliCommand(_deps: Pick<CommandDeps, 'hookInstallTarget' | 'hookPlatform'>): string {
+  return cliUpdateRecoveryCommand()
+}
 
 /** The one first-run command an unsigned machine is told to run. */
 export const SETUP_COMMAND = 'notifai init'
@@ -202,10 +212,14 @@ function naturalList(values: readonly string[]): string {
   return `${values.slice(0, -1).join(', ')}, and ${values.at(-1)}`
 }
 
-function localRecovery(action: RecoveryAction | null, details: unknown): string | null {
+function localRecovery(
+  deps: Pick<CommandDeps, 'hookInstallTarget' | 'hookPlatform'>,
+  action: RecoveryAction | null,
+  details: unknown,
+): string | null {
   switch (action) {
     case 'update_cli':
-      return `next: ${UPDATE_CLI_COMMAND}`
+      return `next: ${updateCliCommand(deps)}`
     case 'update_companion': {
       const names = affectedDeviceNames(details)
       return names.length > 0
@@ -271,7 +285,7 @@ export function reportError(
     const recovery =
       err.code === 'no_active_devices'
         ? 'next: Run `notifai init` to connect an active Companion App; it will complete machine setup and identify any human-only device step.'
-        : localRecovery(err.recoveryAction, err.details)
+        : localRecovery(deps, err.recoveryAction, err.details)
     if (recovery !== null) deps.io.err(recovery)
     else if (err.recoveryAction === null && err.nextAction) deps.io.err(`next: ${err.nextAction}`)
     if (err.code === 'auth_required' || err.code === 'machine_revoked') return EXIT.auth

package/src/commands-devices.ts

@@ -8,6 +8,11 @@ import {
   resolvedBaseUrl,
   type CommandDeps,
 } from './commands-core.js'
+import {
+  companionPlatformLabel,
+  setupCompanionUrl,
+  type CompanionPlatform,
+} from './setup-destinations.js'
 
 // ---------------------------------------------------------------------------
 // devices / capabilities
@@ -40,15 +45,15 @@ export async function devicesCommand(
         deps.io.out(`No ${platform} devices registered.`)
         return EXIT.ok
       }
-      const supportUrl = supportPageUrl(authed.baseUrl)
+      const setupUrl = setupCompanionUrl(authed.baseUrl)
       let email: string | null = null
       try {
         email = (await authed.client.accessStatus()).email
       } catch {
-        // Best-effort: the empty-state copy still points at /support without it.
+        // Best-effort: the empty-state copy still names the destination.
       }
       deps.io.out(
-        `No devices yet. Install Notifai from ${supportUrl}, ${sameAccountSignInLine(email)}, and allow notifications.`,
+        `No devices yet. Set up a Companion App at ${setupUrl}, ${sameAccountSignInLine(email)}, and allow notifications.`,
       )
       return EXIT.ok
     }
@@ -120,14 +125,6 @@ export async function capabilitiesCommand(
   }
 }
 
-export function supportPageUrl(baseUrl: string): string {
-  const normalized = baseUrl.replace(/\/+$/, '')
-  if (normalized === 'https://api.notifai.sh' || normalized === 'https://notifai.fly.dev') {
-    return 'https://app.notifai.sh/support'
-  }
-  return `${normalized}/support`
-}
-
 /** Same-account line for the device hop; prefers the real email when known. */
 export function sameAccountSignInLine(email: string | null | undefined): string {
   return email
@@ -135,18 +132,28 @@ export function sameAccountSignInLine(email: string | null | undefined): string
     : 'sign in with the same email as this account'
 }
 
+/**
+ * What is actually left to do on the phone.
+ *
+ * Three sub-states, three remedies. "Install the app" is useless advice to
+ * someone who installed it and then declined the permission prompt, and
+ * offering install steps to a registered device says this terminal did not
+ * read the state it just fetched.
+ */
 export function deviceInstallRemedy(options: {
   baseUrl: string
   email: string | null
   devices: readonly RoutableDevice[]
+  platform?: CompanionPlatform
 }): string {
-  const support = supportPageUrl(options.baseUrl)
   const sameEmail = sameAccountSignInLine(options.email)
   if (options.devices.length === 0) {
-    return (
-      `open the Companion App install steps at ${support} on a supported device, ` +
-      `install Notifai, ${sameEmail}, and allow notifications`
-    )
+    const destination = setupCompanionUrl(options.baseUrl, options.platform)
+    const named =
+      options.platform === undefined
+        ? 'the Companion App'
+        : `Notifai on ${companionPlatformLabel(options.platform)}`
+    return `open the steps for ${named} at ${destination}, install it, ${sameEmail}, and allow notifications`
   }
   if (options.devices.some((d) => d.permission_status === 'denied')) {
     return "allow notifications for Notifai in the device's Settings"

package/src/commands-doctor.ts

@@ -11,7 +11,11 @@ import {
   HERMES_QUESTION_ROUTING_UNAVAILABLE,
   isHookInstallableHarness,
 } from './harnesses.js'
-import { inspectHookAdapter } from './hook-adapter.js'
+import {
+  hookAdapterTargetsArtifact,
+  inspectHookAdapter,
+  isNpxAdapterTarget,
+} from './hook-adapter.js'
 import {
   readLiveProjectSessionPointers,
   readProjectSessionPointer,
@@ -49,14 +53,15 @@ import type { MachineCredential } from './credentials.js'
 import {
   EXIT,
   SETUP_COMMAND,
-  UPDATE_CLI_COMMAND,
   diagnoseIgnoredOriginOverride,
   loadLoggedConfig,
   makeClient,
   resolvedBaseUrl,
+  updateCliCommand,
   type CommandDeps,
 } from './commands-core.js'
-import { deviceInstallRemedy, readyCompanionDevices, supportPageUrl } from './commands-devices.js'
+import { deviceInstallRemedy, readyCompanionDevices } from './commands-devices.js'
+import { setupAccessUrl } from './setup-destinations.js'
 import {
   claudeSessionPid,
   resolveActiveHarness,
@@ -69,7 +74,7 @@ import {
   hookActivationAdvice,
   requiredHookEvents,
 } from './commands-hooks.js'
-import { cliBinReadiness } from './cli-bin.js'
+import { cliBinReadiness, inspectCliInstallations } from './cli-bin.js'
 import {
   latestPublishedCliVersion,
   newerPublishedCli,
@@ -96,7 +101,7 @@ import { projectBinding, projectEnabled } from './project-enablement.js'
  * versions and document integers are structured inventory, never routing or a
  * definition of "up to date".
  */
-async function compatibilityCheck(client: ApiClient): Promise<ReadinessState> {
+async function compatibilityCheck(client: ApiClient, deps: CommandDeps): Promise<ReadinessState> {
   try {
     const [compatibility, documents] = await Promise.all([
       client.compatibility(),
@@ -131,7 +136,7 @@ async function compatibilityCheck(client: ApiClient): Promise<ReadinessState> {
         remedy: {
           by: 'user-here',
           summary: 'update Notifai',
-          command: UPDATE_CLI_COMMAND,
+          command: updateCliCommand(deps),
         },
       }
     }
@@ -148,7 +153,7 @@ async function compatibilityCheck(client: ApiClient): Promise<ReadinessState> {
         remedy: {
           by: 'user-here',
           summary: 'update Notifai',
-          command: UPDATE_CLI_COMMAND,
+          command: updateCliCommand(deps),
         },
       }
     }
@@ -322,11 +327,14 @@ async function probeAccount(
   lookupFailed: boolean
   auth: ReadinessState
 }> {
-  const [devicesOutcome, accessOutcome] = await Promise.allSettled([
+  const [devicesOutcome, accessOutcome, requestOutcome] = await Promise.allSettled([
     Promise.resolve().then(() => client.listDevices()),
     Promise.resolve().then(() => client.accessStatus()),
+    Promise.resolve().then(() => client.accessRequest()),
   ])
   const access = accessOutcome.status === 'fulfilled' ? accessOutcome.value : null
+  const pendingRequest =
+    requestOutcome.status === 'fulfilled' ? requestOutcome.value.request : null
   const devices = devicesOutcome.status === 'fulfilled' ? devicesOutcome.value.devices : null
   const email = access?.email ?? null
   const devicesErr = devicesOutcome.status === 'rejected' ? devicesOutcome.reason : null
@@ -336,23 +344,36 @@ async function probeAccount(
   if (noActivePlan) {
     const next =
       (isNoActivePlanError(devicesErr) ? devicesErr.nextAction : null) ??
-      `Open ${supportPageUrl(baseUrl)} to request Alpha access, then retry.`
+      `Open ${setupAccessUrl(baseUrl)} to set up access, then retry.`
+    const who = email ? ` (${email})` : ''
+    // Three values, not two. Someone who asked yesterday is waiting on a person,
+    // not on an action of theirs, and telling them to ask again — every run,
+    // forever — is the only thing this terminal could get wrong about a wait it
+    // cannot shorten.
     return {
       email,
       devices: null,
       lookupFailed: true,
-      auth: {
-        id: 'auth',
-        title: 'Account',
-        status: 'gap',
-        detail: email
-          ? `no active plan or temporary Alpha access (${email})`
-          : 'no active plan or temporary Alpha access',
-        remedy: {
-          by: 'user-elsewhere',
-          summary: next,
-        },
-      },
+      auth:
+        pendingRequest === null
+          ? {
+              id: 'auth',
+              title: 'Account',
+              status: 'gap',
+              detail: `this account does not have access to Notifai yet${who}`,
+              remedy: { by: 'user-elsewhere', summary: next },
+            }
+          : {
+              id: 'auth',
+              title: 'Account',
+              status: 'gap',
+              detail: `access requested on ${pendingRequest.requested_at.slice(0, 10)}${who} — waiting to be granted`,
+              remedy: {
+                by: 'user-elsewhere',
+                summary:
+                  'nothing is needed from you; this resumes on the next run once access is granted',
+              },
+            },
     }
   }
 
@@ -515,7 +536,7 @@ export async function assessReadiness(
       baseUrl,
       `Bearer nfm_${credential.machineId}.${credential.secret}`,
     )
-    states.push(await compatibilityCheck(compatibilityClient))
+    states.push(await compatibilityCheck(compatibilityClient, deps))
   }
 
   let accountEmail: string | null = null
@@ -570,7 +591,7 @@ export async function assessReadiness(
             // dashboard origin — not a placeholder, and not typed by hand.
             detail:
               companionDevices.length === 0
-                ? `no active Companion device registered yet; install Notifai via ${supportPageUrl(baseUrl)}`
+                ? 'no active Companion App registered yet'
                 : `${companionDevices.map((d) => `${d.display_name} (${d.platform}, ${d.permission_status})`).join(', ')} — registered but not able to receive`,
             remedy: {
               by: 'user-elsewhere',
@@ -614,7 +635,7 @@ async function applyRegistryRecommendation(
   contract.remedy = {
     by: 'user-here',
     summary: 'update Notifai',
-    command: UPDATE_CLI_COMMAND,
+    command: updateCliCommand(deps),
   }
 }
 
@@ -745,8 +766,12 @@ export async function doctorCommand(
     if (s.id === 'contract') {
       if (s.status === 'ready' || s.status === 'unknown') continue
       deps.io.out(s.detail)
-      if (s.remedy?.by !== 'user-elsewhere' && s.remedy?.command === UPDATE_CLI_COMMAND) {
-        deps.io.out(UPDATE_CLI_COMMAND)
+      if (
+        s.remedy?.by !== 'user-elsewhere' &&
+        s.remedy?.summary === 'update Notifai' &&
+        s.remedy.command !== undefined
+      ) {
+        deps.io.out(s.remedy.command)
       }
       continue
     }
@@ -815,14 +840,15 @@ export function remedyLine(state: ReadinessState): string {
  * way and is not worth re-deriving. The judgment added here is which failures
  * actually stand in the way.
  *
- * Not everything failed is in the way. A pointer that has never been
- * published is the normal condition of an install thirty seconds old — the
- * next prompt fixes it and no command can. Treating that as blocking would
- * mean `init` could only finish after a session had already run — so it
- * reports as something worth knowing rather than something to
- * fix, and `init` walks on to the states it can actually close, delivery
- * proof included. Which failures are informational, and what the true remedy
- * is, is each check's own call (`HookCheck`).
+ * `doctor` is a report and keeps its strict verdict here: a Codex Stop handler
+ * that would swallow an answer is a real failure and reads as one. `init` is
+ * the other consumer, and it treats every state in this group as a report line
+ * rather than a blocker — Question Routing is optional automation, and nothing
+ * optional may stand between a send-capable setup and its delivery proof.
+ *
+ * `reportOnly` marks the checks that no command can close, only the passage of
+ * a turn. Those are report lines even in `doctor`, because "look again" is not
+ * a remedy.
  */
 function hookStates(deps: CommandDeps): ReadinessState[] {
   const installations = findInstallations(deps.cwd, deps.env, deps.hookAdapterHome, deps.hookPlatform)
@@ -924,23 +950,21 @@ function checkTitle(name: string): string {
   return CHECK_TITLES[name] ?? name
 }
 
-  /** Real but not in the way; see the note above. */
-  const informational = new Set<string>()
   return [
     ...hookChecks(deps).map((check) => ({
       id: check.name.replace(/[ ()]+/g, '-').replace(/-$/, ''),
       title: checkTitle(check.name),
       status: check.ok
-        ? 'ready' as const
-        : check.informational === true || informational.has(check.name)
-          ? 'optional-gap' as const
-          : 'gap' as const,
+        ? ('ready' as const)
+        : check.reportOnly === true
+          ? ('optional-gap' as const)
+          : ('gap' as const),
       detail: check.detail,
+      ...(check.technical === undefined ? {} : { technical: check.technical }),
       ...(check.ok
         ? {}
         : {
             remedy: {
-              by: 'user-here' as const,
               // The check's own remedy when it has one; the generic reinstall
               // line was wrong exactly where it mattered (an unfired pointer
               // needs a prompt, not `hooks install`).
@@ -948,6 +972,7 @@ function checkTitle(name: string): string {
                 summary: 'the detail above names what to change',
                 command: 'notifai hooks install',
               }),
+              by: check.remedy?.by ?? ('user-here' as const),
             },
           }),
     })),
@@ -957,13 +982,15 @@ function checkTitle(name: string): string {
 
 
 interface HookCheck {
+  /** No command closes this; only a turn that has not happened yet. */
+  reportOnly?: boolean
   name: string
   ok: boolean
   detail: string
-  /** Real but not in the way: worth a line, never a blocker. */
-  informational?: boolean
+  technical?: unknown
   /** A remedy truer than the generic `notifai hooks install`. */
   remedy?: {
+    by?: 'cli' | 'user-here'
     summary: string
     command: string
     user_action?: { code: string; harness: string; action: string; message: string }
@@ -998,7 +1025,7 @@ function hookChecks(deps: CommandDeps): HookCheck[] {
     checks.push({
       name: 'hooks (detected)',
       ok: false,
-      informational: true,
+      reportOnly: true,
       detail: `${unwired.map((harness) => HARNESS_LABELS[harness]).join(', ')} detected on this machine but not wired`,
       remedy: {
         summary: 'install hooks for every detected harness',
@@ -1020,14 +1047,14 @@ function hookChecks(deps: CommandDeps): HookCheck[] {
     checks.push({
       name: 'hooks (active harness)',
       ok: false,
-      informational: true,
+      reportOnly: true,
       detail: `Several harness sessions could own this shell (${contested.map((candidate) => candidate.label).join(', ')}); routing readiness is intentionally not attributed to either one`,
     })
   } else if (active !== null && !isHookInstallableHarness(active.harness)) {
     checks.push({
       name: 'hooks (active harness)',
       ok: true,
-      informational: true,
+      reportOnly: true,
       detail: `${active.label}: ${HERMES_QUESTION_ROUTING_UNAVAILABLE.deliveryContract}`,
     })
   } else if (active !== null) {
@@ -1060,7 +1087,7 @@ function hookChecks(deps: CommandDeps): HookCheck[] {
         checks.push({
           name: 'hooks (active session)',
           ok: false,
-          informational: true,
+          reportOnly: true,
           detail: `active ${active.label} session has not published exact lifecycle state — send one ${active.label} prompt, then check again`,
           remedy: {
             summary: `send one ${active.label} prompt — its hook publishes the routing pointer`,
@@ -1113,14 +1140,47 @@ function hookChecks(deps: CommandDeps): HookCheck[] {
   )
   const sharedAdapter = inspectHookAdapter(deps.hookAdapterHome, deps.hookPlatform)
   adapterProblems.push(...sharedAdapter.problems)
+  const runningTarget = deps.hookInstallTarget
+  const runningArtifact =
+    runningTarget !== undefined && !isNpxAdapterTarget(runningTarget)
+      ? runningTarget.scriptPath
+      : process.argv[1]
+  const cliInstallations = inspectCliInstallations(
+    deps.env,
+    deps.hookPlatform ?? process.platform,
+    {
+      ...(runningArtifact === undefined ? {} : { runningArtifactPath: runningArtifact }),
+      currentVersion: packageVersion(),
+    },
+  )
+  const effectiveArtifact = cliInstallations.effective?.artifact_path ?? null
+  const adapterMismatch =
+    sharedAdapter.problems.length === 0 &&
+    effectiveArtifact !== null &&
+    !hookAdapterTargetsArtifact(sharedAdapter.target, effectiveArtifact)
+  if (adapterMismatch) {
+    adapterProblems.push('the registered CLI does not match the effective notifai command')
+  }
   if (adapterProblems.length > 0) {
     checks.push({
       name: 'hooks (adapter)',
       ok: false,
       // A machine-global install for a harness that is not active in this
-      // project is useful diagnosis, but it must not block unrelated init.
-      informational: active === null && installations.every((installation) => installation.global),
+      // project is useful diagnosis, but it is not this project's failure.
+      reportOnly: active === null && installations.every((installation) => installation.global),
       detail: adapterProblems.join('; '),
+      ...(adapterMismatch
+        ? { technical: { effective_cli_artifact: effectiveArtifact, registered_target: sharedAdapter.target } }
+        : {}),
+      ...(adapterMismatch && adapterProblems.length === 1
+        ? {
+            remedy: {
+              by: 'cli' as const,
+              summary: 'retarget Question Routing to the effective notifai command',
+              command: 'notifai init',
+            },
+          }
+        : {}),
     })
   }
 
@@ -1276,9 +1336,10 @@ function hookChecks(deps: CommandDeps): HookCheck[] {
   checks.push({
     name: 'hooks (fired)',
     ok: fired,
-    // A wholly fresh install is informational. Once UserPromptSubmit has fired,
-    // a missing Stop is a broken route, not missing historical evidence.
-    informational: firedPointer === null,
+    // Nothing here is a command. Whether the pointer is absent or the turn is
+    // half-finished, the only thing that closes this is a turn ending — which
+    // an agent running `init` inside that very turn cannot supply.
+    reportOnly: true,
     detail: fired
       ? active === null
         ? 'a session in this directory has run UserPromptSubmit and Stop'
@@ -1319,7 +1380,7 @@ function hookChecks(deps: CommandDeps): HookCheck[] {
       continuationHarnesses.every(
         (harness) => HARNESS_CAPABILITIES[harness].stopContinuation !== 'unsupported',
       ),
-    informational: active === null,
+    reportOnly: active === null,
     detail:
       continuationHarnesses.length === 0
         ? active === null
@@ -1376,7 +1437,7 @@ function wakeRouteCheck(
     return {
       name: 'hooks (wake route)',
       ok: readiness.state === 'ready',
-      informational: true,
+      reportOnly: true,
       detail:
         readiness.state === 'ready'
           ? `this Claude Code ${readiness.version} session is listening on ${readiness.socketPath}, so an answer can start a turn here without you`
@@ -1391,7 +1452,7 @@ function wakeRouteCheck(
     return {
       name: 'hooks (wake route)',
       ok: readiness.state === 'ready',
-      informational: true,
+      reportOnly: true,
       detail:
         readiness.state === 'ready'
           ? `the held Codex turn continues from its own hook, and after it returns ${readiness.lockDirectory} can prove a stopped thread unowned before resuming it`

package/src/commands-hooks.ts

@@ -55,6 +55,7 @@ import {
   withdrawUnpushedQuestions,
   type EscalationDeliveryRoute,
   type HookContext,
+  type HookOutcome,
   type HookHarness,
   type PendingQuestion,
 } from './hooks.js'
@@ -102,6 +103,7 @@ import {
   removeOpenclawNotifaiEntry,
 } from './openclaw-plugin.js'
 import { packageVersion } from './release.js'
+import { spawnQuestionSettlement } from './question-settlement-process.js'
 import { enableProject, projectBinding, projectEnabled } from './project-enablement.js'
 import { rejectAccidentalEscapedNewlines } from './send.js'
 import {
@@ -156,6 +158,7 @@ export const HOOK_EVENTS = [
   'session-end',
 ] as const
 export type HookEvent = (typeof HOOK_EVENTS)[number]
+const INTERNAL_HOOK_EVENTS = ['question-settlement'] as const
 
 /** Lifecycle handlers one installed harness must carry in this CLI build. */
 export function requiredHookEvents(harness: HookInstallableHarness): readonly HookEvent[] {
@@ -187,7 +190,10 @@ export async function hookRunCommand(
   readStdin: () => Promise<string>,
   harness?: HookHarness,
 ): Promise<number> {
-  if (!(HOOK_EVENTS as readonly string[]).includes(event)) {
+  if (
+    !(HOOK_EVENTS as readonly string[]).includes(event) &&
+    !(INTERNAL_HOOK_EVENTS as readonly string[]).includes(event)
+  ) {
     deps.io.err(`Unknown hook event "${event}". Valid: ${HOOK_EVENTS.join(', ')}`)
     return EXIT.usage
   }
@@ -501,7 +507,9 @@ export async function hookRunCommand(
       `Bearer nfm_${credential.machineId}.${credential.secret}`,
       {
         timeoutMs: event === 'user-prompt-submit' ? 4_000 : 20_000,
-        ...(event === 'stop' ? { deadlineAt: processDeadlineAt, now } : {}),
+        ...(event === 'stop' || event === 'question-settlement'
+          ? { deadlineAt: processDeadlineAt, now }
+          : {}),
       },
     )
     const ctx: HookContext = {
@@ -533,17 +541,49 @@ export async function hookRunCommand(
     // Daily state pruning is housekeeping, not part of the Stop delivery
     // contract. Its directory scan has no useful bound, so keep it on the
     // short prompt path and never spend the answer owner's finite budget on it.
-    if (event !== 'stop') pruneAbandonedSessions(deps.env)
-
-    const outcome =
-      event === 'user-prompt-submit'
-        ? await handleUserPromptSubmit(ctx, envelope)
-        : await handleStop(
-            ctx,
-            envelope,
-            processDeadlineAt,
-            stopWakeRoute(deps, harness, envelope.session_id, cwd),
-          )
+    if (event !== 'stop' && event !== 'question-settlement') {
+      pruneAbandonedSessions(deps.env)
+    }
+
+    let outcome: HookOutcome
+    if (event === 'user-prompt-submit') {
+      outcome = await handleUserPromptSubmit(ctx, envelope)
+      if (
+        outcome.settlementRequired === true &&
+        envelope.session_id !== undefined &&
+        harness !== undefined &&
+        questionRoutingCapability(harness).stopContinuation !== 'unsupported'
+      ) {
+        try {
+          const launchSettlement = deps.spawnQuestionSettlement ?? spawnQuestionSettlement
+          launchSettlement({
+            envelope: { session_id: envelope.session_id, cwd },
+            harness,
+          })
+          outcome.log = { ...outcome.log, settlement: 'launched' }
+        } catch (err) {
+          outcome.log = {
+            ...outcome.log,
+            settlement: 'launch-failed',
+            settlement_error: failureData(err),
+          }
+        }
+      }
+    } else {
+      outcome = await handleStop(
+        ctx,
+        envelope,
+        processDeadlineAt,
+        stopWakeRoute(
+          deps,
+          harness,
+          envelope.session_id,
+          cwd,
+          event === 'stop',
+        ),
+        event === 'stop',
+      )
+    }
     // Answer diagnostics are already persisted once as hook.answer. Keep every
     // other note in the lifecycle record without duplicating the user's text.
     const notes = outcome.notes.filter((note) => !/^(?:late )?answer from /.test(note))
@@ -595,6 +635,7 @@ function stopWakeRoute(
   harness: HookInstallableHarness | undefined,
   sessionId: string | undefined,
   cwd: string,
+  continuationActive = true,
 ): EscalationDeliveryRoute | undefined {
   if (sessionId === undefined) return undefined
   const declaredSourcePid = declaredHookSourcePid(deps)
@@ -614,6 +655,7 @@ function stopWakeRoute(
       sourcePid: deps.codexSourcePid ?? declaredSourcePid ?? process.ppid,
       env: deps.env,
       ...(deps.codexWake === undefined ? {} : { adapters: deps.codexWake }),
+      continuationActive,
     })
   }
   return undefined
@@ -942,12 +984,17 @@ function recordRegisteredQuestion(
         {
           registered: true,
           question_id: questionId,
+          state: 'local',
+          submitted: false,
+          request_id: null,
+          provider_acceptance: 'not_available',
           questions: built.questions.map((entry) => ({
             id: entry.id,
             text: entry.text,
             ...(entry.choices === undefined ? {} : { choices: entry.choices }),
             ...(entry.multi === true ? { multi: true } : {}),
           })),
+          status: `notifai status ${questionId}`,
           close: `notifai close ${questionId}`,
           next: {
             end_turn: true,
@@ -977,8 +1024,11 @@ function recordRegisteredQuestion(
   }
   deps.io.out(
     built.questions.length > 1
-      ? `${built.questions.length} questions registered as one form (${questionId}). Ask them in the conversation, state the concrete work you will resume for their answers, then end your turn.`
-      : `Question registered (${questionId}). Ask it in the conversation, state the concrete work you will resume when the answer arrives, then end your turn.`,
+      ? `${built.questions.length} questions registered locally as one form (${questionId}); they have not been submitted as a Notification Request and have no Provider Acceptance yet. Ask them in the conversation, state the concrete work you will resume for their answers, then end your turn.`
+      : `Question registered locally (${questionId}); it has not been submitted as a Notification Request and has no Provider Acceptance yet. Ask it in the conversation, state the concrete work you will resume when the answer arrives, then end your turn.`,
+  )
+  deps.io.out(
+    `Question settlement runs after registration. Inspect the original identity with \`notifai status ${questionId}\`; never register a replacement to check whether this one was sent.`,
   )
   deps.io.out('Before ending this turn, pre-commit in your own words to the work you will resume:')
   for (const [index, entry] of built.questions.entries()) {
@@ -1593,7 +1643,7 @@ async function closeLocalQuestion(
   if (entry === undefined) return null
 
   if (entry.request_id === undefined) {
-    dropPendingQuestion(sessionId, deps.env, entry)
+    dropPendingQuestion(sessionId, deps.env, entry, 'withdrawn')
     const output = {
       session_id: sessionId,
       withdrawn: [