@raidiant/notifai 0.3.0 → 0.5.0

package/src/commands.test.ts

@@ -1,6 +1,7 @@
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, symlinkSync, writeFileSync } from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
+import { fileURLToPath } from 'node:url'
 import type {
   CapabilityDocument,
   EvidenceSnapshot,
@@ -11,6 +12,7 @@ import type {
 } from '@raidiant/notifai-protocol'
 import { describe, expect, it } from 'vitest'
 import { ApiCallError, NetworkError, type ApiClient } from './client.js'
+import type { ClaudeWakeAdapters } from './claude-wake.js'
 import {
   askCommand,
   accessStatusCommand,
@@ -20,6 +22,7 @@ import {
   configExplainCommand,
   configSetCommand,
   configShowCommand,
+  configUnsetCommand,
   contradictingAnswer,
   describeHookFailure,
   doctorCommand,
@@ -29,6 +32,8 @@ import {
   initCommand,
   SKILLS_SOURCE,
   loginCommand,
+  logsCommand,
+  parseSince,
   projectSlugFrom,
   repliesCommand,
   sendCommand,
@@ -37,10 +42,18 @@ import {
   type CommandIo,
   type CommandSpinner,
 } from './commands.js'
-import { applyPlan, buildHookConfig } from './install-hooks.js'
+import {
+  applyPlan,
+  buildHookConfig,
+  codexHookIdentityHash,
+  codexTrustKey,
+  findInstallations,
+} from './install-hooks.js'
 import { readSessionState, writeProjectSession, writeSessionState } from './hooks.js'
 import type { NativeSkill, NativeSkills, SkillScope } from './native-skills.js'
-import { CONFIG_KEYS } from './config.js'
+import { CONFIG_KEYS, loadConfig } from './config.js'
+import { createLogger, logsDiskUsage, readLogRecords } from './logging.js'
+import { hookAdapterPath, inspectHookAdapter } from './hook-adapter.js'
 import type { Tone } from './ui/theme.js'
 
 class CapturedIo implements CommandIo {
@@ -120,7 +133,23 @@ class InteractiveIo extends CapturedIo {
   }
 }
 
+function trustInstalledCodexHooks(cwd: string, env: NodeJS.ProcessEnv): void {
+  const installations = findInstallations(cwd, env).filter(
+    (installation) => installation.harness === 'codex',
+  )
+  const sections = installations.flatMap((installation) =>
+    installation.handlers.map((handler) => {
+      const key = codexTrustKey(installation, handler)
+      return `[hooks.state.${JSON.stringify(key)}]\ntrusted_hash = ${JSON.stringify(codexHookIdentityHash(handler))}\n`
+    }),
+  )
+  const codexHome = env['CODEX_HOME'] as string
+  mkdirSync(codexHome, { recursive: true })
+  writeFileSync(path.join(codexHome, 'config.toml'), sections.join('\n'))
+}
+
 function makeDeps(io: CapturedIo, client: ApiClient): CommandDeps {
+  const testRoot = path.join(os.tmpdir(), 'notifai-cli-command-tests')
   return {
     io,
     store: {
@@ -134,12 +163,36 @@ function makeDeps(io: CapturedIo, client: ApiClient): CommandDeps {
       clear: () => {},
       describe: () => 'test credential store',
     },
-    env: { XDG_CONFIG_HOME: path.join(os.tmpdir(), 'notifai-cli-command-tests') },
+    env: {
+      XDG_CONFIG_HOME: testRoot,
+      XDG_STATE_HOME: path.join(os.tmpdir(), 'notifai-cli-command-tests-state'),
+    },
+    hookAdapterHome: path.join(testRoot, 'home'),
     cwd: os.tmpdir(),
     clientFactory: () => client,
   }
 }
 
+/**
+ * An environment that cannot see the machine running the suite.
+ *
+ * Harness discovery walks the real home directory whenever the environment
+ * names no override, so a developer with Notifai's own global hooks installed
+ * was silently running these cases against their own settings file — and a
+ * check that failed on that file failed only for them. Every setup case that
+ * asserts on readiness therefore gets its own home.
+ */
+function isolatedEnv(cwd: string): NodeJS.ProcessEnv {
+  const home = path.join(cwd, 'home')
+  return {
+    HOME: home,
+    CLAUDE_CONFIG_DIR: path.join(home, '.claude'),
+    CODEX_HOME: path.join(home, '.codex'),
+    XDG_CONFIG_HOME: path.join(cwd, 'config'),
+    XDG_STATE_HOME: path.join(cwd, 'state'),
+  }
+}
+
 const receipt: SubmissionReceipt = {
   request_id: 'req_reply_test',
   replayed: false,
@@ -494,13 +547,19 @@ describe('command contracts', () => {
         return replyResponse(polls.length === 3 ? [reply] : [])
       },
     } as unknown as ApiClient
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-direct-reply-log-'))
     const deps = {
       ...makeDeps(io, client),
+      env: {
+        XDG_CONFIG_HOME: path.join(root, 'config'),
+        XDG_STATE_HOME: path.join(root, 'state'),
+      },
       now: () => now,
       sleep: async (milliseconds: number) => {
         now += milliseconds
       },
     }
+    deps.logger = createLogger({ env: deps.env, cmd: 'send' })
 
     expect(
       await sendCommand(deps, {
@@ -513,6 +572,14 @@ describe('command contracts', () => {
     expect(polls).toHaveLength(3)
     expect(polls.every((poll) => poll.waitSeconds <= 25)).toBe(true)
     expect(io.outLines.at(-1)).toBe('reply from iPhone: yes, after the migration')
+    const received = readLogRecords(deps.env, { event: ['reply.received'] }).records
+    expect(received).toHaveLength(1)
+    expect(received[0]?.data).toMatchObject({
+      request_id: receipt.request_id,
+      sequence: reply.seq,
+      device: reply.device_name,
+      text: reply.text,
+    })
   })
 
   it('backs off and retries a transient network error while waiting', async () => {
@@ -549,6 +616,97 @@ describe('command contracts', () => {
     expect(sleeps).toEqual([250])
   })
 
+  /**
+   * Regression context: Provider Acceptance and Companion Receipt succeeded,
+   * then a long-poll returned HTTP 500 internal_error and the blocking wait aborted
+   * while the reply window was still open. The answer arrived ~1 minute later
+   * and was recovered only on the next turn. Transient server faults must not
+   * end the wait; permanent client errors still may.
+   */
+  it('keeps blocking through a transient internal_error on the replies poll', async () => {
+    const io = new CapturedIo()
+    let now = 0
+    let replyCalls = 0
+    const client = {
+      submit: async () => receipt,
+      replies: async () => {
+        replyCalls += 1
+        if (replyCalls <= 2) {
+          throw new ApiCallError(500, 'internal_error', 'An unexpected server error occurred.')
+        }
+        return replyResponse([reply])
+      },
+    } as unknown as ApiClient
+    const deps = {
+      ...makeDeps(io, client),
+      now: () => now,
+      sleep: async (milliseconds: number) => {
+        now += milliseconds
+      },
+    }
+
+    expect(
+      await sendCommand(deps, {
+        title: 'Question',
+        body: 'Deploy?',
+        reply: true,
+        replyTimeout: 30,
+      }),
+    ).toBe(EXIT.ok)
+    expect(replyCalls).toBe(3)
+    expect(io.outLines.at(-1)).toBe('reply from iPhone: yes, after the migration')
+    expect(io.errLines.join('\n')).not.toContain('internal_error')
+  })
+
+  it('does not treat a permanent replies error as a transient wait fault', async () => {
+    const io = new CapturedIo()
+    let now = 0
+    let replyCalls = 0
+    const client = {
+      submit: async () => receipt,
+      replies: async () => {
+        replyCalls += 1
+        throw new ApiCallError(404, 'not_found', 'No such request.')
+      },
+    } as unknown as ApiClient
+    const deps: CommandDeps = {
+      ...makeDeps(io, client),
+      now: () => now,
+      sleep: async (milliseconds: number) => {
+        now += milliseconds
+      },
+    }
+    deps.env = {
+      ...deps.env,
+      XDG_STATE_HOME: mkdtempSync(path.join(os.tmpdir(), 'notifai-reply-wait-log-')),
+    }
+    deps.logger = createLogger({ env: deps.env, cmd: 'send' })
+
+    expect(
+      await sendCommand(deps, {
+        title: 'Question',
+        body: 'Deploy?',
+        reply: true,
+        replyTimeout: 30,
+      }),
+    ).toBe(EXIT.failed)
+    expect(replyCalls).toBe(1)
+    expect(io.errLines.join('\n')).toContain('reply wait failed')
+    expect(io.errLines.join('\n')).toContain(receipt.request_id)
+    expect(io.errLines.join('\n')).toContain('not_found')
+    // Receipt was already printed — the durable send is not the failure.
+    expect(io.outLines[0]).toContain(receipt.request_id)
+    const waitError = readLogRecords(deps.env, { event: ['cli.error'], limit: 20 }).records.find(
+      (record) => record.data?.['operation'] === 'reply_wait',
+    )
+    expect(waitError?.data).toMatchObject({
+      kind: 'api',
+      request_id: receipt.request_id,
+      status: 404,
+      code: 'not_found',
+    })
+  })
+
   it('prints an NDJSON receipt before waiting and a result record on exit 3', async () => {
     const io = new CapturedIo()
     let now = 0
@@ -619,10 +777,18 @@ describe('command contracts', () => {
         return replyResponse([reply])
       },
     } as unknown as ApiClient
+    const deps = makeDeps(io, client)
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-replies-log-'))
+    deps.env = {
+      XDG_CONFIG_HOME: path.join(root, 'config'),
+      XDG_STATE_HOME: path.join(root, 'state'),
+    }
+    deps.logger = createLogger({ env: deps.env, cmd: 'replies' })
 
-    expect(await repliesCommand(makeDeps(io, client), receipt.request_id, { after: 7 })).toBe(EXIT.ok)
+    expect(await repliesCommand(deps, receipt.request_id, { after: 7 })).toBe(EXIT.ok)
     expect(requested).toEqual({ waitSeconds: 0, afterSeq: 7 })
     expect(io.outLines).toEqual(['reply from iPhone: yes, after the migration'])
+    expect(readLogRecords(deps.env, { event: ['reply.received'] }).records).toHaveLength(1)
   })
 
   it('resolves replies --pending through the project session pointer and prints its id', async () => {
@@ -678,6 +844,198 @@ describe('command contracts', () => {
     expect(io.outLines[1]).toContain('yes, after the migration')
     expect(io.outLines.join('\n')).toContain('req_second')
   })
+
+  it('keeps the failing request identity when one pending reply wait throws', async () => {
+    const io = new CapturedIo()
+    const client = {
+      replies: async (requestId: string) => {
+        if (requestId === 'req_failed') {
+          throw new ApiCallError(404, 'not_found', 'That notification request does not exist.')
+        }
+        return replyResponse([reply])
+      },
+    } as unknown as ApiClient
+    const deps = makeDeps(io, client)
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-pending-error-log-'))
+    deps.cwd = root
+    deps.env = {
+      XDG_CONFIG_HOME: path.join(root, 'config'),
+      XDG_STATE_HOME: path.join(root, 'state'),
+    }
+    deps.logger = createLogger({ env: deps.env, cmd: 'replies' })
+    writeSessionState('pending-error-log', deps.env, {
+      pending: [
+        { question: 'First?', request_id: 'req_healthy' },
+        { question: 'Second?', request_id: 'req_failed' },
+        { question: 'Third?', request_id: 'req_unreached' },
+      ],
+    })
+    writeProjectSession(root, deps.env, 'pending-error-log', Date.now(), 'codex')
+
+    expect(await repliesCommand(deps, undefined, { pending: true })).toBe(EXIT.failed)
+
+    io.outLines = []
+    io.errLines = []
+    expect(logsCommand(deps, { request: 'req_failed', json: true, allProjects: true })).toBe(
+      EXIT.ok,
+    )
+    expect(io.outLines).toHaveLength(1)
+    expect(JSON.parse(io.outLines[0]!)).toMatchObject({
+      event: 'cli.error',
+      data: { request_id: 'req_failed', operation: 'reply_wait' },
+    })
+
+    io.outLines = []
+    expect(logsCommand(deps, { request: 'req_healthy', json: true, allProjects: true })).toBe(
+      EXIT.ok,
+    )
+    expect(io.outLines).toHaveLength(1)
+    expect(JSON.parse(io.outLines[0]!)).toMatchObject({
+      event: 'reply.received',
+      data: { request_id: 'req_healthy' },
+    })
+
+    io.outLines = []
+    expect(logsCommand(deps, { request: 'req_unreached', json: true, allProjects: true })).toBe(
+      EXIT.ok,
+    )
+    expect(io.outLines).toEqual([])
+  })
+
+  it('attributes a degraded multi-request wait only to the request whose polls failed', async () => {
+    const io = new CapturedIo()
+    let now = 0
+    let failedPolls = 0
+    const client = {
+      replies: async (requestId: string) => {
+        if (requestId !== 'req_degraded') return replyResponse([reply])
+        failedPolls += 1
+        if (failedPolls === 1) return replyResponse([])
+        throw new NetworkError('temporary disconnect')
+      },
+    } as unknown as ApiClient
+    const deps = makeDeps(io, client)
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-pending-degraded-log-'))
+    deps.cwd = root
+    deps.env = {
+      XDG_CONFIG_HOME: path.join(root, 'config'),
+      XDG_STATE_HOME: path.join(root, 'state'),
+    }
+    deps.now = () => now
+    deps.sleep = async (milliseconds: number) => {
+      now += milliseconds
+    }
+    deps.logger = createLogger({ env: deps.env, cmd: 'replies' })
+    writeSessionState('pending-degraded-log', deps.env, {
+      pending: [
+        { question: 'First?', request_id: 'req_healthy_before' },
+        { question: 'Second?', request_id: 'req_degraded' },
+        { question: 'Third?', request_id: 'req_healthy_after' },
+      ],
+    })
+    writeProjectSession(root, deps.env, 'pending-degraded-log', Date.now(), 'codex')
+
+    expect(await repliesCommand(deps, undefined, { pending: true, wait: 1 })).toBe(EXIT.network)
+
+    io.outLines = []
+    io.errLines = []
+    expect(logsCommand(deps, { request: 'req_degraded', json: true, allProjects: true })).toBe(
+      EXIT.ok,
+    )
+    expect(io.outLines).toHaveLength(1)
+    expect(JSON.parse(io.outLines[0]!)).toMatchObject({
+      event: 'cli.error',
+      data: { request_ids: ['req_degraded'], operation: 'reply_wait' },
+    })
+
+    for (const requestId of ['req_healthy_before', 'req_healthy_after']) {
+      io.outLines = []
+      expect(logsCommand(deps, { request: requestId, json: true, allProjects: true })).toBe(
+        EXIT.ok,
+      )
+      expect(io.outLines).toHaveLength(1)
+      expect(JSON.parse(io.outLines[0]!)).toMatchObject({
+        event: 'reply.received',
+        data: { request_id: requestId },
+      })
+    }
+  })
+
+  it('records earlier degraded requests before a later pending wait throws', async () => {
+    const io = new CapturedIo()
+    let now = 0
+    let degradedPolls = 0
+    const client = {
+      replies: async (requestId: string) => {
+        if (requestId === 'req_success') return replyResponse([reply])
+        if (requestId === 'req_degraded') {
+          degradedPolls += 1
+          if (degradedPolls === 1) return replyResponse([])
+          throw new NetworkError('temporary disconnect')
+        }
+        if (requestId === 'req_failed') {
+          throw new ApiCallError(404, 'not_found', 'That notification request does not exist.')
+        }
+        return replyResponse([reply])
+      },
+    } as unknown as ApiClient
+    const deps = makeDeps(io, client)
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-pending-mixed-log-'))
+    deps.cwd = root
+    deps.env = {
+      XDG_CONFIG_HOME: path.join(root, 'config'),
+      XDG_STATE_HOME: path.join(root, 'state'),
+    }
+    deps.now = () => now
+    deps.sleep = async (milliseconds: number) => {
+      now += milliseconds
+    }
+    deps.logger = createLogger({ env: deps.env, cmd: 'replies' })
+    writeSessionState('pending-mixed-log', deps.env, {
+      pending: [
+        { question: 'Healthy?', request_id: 'req_success' },
+        { question: 'Degraded?', request_id: 'req_degraded' },
+        { question: 'Gone?', request_id: 'req_failed' },
+        { question: 'Unreached?', request_id: 'req_unreached' },
+      ],
+    })
+    writeProjectSession(root, deps.env, 'pending-mixed-log', Date.now(), 'codex')
+
+    expect(await repliesCommand(deps, undefined, { pending: true, wait: 1 })).toBe(EXIT.failed)
+
+    const recordsFor = (requestId: string): Array<Record<string, unknown>> => {
+      io.outLines = []
+      io.errLines = []
+      expect(logsCommand(deps, { request: requestId, json: true, allProjects: true })).toBe(
+        EXIT.ok,
+      )
+      return io.outLines.map((line) => JSON.parse(line) as Record<string, unknown>)
+    }
+
+    expect(recordsFor('req_success')).toEqual([
+      expect.objectContaining({
+        event: 'reply.received',
+        data: expect.objectContaining({ request_id: 'req_success' }),
+      }),
+    ])
+    expect(recordsFor('req_degraded')).toEqual([
+      expect.objectContaining({
+        event: 'cli.error',
+        data: expect.objectContaining({
+          request_ids: ['req_degraded'],
+          operation: 'reply_wait',
+          degraded: true,
+        }),
+      }),
+    ])
+    expect(recordsFor('req_failed')).toEqual([
+      expect.objectContaining({
+        event: 'cli.error',
+        data: expect.objectContaining({ request_id: 'req_failed', operation: 'reply_wait' }),
+      }),
+    ])
+    expect(recordsFor('req_unreached')).toEqual([])
+  })
 })
 
 describe('delivery evidence status', () => {
@@ -734,6 +1092,8 @@ describe('delivery evidence status', () => {
     expect(said).toContain("Companion Receipt (the app's delivery confirmation): unknown")
     expect(said).toContain('not a failure')
     expect(said).toContain('attempt_started')
+    expect(said).toContain('OS presentation: not observed by Notifai')
+    expect(said).toContain('Reply wait:')
   })
 
   it('reports the observed device receipt and measured provider-to-companion latency', async () => {
@@ -751,12 +1111,40 @@ describe('delivery evidence status', () => {
     const said = io.outLines.join('\n')
     expect(said).toContain("Companion Receipt (the app's delivery confirmation): observed")
     expect(said).toContain('11m 27s after Provider Acceptance')
+    expect(said).toContain('OS presentation: not observed by Notifai')
+    expect(said).toContain('Reply received: not yet recorded')
+    expect(said).toContain('Reply wait: no answer stored yet')
+  })
+
+  it('separates a stored reply from Delivery so a wait fault is not misread as non-delivery', async () => {
+    const io = new CapturedIo()
+    const base = snapshot({
+      state: 'observed',
+      observed_at: '2026-08-05T13:17:17.000Z',
+      latency_ms: 1_000,
+    })
+    base.deliveries[0]!.events.push({
+      stage: 'reply_received',
+      source: 'companion',
+      reason: null,
+      attempt: null,
+      occurred_at: '2026-08-05T13:18:00.000Z',
+    })
+    const client = { evidence: async () => base } as unknown as ApiClient
+
+    expect(await statusCommand(makeDeps(io, client), 'req_status_test', {})).toBe(EXIT.ok)
+    const said = io.outLines.join('\n')
+    expect(said).toContain('Provider Acceptance: accepted')
+    expect(said).toContain('Companion Receipt')
+    expect(said).toContain('OS presentation: not observed by Notifai')
+    expect(said).toContain('Reply received: yes')
+    expect(said).toContain('answers are on the server')
   })
 })
 
 describe('Cursor hook commands', () => {
-  const execPath = '/usr/local/bin/node'
-  const scriptPath = '/opt/notifai/dist/main.js'
+  const execPath = process.execPath
+  const scriptPath = fileURLToPath(import.meta.url)
 
   it('installs native Cursor hooks with bounded chained answer continuations', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-cursor-install-'))
@@ -850,8 +1238,8 @@ describe('Cursor hook commands', () => {
 })
 
 describe('harness activation guidance', () => {
-  const execPath = '/usr/local/bin/node'
-  const scriptPath = '/opt/notifai/dist/main.js'
+  const execPath = process.execPath
+  const scriptPath = fileURLToPath(import.meta.url)
 
   it('does not require a Claude Code restart for project hook files', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-claude-activation-'))
@@ -881,7 +1269,7 @@ describe('harness activation guidance', () => {
     expect(output).not.toMatch(/trust|approve/i)
   })
 
-  it('keeps OpenCode permission prompts local and reports its continuation limit', async () => {
+  it('keeps OpenCode permission prompts local and reports unsupported continuation', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-opencode-activation-'))
     const io = new CapturedIo()
     const client = {
@@ -889,21 +1277,33 @@ describe('harness activation guidance', () => {
       capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
       listDevices: async () => ({ devices: [] }),
     } as unknown as ApiClient
-    const deps = { ...makeDeps(io, client), cwd }
+    const base = makeDeps(io, client)
+    const deps = {
+      ...base,
+      cwd,
+      env: {
+        ...base.env,
+        HOME: path.join(cwd, 'home'),
+        CODEX_HOME: path.join(cwd, 'codex-home'),
+        CLAUDE_CONFIG_DIR: path.join(cwd, 'claude-home'),
+        OPENCODE_CONFIG_DIR: path.join(cwd, 'opencode-home'),
+      },
+    }
 
     expect(hooksInstallCommand(deps, { harness: 'opencode', execPath, scriptPath })).toBe(
       EXIT.ok,
     )
 
     expect(io.outLines.join('\n')).toContain('Permission prompts stay in OpenCode.')
-    expect(io.outLines.join('\n')).toContain('next user prompt')
+    expect(io.outLines.join('\n')).toContain('does not expose a proven exactly-once continuation')
     const pluginFile = path.join(cwd, '.opencode', 'plugins', 'notifai.js')
     const plugin = readFileSync(pluginFile, 'utf8')
     expect(plugin).toContain('const TIMEOUT_MS = 540000')
 
     io.outLines = []
     expect(await doctorCommand(deps, {})).toBe(EXIT.failed)
-    expect(io.outLines.join('\n')).toContain('hooks (opencode continuation)')
+    expect(io.outLines.join('\n')).toContain('hooks (answer continuation)')
+    expect(io.outLines.join('\n')).toContain('no proven answer continuation')
     expect(io.outLines.join('\n')).not.toContain('hooks (adapter)')
 
     writeFileSync(pluginFile, plugin.replace(/^const ADAPTER_VERSION = .*\n/m, ''))
@@ -912,6 +1312,107 @@ describe('harness activation guidance', () => {
     expect(io.outLines.join('\n')).toContain('hooks (adapter)')
     expect(io.outLines.join('\n')).toContain('obsolete OpenCode event wiring')
   })
+
+  it('refuses a symlinked OpenCode plugin without touching its target', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-opencode-symlink-'))
+    const plugin = path.join(cwd, '.opencode', 'plugins', 'notifai.js')
+    const target = path.join(cwd, 'foreign.js')
+    mkdirSync(path.dirname(plugin), { recursive: true })
+    writeFileSync(target, '// notifai managed opencode plugin\nleave me\n')
+    symlinkSync(target, plugin)
+    const io = new CapturedIo()
+    const deps = {
+      ...makeDeps(io, {} as ApiClient),
+      cwd,
+      env: { XDG_STATE_HOME: path.join(cwd, 'state') },
+    }
+
+    expect(hooksInstallCommand(deps, { harness: 'opencode', execPath, scriptPath })).toBe(
+      EXIT.failed,
+    )
+    expect(io.errLines.join('\n')).toMatch(/not a regular file/)
+    expect(readFileSync(target, 'utf8')).toBe('// notifai managed opencode plugin\nleave me\n')
+    // Adapter preparation commits first. A definition failure leaves a valid
+    // shared adapter (useful to any existing harness) and never half-writes the
+    // rejected definition.
+    expect(inspectHookAdapter(deps.hookAdapterHome).problems).toEqual([])
+    expect(inspectHookAdapter(deps.hookAdapterHome).target?.scriptPath).toBe(scriptPath)
+  })
+})
+
+describe('stable hook installation', () => {
+  it('keeps definition bytes stable across config, CLI target, and project/global changes', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-stable-hook-install-'))
+    const firstCli = path.join(cwd, 'first cli.js')
+    const secondCli = path.join(cwd, 'second cli.js')
+    writeFileSync(firstCli, '')
+    writeFileSync(secondCli, '')
+    const io = new CapturedIo()
+    const env = {
+      HOME: path.join(cwd, 'home'),
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CLAUDE_CONFIG_DIR: path.join(cwd, 'claude-home'),
+      CODEX_HOME: path.join(cwd, 'codex-home'),
+    }
+    const client = {
+      health: async () => true,
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+      listDevices: async () => ({ devices: [] }),
+    } as unknown as ApiClient
+    const deps = { ...makeDeps(io, client), cwd, env }
+    const local = path.join(cwd, '.claude', 'settings.local.json')
+
+    expect(
+      hooksInstallCommand(deps, {
+        harness: 'claude-code',
+        execPath: process.execPath,
+        scriptPath: firstCli,
+      }),
+    ).toBe(EXIT.ok)
+    const firstDefinition = readFileSync(local, 'utf8')
+    const firstAdapter = readFileSync(hookAdapterPath(deps.hookAdapterHome), 'utf8')
+    mkdirSync(path.join(cwd, '.notifai'), { recursive: true })
+    writeFileSync(path.join(cwd, '.notifai', 'config.local.toml'), 'ask_grace_seconds = 300\n')
+    env.XDG_CONFIG_HOME = path.join(cwd, 'different-config')
+    env.XDG_STATE_HOME = path.join(cwd, 'different-state')
+
+    expect(
+      hooksInstallCommand(deps, {
+        harness: 'claude-code',
+        execPath: process.execPath,
+        scriptPath: secondCli,
+      }),
+    ).toBe(EXIT.ok)
+    expect(readFileSync(local, 'utf8')).toBe(firstDefinition)
+    expect(readFileSync(hookAdapterPath(deps.hookAdapterHome), 'utf8')).not.toBe(firstAdapter)
+    expect(firstDefinition).toContain(hookAdapterPath(deps.hookAdapterHome))
+    expect(firstDefinition).not.toContain(firstCli)
+    expect(firstDefinition).not.toContain(secondCli)
+
+    expect(
+      hooksInstallCommand(deps, {
+        harness: 'claude-code',
+        global: true,
+        execPath: process.execPath,
+        scriptPath: secondCli,
+      }),
+    ).toBe(EXIT.ok)
+    const global = readFileSync(path.join(env.CLAUDE_CONFIG_DIR, 'settings.json'), 'utf8')
+    expect(global).toBe(firstDefinition)
+
+    io.outLines = []
+    await doctorCommand(deps, {})
+    expect(io.outLines.join('\n')).toMatch(/hooks \(duplicates\).*project or global routing/is)
+
+    expect(hooksUninstallCommand(deps, { harness: 'claude-code' })).toBe(EXIT.ok)
+    expect(existsSync(hookAdapterPath(deps.hookAdapterHome))).toBe(true)
+    expect(
+      findInstallations(cwd, env, deps.hookAdapterHome).filter(
+        (item) => item.harness === 'claude-code',
+      ),
+    ).toHaveLength(1)
+  })
 })
 
 describe('projectSlugFrom', () => {
@@ -923,15 +1424,165 @@ describe('projectSlugFrom', () => {
   })
 })
 
-describe('config surfaces', () => {
-  function configDeps(io: CapturedIo): CommandDeps {
-    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-config-surface-'))
-    return { ...makeDeps(io, {} as ApiClient), cwd, env: { XDG_CONFIG_HOME: path.join(cwd, 'xdg') } }
+describe('logs', () => {
+  function logDeps(io: CapturedIo): CommandDeps {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-logs-cmd-'))
+    return {
+      ...makeDeps(io, {} as ApiClient),
+      cwd,
+      env: { XDG_CONFIG_HOME: path.join(cwd, 'xdg'), XDG_STATE_HOME: path.join(cwd, 'state') },
+    }
   }
 
-  it('gives an agent the same flat key = value output it always had', () => {
-    // The whole point of gating the readable rendering on a human terminal.
-    // Anything parsing this today must keep parsing it tomorrow.
+  function seed(deps: CommandDeps, project?: string): void {
+    const logger = createLogger({ env: deps.env, runId: 'r_seed', cmd: 'send' })
+    if (project !== undefined) logger.bind({ project })
+    logger.info('send.submitted', { request_id: 'req_seeded' })
+    logger.error('cli.error', { message: 'the server said no' })
+  }
+
+  it('shows the recent records, newest last', () => {
+    const io = new CapturedIo()
+    const deps = logDeps(io)
+    seed(deps)
+    expect(logsCommand(deps, {})).toBe(EXIT.ok)
+    expect(io.outLines).toHaveLength(2)
+    expect(io.outLines[0]).toContain('send.submitted')
+    expect(io.outLines[1]).toContain('cli.error')
+  })
+
+  it('keeps stdout pure JSONL under --json so a parser needs no filtering', () => {
+    // Every word of explanation goes to stderr. A machine reading stdout gets
+    // records and nothing else.
+    const io = new CapturedIo()
+    const deps = logDeps(io)
+    seed(deps)
+    expect(logsCommand(deps, { json: true })).toBe(EXIT.ok)
+    for (const line of io.outLines) {
+      expect(() => JSON.parse(line) as unknown).not.toThrow()
+    }
+    expect(io.outLines).toHaveLength(2)
+  })
+
+  it('narrows to the failures', () => {
+    const io = new CapturedIo()
+    const deps = logDeps(io)
+    seed(deps)
+    expect(logsCommand(deps, { level: 'error', json: true })).toBe(EXIT.ok)
+    expect(io.outLines).toHaveLength(1)
+    expect(io.outLines[0]).toContain('cli.error')
+  })
+
+  it('narrows to one notification request', () => {
+    const io = new CapturedIo()
+    const deps = logDeps(io)
+    seed(deps)
+    expect(logsCommand(deps, { request: 'req_seeded', json: true })).toBe(EXIT.ok)
+    expect(io.outLines).toHaveLength(1)
+  })
+
+  it('scopes to this project unless told otherwise', () => {
+    const io = new CapturedIo()
+    const deps = logDeps(io)
+    mkdirSync(path.join(deps.cwd, '.notifai'), { recursive: true })
+    writeFileSync(path.join(deps.cwd, '.notifai', 'config.toml'), 'project = "mine"\n')
+    seed(deps, 'mine')
+    seed(deps, 'someone-elses')
+
+    // A machine commonly runs several agents in several worktrees at once, and
+    // an answer interleaved with three other projects answers nothing.
+    expect(logsCommand(deps, { json: true })).toBe(EXIT.ok)
+    expect(io.outLines).toHaveLength(2)
+    io.outLines.length = 0
+    expect(logsCommand(deps, { json: true, allProjects: true })).toBe(EXIT.ok)
+    expect(io.outLines).toHaveLength(4)
+  })
+
+  it('rejects an unreadable time, unknown event, and invalid limits', () => {
+    const io = new CapturedIo()
+    const deps = logDeps(io)
+    expect(logsCommand(deps, { since: 'yesterday-ish' })).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toContain('10m')
+    io.errLines.length = 0
+    expect(logsCommand(deps, { event: ['send.exploded'] })).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toContain('send.submitted')
+    io.errLines.length = 0
+    expect(logsCommand(deps, { limit: Number.NaN })).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toContain('--limit')
+    io.errLines.length = 0
+    expect(logsCommand(deps, { limit: 2_001 })).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toContain('cannot exceed 2000')
+  })
+
+  it.each([
+    [{ path: true, clear: true }, '--path'],
+    [{ path: true, request: 'req_seeded' }, '--path'],
+    [{ clear: true, since: '1d' }, '--clear'],
+    [{ project: 'mine', allProjects: true }, '--project'],
+    [{ limit: 10, all: true }, '--limit'],
+  ] as const)('rejects incompatible log options %j', (flags, namedFlag) => {
+    const io = new CapturedIo()
+    expect(logsCommand(logDeps(io), flags)).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toContain(namedFlag)
+  })
+
+  it('accepts relative and absolute times', () => {
+    const now = Date.parse('2026-08-11T12:00:00Z')
+    expect(parseSince('10m', now)).toBe(now - 600_000)
+    expect(parseSince('2h', now)).toBe(now - 7_200_000)
+    expect(parseSince('1d', now)).toBe(now - 86_400_000)
+    expect(parseSince('2026-08-11T11:00:00Z', now)).toBe(Date.parse('2026-08-11T11:00:00Z'))
+    expect(parseSince('whenever', now)).toBeNull()
+  })
+
+  it('says why it is empty, and what to do about it', () => {
+    // "No records" with no explanation sends the reader looking for a bug that
+    // is actually a setting.
+    const io = new CapturedIo()
+    const deps = logDeps(io)
+    mkdirSync(path.join(deps.cwd, '.notifai'), { recursive: true })
+    writeFileSync(path.join(deps.cwd, '.notifai', 'config.toml'), 'log_level = "off"\n')
+    expect(logsCommand(deps, {})).toBe(EXIT.ok)
+    expect(io.errLines.join('\n')).toContain('log_level is off')
+    expect(io.errLines.join('\n')).toContain('config set log_level info')
+  })
+
+  it('points at the files, and says they stay here', () => {
+    const io = new CapturedIo()
+    const deps = logDeps(io)
+    seed(deps)
+    expect(logsCommand(deps, { path: true })).toBe(EXIT.ok)
+    expect(io.outLines[0]).toContain('notifai.jsonl')
+    expect(io.errLines.join('\n')).toContain('stay on this machine')
+  })
+
+  it('reports local_only in the machine-readable form', () => {
+    const io = new CapturedIo()
+    const deps = logDeps(io)
+    expect(logsCommand(deps, { path: true, json: true })).toBe(EXIT.ok)
+    const parsed = JSON.parse(io.outLines.join('\n')) as Record<string, unknown>
+    expect(parsed['local_only']).toBe(true)
+    expect(parsed['level']).toBe('info')
+  })
+
+  it('clears the files when asked', () => {
+    const io = new CapturedIo()
+    const deps = logDeps(io)
+    seed(deps)
+    expect(logsCommand(deps, { clear: true })).toBe(EXIT.ok)
+    expect(logsDiskUsage(deps.env).files).toBe(0)
+  })
+})
+
+describe('config surfaces', () => {
+  function configDeps(io: CapturedIo): CommandDeps {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-config-surface-'))
+    return { ...makeDeps(io, {} as ApiClient), cwd, env: { XDG_CONFIG_HOME: path.join(cwd, 'xdg') } }
+  }
+
+  it('gives an agent the same flat key = value output it always had', () => {
+    // The whole point of gating the readable rendering on a human terminal.
+    // Anything parsing this today must keep parsing it tomorrow.
     const io = new CapturedIo()
     expect(configShowCommand(configDeps(io), {})).toBe(EXIT.ok)
     expect(io.outLines).toHaveLength(CONFIG_KEYS.length)
@@ -943,8 +1594,8 @@ describe('config surfaces', () => {
     const io = new InteractiveIo()
     expect(configShowCommand(configDeps(io), {})).toBe(EXIT.ok)
     const text = io.outLines.join('\n')
-    expect(text).toContain('Questions & presence')
-    expect(text).toContain('Whether sitting at this keyboard holds a question back')
+    expect(text).toContain('Questions')
+    expect(text).toContain('Optional delay before a question may reach your devices')
   })
 
   it('keeps --plain available to a human who wants the parseable form', () => {
@@ -955,17 +1606,18 @@ describe('config surfaces', () => {
 
   it('explains one setting, and says so in JSON when asked', () => {
     const io = new InteractiveIo()
-    expect(configExplainCommand(configDeps(io), 'require_idle', { json: true })).toBe(EXIT.ok)
+    expect(configExplainCommand(configDeps(io), 'ask_notifications', { json: true })).toBe(EXIT.ok)
     const parsed = JSON.parse(io.outLines.join('\n')) as Record<string, unknown>
-    expect(parsed['key']).toBe('require_idle')
+    expect(parsed['key']).toBe('ask_notifications')
     expect(parsed['accepts']).toBe('true or false')
-    expect(parsed['detail']).toContain('question waits while you are using this machine')
+    expect(parsed['detail']).toContain('The master switch')
+    expect(parsed['detail']).toContain('Turn it off')
   })
 
   it('rejects an unknown setting and points at the nearest real one', () => {
     const io = new CapturedIo()
-    expect(configExplainCommand(configDeps(io), 'require_idl')).toBe(EXIT.usage)
-    expect(io.errLines[0]).toBe('Unknown setting "require_idl".')
+    expect(configExplainCommand(configDeps(io), 'ask_notification')).toBe(EXIT.usage)
+    expect(io.errLines[0]).toBe('Unknown setting "ask_notification".')
   })
 
   it('refuses an enum value the sender would later reject', async () => {
@@ -982,6 +1634,49 @@ describe('config surfaces', () => {
     const io = new CapturedIo()
     expect(await configSetCommand(configDeps(io), 'sound', 'none', { yes: true })).toBe(EXIT.ok)
   })
+
+  it('removes one machine setting, preserves its siblings, and restores default provenance', async () => {
+    const io = new CapturedIo()
+    const deps = configDeps(io)
+    const configFile = path.join(deps.env['XDG_CONFIG_HOME']!, 'notifai', 'config.toml')
+    mkdirSync(path.dirname(configFile), { recursive: true })
+    writeFileSync(configFile, 'wait_seconds = 20\nsound = "done"\n')
+
+    expect(await configUnsetCommand(deps, 'wait_seconds', { yes: true })).toBe(EXIT.ok)
+
+    const remaining = readFileSync(configFile, 'utf8')
+    expect(remaining).toContain('sound = "done"')
+    expect(remaining).not.toContain('wait_seconds')
+    const resolved = loadConfig({ cwd: deps.cwd, env: deps.env })
+    expect(resolved.wait_seconds).toEqual({ value: 10, source: 'default' })
+    expect(resolved.sound.source).toMatch(/^global:/)
+  })
+
+  it('refuses to create a redundant machine override equal to the shipped default', async () => {
+    const io = new CapturedIo()
+    const deps = configDeps(io)
+
+    expect(await configSetCommand(deps, 'wait_seconds', '10', { yes: true })).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toContain('already the shipped default')
+    expect(io.errLines.join('\n')).toContain('notifai config unset wait_seconds')
+    expect(existsSync(path.join(deps.env['XDG_CONFIG_HOME']!, 'notifai', 'config.toml'))).toBe(false)
+  })
+
+  it('allows a project to choose the shipped value when it masks a machine override', async () => {
+    const io = new CapturedIo()
+    const deps = configDeps(io)
+    const globalFile = path.join(deps.env['XDG_CONFIG_HOME']!, 'notifai', 'config.toml')
+    mkdirSync(path.dirname(globalFile), { recursive: true })
+    writeFileSync(globalFile, 'wait_seconds = 20\n')
+
+    expect(await configSetCommand(deps, 'wait_seconds', '10', { project: true, yes: true })).toBe(
+      EXIT.ok,
+    )
+    expect(loadConfig({ cwd: deps.cwd, env: deps.env }).wait_seconds).toMatchObject({
+      value: 10,
+      source: expect.stringMatching(/^project:/),
+    })
+  })
 })
 
 describe('interactive command UX', () => {
@@ -1099,6 +1794,25 @@ describe('interactive command UX', () => {
     )
   })
 
+  it('asks the same layer question when returning a setting to its inherited value', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-config-unset-layer-'))
+    const io = new InteractiveIo()
+    io.selectAnswer = 'local'
+    const localFile = path.join(cwd, '.notifai', 'config.local.toml')
+    mkdirSync(path.dirname(localFile), { recursive: true })
+    writeFileSync(localFile, 'sound = "done"\n')
+    const deps = {
+      ...makeDeps(io, {} as ApiClient),
+      cwd,
+      env: { XDG_CONFIG_HOME: path.join(cwd, 'xdg') },
+    }
+
+    expect(await configUnsetCommand(deps, 'sound', {})).toBe(EXIT.ok)
+    expect(io.prompts[0]).toBe('Where should this setting live?')
+    expect(io.prompts[1]).toContain(localFile)
+    expect(existsSync(localFile)).toBe(false)
+  })
+
   it('rejects numeric config values that resolution would otherwise silently clamp', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-config-bounds-'))
     const io = new CapturedIo()
@@ -1116,10 +1830,10 @@ describe('interactive command UX', () => {
       EXIT.usage,
     )
     expect(io.errLines).toEqual([
-      'ask_grace_seconds must be between 0 and 540.',
+      'ask_grace_seconds must be between 0 and 360.',
       // Names the key and its range: `"1.5" is not an integer` left the reader
       // to work out which of the two settings they had just mistyped.
-      'ask_grace_seconds takes a whole number from 0s–540s, not "1.5".',
+      'ask_grace_seconds takes a whole number from 0s–360s, not "1.5".',
     ])
     expect(existsSync(configFile)).toBe(false)
   })
@@ -1260,7 +1974,7 @@ describe('init', () => {
       source: 'Raidiant-io/notifai',
       sourceType: 'github',
       sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
-      ref: 'v0.3.0',
+      ref: 'v0.5.0',
     }
   }
 
@@ -1288,7 +2002,7 @@ describe('init', () => {
     return {
       ...makeDeps(io, client),
       cwd,
-      env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
+      env: isolatedEnv(cwd),
       nativeSkills,
     }
   }
@@ -1363,7 +2077,7 @@ describe('init', () => {
   })
 
   it('pins the skill installer to the tagged public release syntax', () => {
-    expect(SKILLS_SOURCE).toBe('Raidiant-io/notifai#v0.3.0')
+    expect(SKILLS_SOURCE).toBe('Raidiant-io/notifai#v0.5.0')
     expect(SKILLS_SOURCE).not.toContain('@v')
   })
 
@@ -1386,7 +2100,7 @@ describe('init', () => {
             source: 'Raidiant-io/notifai',
             sourceType: 'github',
             sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
-            ref: 'v0.3.0',
+            ref: 'v0.5.0',
           },
         ],
       }),
@@ -1618,7 +2332,7 @@ describe('init', () => {
     const deps: CommandDeps = {
       ...makeDeps(io, { health: async () => true } as unknown as ApiClient),
       cwd,
-      env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
+      env: isolatedEnv(cwd),
       store: { load: () => null, save: () => {}, clear: () => {}, describe: () => 'empty store' },
     }
 
@@ -1643,7 +2357,7 @@ describe('init', () => {
     const deps = {
       ...makeDeps(io, client),
       cwd,
-      env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
+      env: isolatedEnv(cwd),
     }
 
     expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.failed)
@@ -1716,7 +2430,7 @@ describe('init', () => {
     const deps = {
       ...makeDeps(io, client),
       cwd,
-      env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
+      env: isolatedEnv(cwd),
     }
 
     expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.failed)
@@ -1758,7 +2472,7 @@ describe('init', () => {
     const deps: CommandDeps = {
       ...makeDeps(io, client),
       cwd,
-      env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
+      env: isolatedEnv(cwd),
       now: () => now,
       sleep: async (milliseconds) => {
         now += milliseconds
@@ -1824,7 +2538,7 @@ describe('init', () => {
     const deps: CommandDeps = {
       ...makeDeps(io, client),
       cwd,
-      env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
+      env: isolatedEnv(cwd),
       now: () => now,
       sleep: async (milliseconds) => {
         now += milliseconds
@@ -1864,7 +2578,7 @@ describe('init', () => {
     const deps = {
       ...makeDeps(io, client),
       cwd,
-      env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
+      env: isolatedEnv(cwd),
     }
 
     expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.failed)
@@ -1908,7 +2622,7 @@ describe('init', () => {
     const deps: CommandDeps = {
       ...makeDeps(io, client),
       cwd,
-      env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
+      env: isolatedEnv(cwd),
       now: () => now,
       sleep: async (milliseconds) => {
         now += milliseconds
@@ -1954,7 +2668,7 @@ describe('init', () => {
     const deps = {
       ...makeDeps(io, client),
       cwd,
-      env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: '/dev/null' },
+      env: { ...isolatedEnv(cwd), XDG_STATE_HOME: '/dev/null' },
     }
 
     await expect(initCommand(deps, { hooks: false, skills: false })).resolves.toBe(EXIT.failed)
@@ -1981,7 +2695,7 @@ describe('init', () => {
     const deps = {
       ...makeDeps(io, client),
       cwd,
-      env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
+      env: isolatedEnv(cwd),
     }
 
     expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.ok)
@@ -1999,7 +2713,7 @@ describe('init', () => {
         {
           ...makeDeps(doctorIo, client),
           cwd,
-          env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
+          env: isolatedEnv(cwd),
         },
         {},
       ),
@@ -2059,7 +2773,7 @@ describe('init', () => {
     const deps = {
       ...makeDeps(io, client),
       cwd,
-      env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
+      env: isolatedEnv(cwd),
     }
 
     expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.failed)
@@ -2095,7 +2809,7 @@ describe('init', () => {
       const deps = {
         ...makeDeps(io, client),
         cwd,
-        env: { XDG_CONFIG_HOME: stateRoot, XDG_STATE_HOME: stateRoot },
+        env: { ...isolatedEnv(cwd), XDG_CONFIG_HOME: stateRoot, XDG_STATE_HOME: stateRoot },
       }
       expect(
         await initCommand(deps, { projectId: 'shared-project', hooks: false, skills: false }),
@@ -2114,7 +2828,9 @@ describe('an outage is not an answer', () => {
    * agent scripted to read exit 3 as "nobody objected" would proceed against a
    * refusal it never saw.
    */
-  function outageAfterFirstPoll(io: CapturedIo): CommandDeps {
+  function outageAfterFirstPoll(io: CapturedIo, fault: () => never = () => {
+    throw new NetworkError('link went down')
+  }): CommandDeps {
     let now = 0
     let polls = 0
     const client = {
@@ -2122,7 +2838,7 @@ describe('an outage is not an answer', () => {
       replies: async () => {
         polls += 1
         if (polls === 1) return replyResponse([])
-        throw new NetworkError('link went down')
+        fault()
       },
     } as unknown as ApiClient
     return {
@@ -2148,6 +2864,27 @@ describe('an outage is not an answer', () => {
     expect(exit).not.toBe(EXIT.noReply)
     expect(exit).toBe(EXIT.network)
     expect(io.errLines.join('\n')).toContain('could not find out')
+    expect(io.errLines.join('\n')).toContain(receipt.request_id)
+  })
+
+  it('treats a late internal_error outage the same as a network outage', async () => {
+    const io = new CapturedIo()
+    const exit = await sendCommand(
+      outageAfterFirstPoll(io, () => {
+        throw new ApiCallError(500, 'internal_error', 'An unexpected server error occurred.')
+      }),
+      {
+        title: 'Question',
+        body: 'Deploy to production?',
+        reply: true,
+        replyTimeout: 10,
+      },
+    )
+
+    expect(exit).not.toBe(EXIT.noReply)
+    expect(exit).toBe(EXIT.network)
+    expect(io.errLines.join('\n')).toContain('could not find out')
+    expect(io.errLines.join('\n')).toContain('Provider Acceptance')
   })
 
   it('marks the JSON so an agent reading it programmatically can tell', async () => {
@@ -2186,8 +2923,8 @@ describe('an outage is not an answer', () => {
 })
 
 describe('asking before the hooks have ever run', () => {
-  const execPath = '/usr/local/bin/node'
-  const scriptPath = '/opt/notifai/dist/main.js'
+  const execPath = process.execPath
+  const scriptPath = fileURLToPath(import.meta.url)
 
   it('names the active Codex harness instead of unrelated installed adapters', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-codex-missing-'))
@@ -2230,7 +2967,7 @@ describe('asking before the hooks have ever run', () => {
     io.outLines = []
 
     expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
-    expect(io.errLines.join(' ')).toMatch(/belongs to another Codex session/i)
+    expect(io.errLines.join(' ')).toMatch(/active Codex session:.*has not published/i)
     expect(io.outLines).not.toContain(
       'Question registered. Ask it in the conversation as usual and end your turn.',
     )
@@ -2248,16 +2985,230 @@ describe('asking before the hooks have ever run', () => {
     const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
 
     expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
-    writeSessionState('codex-current-thread', env, { last_prompt_at: 42 })
+    trustInstalledCodexHooks(cwd, env)
+    writeSessionState('codex-current-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'codex-current-thread', 42, 'codex')
+    writeSessionState('claude-concurrent', env, { last_prompt_at: 43, last_stop_at: 43 })
+    writeProjectSession(cwd, env, 'claude-concurrent', 43, 'claude-code')
     io.outLines = []
 
     expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.ok)
     expect(io.outLines).toContain(
-      'Question registered. Ask it in the conversation as usual and end your turn.',
+      'Question registered. Ask it in the conversation, state the concrete work you will resume when the answer arrives, then end your turn.',
+    )
+  })
+
+  // A harness exports its markers into everything it starts, so a nested
+  // harness sees its parent's markers alongside its own. Neither order between
+  // two markers can be right, and both nestings are ordinary: an orchestrator
+  // running inside Claude Code starts Codex, and the reverse happens just as
+  // often. The environment cannot settle it; the pointer index can.
+  it('routes to the live Codex thread when a Claude Code orchestrator started it', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-under-claude-'))
+    const io = new CapturedIo()
+    const env = {
+      ...isolatedEnv(cwd),
+      // Inherited from the parent Claude Code process, and unstrippable.
+      CLAUDECODE: '1',
+      CLAUDE_CODE_SESSION_ID: 'claude-orchestrator',
+      CODEX_THREAD_ID: 'codex-current-thread',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    // The configuration that made this unrecoverable: Claude Code hooks
+    // installed machine-wide match every directory, including this one.
+    expect(
+      hooksInstallCommand(deps, { harness: 'claude-code', global: true, execPath, scriptPath }),
+    ).toBe(EXIT.ok)
+    trustInstalledCodexHooks(cwd, env)
+    writeSessionState('codex-current-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeProjectSession(cwd, env, 'codex-current-thread', 42, 'codex')
+    io.outLines = []
+
+    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.ok)
+    expect(readSessionState('codex-current-thread', env).pending?.[0]?.question).toBe('Ship it?')
+    expect(readSessionState('claude-orchestrator', env).pending).toBeUndefined()
+  })
+
+  it('routes to the live Claude Code session when a Codex orchestrator started it', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-claude-under-codex-'))
+    const io = new CapturedIo()
+    const env = {
+      ...isolatedEnv(cwd),
+      CODEX_THREAD_ID: 'codex-orchestrator',
+      CLAUDECODE: '1',
+      CLAUDE_CODE_SESSION_ID: 'claude-current',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+
+    expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
+      EXIT.ok,
+    )
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    trustInstalledCodexHooks(cwd, env)
+    // Both sessions are live here. The parent fired when its own turn began;
+    // the child fired for the turn that is running this command.
+    writeSessionState('codex-orchestrator', env, { last_prompt_at: 40, last_stop_at: 39 })
+    writeProjectSession(cwd, env, 'codex-orchestrator', 40, 'codex')
+    writeSessionState('claude-current', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeProjectSession(cwd, env, 'claude-current', 42, 'claude-code')
+    io.outLines = []
+
+    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.ok)
+    expect(readSessionState('claude-current', env).pending?.[0]?.question).toBe('Ship it?')
+    expect(readSessionState('codex-orchestrator', env).pending).toBeUndefined()
+  })
+
+  it('judges the fired check against the active harness, not a global installation of another', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-fired-active-harness-'))
+    const io = new CapturedIo()
+    const env = {
+      ...isolatedEnv(cwd),
+      CLAUDECODE: '1',
+      CLAUDE_CODE_SESSION_ID: 'claude-orchestrator',
+      CODEX_THREAD_ID: 'codex-current-thread',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    expect(
+      hooksInstallCommand(deps, { harness: 'claude-code', global: true, execPath, scriptPath }),
+    ).toBe(EXIT.ok)
+    trustInstalledCodexHooks(cwd, env)
+    writeSessionState('codex-current-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeProjectSession(cwd, env, 'codex-current-thread', 42, 'codex')
+
+    const readiness = await assessReadiness(deps)
+    const fired = readiness.states.find((state) => state.id === 'hooks-fired')
+    // The Codex hooks fired. A missing Claude Code pointer says nothing about
+    // that, and telling this agent to send a Claude Code prompt is advice it
+    // cannot act on: it would refuse to ask, forever.
+    expect(fired?.status).toBe('ready')
+    expect(fired?.detail).toMatch(/active Codex session/i)
+    expect(fired?.detail).not.toMatch(/Claude Code/i)
+  })
+
+  it('advises every harness whose markers are present when none of them has fired here', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-fired-contested-'))
+    const io = new CapturedIo()
+    const env = {
+      ...isolatedEnv(cwd),
+      CLAUDECODE: '1',
+      CLAUDE_CODE_SESSION_ID: 'claude-orchestrator',
+      CODEX_THREAD_ID: 'codex-current-thread',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    expect(
+      hooksInstallCommand(deps, { harness: 'claude-code', global: true, execPath, scriptPath }),
+    ).toBe(EXIT.ok)
+    trustInstalledCodexHooks(cwd, env)
+
+    const readiness = await assessReadiness(deps)
+    const fired = readiness.states.find((state) => state.id === 'hooks-fired')
+    expect(fired?.status).toBe('optional-gap')
+    expect(fired?.detail).toMatch(/Claude Code/)
+    expect(fired?.detail).toMatch(/Codex: send one prompt/)
+
+    io.errLines = []
+    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
+    expect(io.errLines.join(' ')).toMatch(/Several harness markers are present/i)
+  })
+
+  it('makes one work-resumption commitment per offered answer part of the asking turn', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-ask-commitment-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CODEX_HOME: path.join(cwd, 'codex-home'),
+      CODEX_THREAD_ID: 'codex-commitment-thread',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    trustInstalledCodexHooks(cwd, env)
+    writeSessionState('codex-commitment-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeProjectSession(cwd, env, 'codex-commitment-thread', 42, 'codex')
+    io.outLines = []
+
+    expect(
+      askCommand(deps, 'Which environment should I deploy to?', {
+        choice: ['Staging', 'Production', 'Cancel'],
+      }),
+    ).toBe(EXIT.ok)
+
+    const said = io.outLines.join('\n')
+    expect(said).toContain('Before ending this turn')
+    for (const answer of ['Staging', 'Production', 'Cancel']) {
+      expect(said).toContain(`If the answer is "${answer}"`)
+    }
+    expect(said).toContain('unexpected typed answer')
+    expect(said).toContain('work you will resume')
+    expect(said).toContain('without asking the user to confirm again')
+    expect(said).toContain('not as approval')
+    expect(said).toContain('cannot answer a harness permission prompt or interactive picker')
+  })
+
+  it('requires a concrete fallback for free-text answers before the turn ends', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-ask-free-text-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CODEX_HOME: path.join(cwd, 'codex-home'),
+      CODEX_THREAD_ID: 'codex-free-text-thread',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    trustInstalledCodexHooks(cwd, env)
+    writeSessionState('codex-free-text-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeProjectSession(cwd, env, 'codex-free-text-thread', 42, 'codex')
+    io.outLines = []
+
+    expect(askCommand(deps, 'What rollout adjustment should I make?', {})).toBe(EXIT.ok)
+    expect(io.outLines.join('\n')).toContain(
+      'For the free-text answer: state how its content will determine the concrete work you resume.',
     )
   })
 
+  it('refuses a Codex question when the installed Stop definition is no longer trusted', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-stale-trust-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CODEX_HOME: path.join(cwd, 'codex-home'),
+      CODEX_THREAD_ID: 'codex-current-thread',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    trustInstalledCodexHooks(cwd, env)
+    const stop = findInstallations(cwd, env)
+      .find((installation) => installation.harness === 'codex')
+      ?.handlers.find((handler) => handler.event === 'Stop')
+    expect(stop).toBeDefined()
+    const configFile = path.join(env.CODEX_HOME, 'config.toml')
+    writeFileSync(
+      configFile,
+      readFileSync(configFile, 'utf8').replace(codexHookIdentityHash(stop!), 'sha256:obsolete'),
+    )
+    writeSessionState('codex-current-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeProjectSession(cwd, env, 'codex-current-thread', 42, 'codex')
+    io.outLines = []
+
+    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toMatch(/Stop.*changed since it was trusted.*\/hooks/is)
+
+    io.outLines = []
+    await doctorCommand(deps, {})
+    expect(io.outLines.join('\n')).toMatch(/FAIL\s+hooks \(trust\).*Stop/is)
+    expect(io.outLines.join('\n')).toMatch(/best-effort.*never writes.*\/hooks/is)
+  })
+
   it('gives doctor the same active-Codex diagnosis as ask', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-codex-doctor-'))
     const io = new CapturedIo()
@@ -2286,7 +3237,7 @@ describe('asking before the hooks have ever run', () => {
                   source: 'Raidiant-io/notifai',
                   sourceType: 'github',
                   sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
-                  ref: 'v0.3.0',
+                  ref: 'v0.5.0',
                 },
               ]
             : [],
@@ -2323,7 +3274,7 @@ describe('asking before the hooks have ever run', () => {
     io.outLines = []
 
     expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
-    expect(io.errLines.join(' ')).toMatch(/another Claude Code session/i)
+    expect(io.errLines.join(' ')).toMatch(/active Claude Code session:.*has not published/i)
   })
 
   it('accepts a Claude Code subprocess when its documented session id owns the pointer', () => {
@@ -2341,7 +3292,7 @@ describe('asking before the hooks have ever run', () => {
     expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
       EXIT.ok,
     )
-    writeSessionState('claude-parent-loop', env, { last_prompt_at: 42 })
+    writeSessionState('claude-parent-loop', env, { last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'claude-parent-loop', 42, 'claude-code')
     io.outLines = []
 
@@ -2349,6 +3300,80 @@ describe('asking before the hooks have ever run', () => {
     expect(readSessionState('claude-parent-loop', env).pending?.[0]?.question).toBe('Ship it?')
   })
 
+  it('fails closed when Claude Code does not expose an exact session id', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-claude-no-id-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CLAUDE_CONFIG_DIR: path.join(cwd, 'claude-home'),
+      CLAUDECODE: '1',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+    expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
+      EXIT.ok,
+    )
+    writeSessionState('claude-last-writer', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeProjectSession(cwd, env, 'claude-last-writer', 42, 'claude-code')
+    io.outLines = []
+
+    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toMatch(/does not expose an exact session id/i)
+    expect(readSessionState('claude-last-writer', env).pending).toBeUndefined()
+  })
+
+  it('rejects duplicate active Codex definitions before registration', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-codex-duplicate-'))
+    const io = new CapturedIo()
+    const env = {
+      HOME: path.join(cwd, 'home'),
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CODEX_HOME: path.join(cwd, 'codex-home'),
+      CODEX_THREAD_ID: 'codex-current-thread',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    expect(
+      hooksInstallCommand(deps, { harness: 'codex', global: true, execPath, scriptPath }),
+    ).toBe(EXIT.ok)
+    trustInstalledCodexHooks(cwd, env)
+    writeSessionState('codex-current-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeProjectSession(cwd, env, 'codex-current-thread', 42, 'codex')
+    io.outLines = []
+
+    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toMatch(/2 Codex definitions are active/i)
+    expect(readSessionState('codex-current-thread', env).pending).toBeUndefined()
+  })
+
+  it('does not let UserPromptSubmit alone count as a working turn-end route', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-prompt-only-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CLAUDE_CONFIG_DIR: path.join(cwd, 'claude-home'),
+      CLAUDECODE: '1',
+      CLAUDE_CODE_SESSION_ID: 'claude-current',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+    expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
+      EXIT.ok,
+    )
+    writeSessionState('claude-current', env, { last_prompt_at: 42 })
+    writeProjectSession(cwd, env, 'claude-current', 42, 'claude-code')
+    io.outLines = []
+
+    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toMatch(/Stop hook has not been observed/)
+
+    const readiness = await assessReadiness(deps)
+    const fired = readiness.states.find((state) => state.id === 'hooks-fired')
+    expect(fired?.status).toBe('gap')
+    expect(fired?.detail).toMatch(/UserPromptSubmit.*Stop has not been observed/)
+  })
+
   it('uses the OpenCode adapter marker instead of its config-directory variable', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-opencode-'))
     const io = new CapturedIo()
@@ -2366,10 +3391,31 @@ describe('asking before the hooks have ever run', () => {
     io.outLines = []
 
     expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
-    expect(io.errLines.join(' ')).toMatch(/another OpenCode session/i)
+    expect(io.errLines.join(' ')).toMatch(/active OpenCode session:.*has not published/i)
+  })
+
+  it('rejects OpenCode before registration even with an exact matching pointer', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-opencode-unsupported-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      OPENCODE_CONFIG_DIR: path.join(cwd, 'opencode-home'),
+      NOTIFAI_ACTIVE_HARNESS: 'opencode',
+      NOTIFAI_ACTIVE_SESSION_ID: 'opencode-current',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+    expect(hooksInstallCommand(deps, { harness: 'opencode', execPath, scriptPath })).toBe(EXIT.ok)
+    writeSessionState('opencode-current', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeProjectSession(cwd, env, 'opencode-current', 42, 'opencode')
+    io.outLines = []
+
+    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toMatch(/no proven answer continuation/i)
+    expect(readSessionState('opencode-current', env).pending).toBeUndefined()
   })
 
-  it('recognizes Cursor only from its active-agent marker', () => {
+  it('refuses Cursor when its active-agent marker has no exact conversation id', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-cursor-'))
     const io = new CapturedIo()
     const env = {
@@ -2379,12 +3425,13 @@ describe('asking before the hooks have ever run', () => {
     }
     const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
     expect(hooksInstallCommand(deps, { harness: 'cursor', execPath, scriptPath })).toBe(EXIT.ok)
-    writeSessionState('cursor-live', env, { last_prompt_at: 42 })
+    writeSessionState('cursor-live', env, { last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'cursor-live', 42, 'cursor')
     io.outLines = []
 
-    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.ok)
-    expect(readSessionState('cursor-live', env).pending?.[0]?.question).toBe('Ship it?')
+    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toMatch(/does not expose an exact session id/i)
+    expect(readSessionState('cursor-live', env).pending).toBeUndefined()
   })
 
   it('fails doctor when another harness looks healthy but the active Claude Code session does not', async () => {
@@ -2446,7 +3493,7 @@ describe('asking before the hooks have ever run', () => {
     mkdirSync(path.join(cwd, '.notifai'), { recursive: true })
     writeFileSync(
       path.join(cwd, '.notifai', 'config.local.toml'),
-      'ask_notifications = false\nrequire_idle = false\naway_after_seconds = 45\nask_grace_seconds = 90\nhook_reply_timeout_seconds = 120\n',
+      'ask_notifications = false\nask_grace_seconds = 90\n',
     )
     const io = new CapturedIo()
     const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: {} }
@@ -2456,27 +3503,167 @@ describe('asking before the hooks have ever run', () => {
     const said = io.outLines.join('\n')
     expect(said).toContain('Question routing settings:')
     expect(said).toContain('ask_notifications=false (project-local:')
-    expect(said).toContain('require_idle=false (project-local:')
-    expect(said).toContain('away_after_seconds=45 (project-local:')
     expect(said).toContain('ask_grace_seconds=90 (project-local:')
-    expect(said).toContain('hook_reply_timeout_seconds=120 (project-local:')
+    // Nothing about where the user is standing is listed, because nothing
+    // about where they are standing decides anything any more.
+    expect(said).not.toMatch(/require_idle|away_after_seconds|hook_reply_timeout_seconds/)
   })
 
-  it('fails doctor when runtime waits outgrow an installed Stop timeout', async () => {
+  it('keeps a freshly installed Stop definition valid when timing preferences change', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-doctor-timeout-drift-'))
     const io = new CapturedIo()
-    const env = { XDG_STATE_HOME: path.join(cwd, 'state'), CLAUDE_CONFIG_DIR: path.join(cwd, 'claude') }
-    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
     expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
       EXIT.ok,
     )
     mkdirSync(path.join(cwd, '.notifai'), { recursive: true })
-    writeFileSync(path.join(cwd, '.notifai', 'config.local.toml'), 'ask_grace_seconds = 400\n')
+    writeFileSync(path.join(cwd, '.notifai', 'config.local.toml'), 'ask_grace_seconds = 300\n')
     io.outLines = []
 
-    expect(await doctorCommand(deps, {})).toBe(EXIT.failed)
-    expect(io.outLines.join('\n')).toMatch(/FAIL\s+hooks \(timeout\)/)
-    expect(io.outLines.join('\n')).toContain('notifai hooks install --harness claude-code')
+    await doctorCommand(deps, {})
+    expect(io.outLines.join('\n')).toMatch(/ok\s+hooks \(stop shape\)/)
+  })
+
+  it('names an old blocking Claude Stop handler as the reason no wake can happen', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-doctor-stale-shape-'))
+    const io = new CapturedIo()
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
+    // Exactly what every build before the asynchronous waiter wrote: a blocking
+    // handler with the old ceiling. It looks installed and it fires, but the
+    // waiter would hold the turn and then be killed at Claude's silent default.
+    mkdirSync(path.join(cwd, '.claude'), { recursive: true })
+    applyPlan(path.join(cwd, '.claude', 'settings.local.json'), {
+      hooks: {
+        Stop: [
+          {
+            hooks: [
+              {
+                type: 'command',
+                command: `'${path.join(cwd, 'home', '.notifai', 'bin', 'hook-adapter')}' hook stop --owner notifai --harness claude-code`,
+                timeout: 540,
+              },
+            ],
+          },
+        ],
+      },
+    })
+
+    await doctorCommand(deps, {})
+    const out = io.outLines.join('\n')
+    expect(out).toMatch(/FAIL\s+hooks \(stop shape\)/)
+    expect(out).toContain('needs `async: true`')
+    expect(out).toContain('kills the backgrounded waiter at its 600s default')
+  })
+
+  /** A configured Claude Code project with one live session claiming `pid`. */
+  function claudeWakeDeps(
+    io: CapturedIo,
+    descriptor: (pid: number) => unknown,
+  ): { deps: CommandDeps; cwd: string } {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-doctor-wake-'))
+    const base = {
+      ...makeDeps(io, {} as ApiClient),
+      cwd,
+      env: { ...isolatedEnv(cwd), CLAUDECODE: '1', CLAUDE_CODE_SESSION_ID: 'sess-live' },
+      claudeSourcePid: 4242,
+      claudeWake: { readDescriptor: descriptor } as unknown as ClaudeWakeAdapters,
+    }
+    expect(hooksInstallCommand(base, { harness: 'claude-code', execPath, scriptPath })).toBe(
+      EXIT.ok,
+    )
+    io.outLines = []
+    return { deps: base, cwd }
+  }
+
+  it('reports a live Claude session as reachable without connecting to its socket', async () => {
+    const io = new CapturedIo()
+    const socket = path.join(mkdtempSync(path.join(os.tmpdir(), 'cc-socks-')), '4242.sock')
+    writeFileSync(socket, '')
+    const { deps } = claudeWakeDeps(io, (pid) => ({
+      pid,
+      sessionId: 'sess-live',
+      cwd: '/tmp',
+      startedAt: 1,
+      procStart: 'x',
+      version: '2.1.228',
+      peerProtocol: 1,
+      messagingSocketPath: socket,
+      status: 'idle',
+    }))
+
+    await doctorCommand(deps, {})
+    const out = io.outLines.join('\n')
+    expect(out).toMatch(/ok\s+hooks \(wake route\)/)
+    expect(out).toContain(socket)
+    expect(out).toContain('an answer can start a turn here without you')
+    // Doctor never widens the user's inbound policy to make Notifai work: the
+    // poster is the session's own hook child and needs no such permission.
+    expect(out).not.toContain('crossSessionInbound')
+  })
+
+  it('names a --bare session as the reason an answer would wait for the next turn', async () => {
+    const io = new CapturedIo()
+    const { deps } = claudeWakeDeps(io, () => {
+      throw new Error('ENOENT: no such file or directory')
+    })
+
+    expect(await doctorCommand(deps, {})).toBe(EXIT.failed) // unreachable test server
+    const out = io.outLines.join('\n')
+    // Honest, and not a blocker: nothing is lost, it simply arrives later.
+    expect(out).toMatch(/--\s+hooks \(wake route\)/)
+    expect(out).toContain('`--bare` binds no inbox socket')
+    expect(out).toContain("at this session's next turn")
+    expect(out).not.toMatch(/FAIL\s+hooks \(wake route\)/)
+  })
+
+  it('fails closed on an inbox protocol it does not recognise', async () => {
+    const io = new CapturedIo()
+    const socket = path.join(mkdtempSync(path.join(os.tmpdir(), 'cc-socks-')), '4242.sock')
+    writeFileSync(socket, '')
+    const { deps } = claudeWakeDeps(io, (pid) => ({
+      pid,
+      sessionId: 'sess-live',
+      cwd: '/tmp',
+      startedAt: 1,
+      procStart: 'x',
+      version: '2.1.228',
+      peerProtocol: 7,
+      messagingSocketPath: socket,
+      status: 'idle',
+    }))
+
+    await doctorCommand(deps, {})
+    const out = io.outLines.join('\n')
+    expect(out).toContain('speaks inbox protocol 7')
+    expect(out).toContain('refusing to guess at an undocumented wire format')
+  })
+
+  it('reports Codex resume readiness from its writer-lock directory alone', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-doctor-codex-wake-'))
+    const io = new CapturedIo()
+    const env = {
+      ...isolatedEnv(cwd),
+      CODEX_THREAD_ID: '9f1c2b3a-4d5e-6f70-8192-a3b4c5d6e7f8',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env }
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+
+    io.outLines = []
+    await doctorCommand(deps, {})
+    expect(io.outLines.join('\n')).toContain('nothing can be resumed: no thread-writer-lock')
+
+    mkdirSync(path.join(env['CODEX_HOME']!, 'thread-writer-locks'), { recursive: true })
+    io.outLines = []
+    await doctorCommand(deps, {})
+    const out = io.outLines.join('\n')
+    if (process.platform === 'darwin') {
+      expect(out).toMatch(/ok\s+hooks \(wake route\)/)
+      expect(out).toContain('can prove a stopped thread unowned before resuming it')
+    } else {
+      // Linux has no non-blocking `flock` through Node's `open(2)` flags, so
+      // the gate stays shut and doctor says so rather than implying a wake.
+      expect(out).toContain('nothing can be resumed')
+    }
   })
 
   it('documents the failing exit contract in doctor JSON', async () => {
@@ -2494,10 +3681,7 @@ describe('asking before the hooks have ever run', () => {
     mkdirSync(path.join(cwd, '.claude'), { recursive: true })
     applyPlan(path.join(cwd, '.claude', 'settings.local.json'), {
       hooks: buildHookConfig({
-        execPath: '/usr/bin/node',
-        scriptPath: '/opt/notifai/main.js',
-        replyTimeoutSeconds: 180,
-        graceSeconds: 300,
+        adapterPath: path.join(cwd, 'notifai', 'hook-adapter'),
       }),
     })
 
@@ -2526,7 +3710,7 @@ describe('asking before the hooks have ever run', () => {
     expect(io.errLines.join(' ')).toMatch(/Cursor: send one prompt, then run `notifai doctor`/)
   })
 
-  it('keeps OpenCode activation separate from answer continuation', () => {
+  it('keeps OpenCode activation separate from unsupported answer continuation', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-opencode-first-run-'))
     const io = new CapturedIo()
     const deps = {
@@ -2544,7 +3728,7 @@ describe('asking before the hooks have ever run', () => {
     expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
     const said = io.errLines.join(' ')
     expect(said).toMatch(/OpenCode: restart it, then send one prompt/)
-    expect(said).toContain('device answer is delivered on the next prompt')
+    expect(said).toContain('non-blocking question continuation is intentionally unsupported')
   })
 
   it('says to install when nothing is installed at all', () => {