@raidiant/notifai 0.2.1 → 0.4.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,
@@ -17,7 +18,10 @@ import {
   buildQuestions,
   assessReadiness,
   capabilitiesCommand,
+  configExplainCommand,
   configSetCommand,
+  configShowCommand,
+  configUnsetCommand,
   contradictingAnswer,
   describeHookFailure,
   doctorCommand,
@@ -27,6 +31,8 @@ import {
   initCommand,
   SKILLS_SOURCE,
   loginCommand,
+  logsCommand,
+  parseSince,
   projectSlugFrom,
   repliesCommand,
   sendCommand,
@@ -35,9 +41,19 @@ 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, 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 {
   outLines: string[] = []
@@ -72,7 +88,7 @@ class InteractiveIo extends CapturedIo {
   intros: string[] = []
   outros: string[] = []
   spinnerEvents: string[] = []
-  checks: { ok: boolean; message: string }[] = []
+  checks: { ok: boolean; message: string; tone?: Tone }[] = []
 
   override async confirm(question: string) {
     this.prompts.push(question)
@@ -111,12 +127,28 @@ class InteractiveIo extends CapturedIo {
     }
   }
 
-  async check(ok: boolean, message: string) {
-    this.checks.push({ ok, message })
+  async check(ok: boolean, message: string, tone?: Tone) {
+    this.checks.push({ ok, message, ...(tone === undefined ? {} : { tone }) })
   }
 }
 
+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: {
@@ -130,7 +162,11 @@ 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,
   }
@@ -490,13 +526,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, {
@@ -509,6 +551,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 () => {
@@ -545,6 +595,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
@@ -615,10 +756,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 () => {
@@ -674,6 +823,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', () => {
@@ -730,6 +1071,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 () => {
@@ -747,12 +1090,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-'))
@@ -846,8 +1217,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-'))
@@ -877,7 +1248,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 = {
@@ -885,21 +1256,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, ''))
@@ -908,6 +1291,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', () => {
@@ -919,6 +1403,261 @@ describe('projectSlugFrom', () => {
   })
 })
 
+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') },
+    }
+  }
+
+  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)
+    expect(io.outLines[0]).toMatch(/^base_url = "/)
+    for (const line of io.outLines) expect(line).toMatch(/^[a-z_]+ = /)
+  })
+
+  it('explains each setting once a human is at the terminal', () => {
+    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')
+  })
+
+  it('keeps --plain available to a human who wants the parseable form', () => {
+    const io = new InteractiveIo()
+    expect(configShowCommand(configDeps(io), { plain: true })).toBe(EXIT.ok)
+    expect(io.outLines).toHaveLength(CONFIG_KEYS.length)
+  })
+
+  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)
+    const parsed = JSON.parse(io.outLines.join('\n')) as Record<string, unknown>
+    expect(parsed['key']).toBe('require_idle')
+    expect(parsed['accepts']).toBe('true or false')
+    expect(parsed['detail']).toContain('Off (the default)')
+    expect(parsed['detail']).toContain('Turn this on')
+  })
+
+  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".')
+  })
+
+  it('refuses an enum value the sender would later reject', async () => {
+    // `config set sound whatever` used to be written straight to disk: the
+    // typo only surfaced when a notification failed to carry the sound.
+    const io = new CapturedIo()
+    expect(await configSetCommand(configDeps(io), 'sound', 'whatever', { yes: true })).toBe(
+      EXIT.usage,
+    )
+    expect(io.errLines[0]).toContain('default, done, attention, alert, none')
+  })
+
+  it('still accepts a legal enum value', async () => {
+    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', () => {
   it('styles login pairing progress for a human terminal', async () => {
     const io = new InteractiveIo()
@@ -1034,6 +1773,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()
@@ -1051,8 +1809,10 @@ describe('interactive command UX', () => {
       EXIT.usage,
     )
     expect(io.errLines).toEqual([
-      'ask_grace_seconds must be between 0 and 540.',
-      '"1.5" is not an integer.',
+      'ask_grace_seconds must be between 0 and 334.',
+      // 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–334s, not "1.5".',
     ])
     expect(existsSync(configFile)).toBe(false)
   })
@@ -1081,6 +1841,18 @@ describe('interactive command UX', () => {
     expect(io.checks.some((check) => !check.ok && check.message.startsWith('This machine:'))).toBe(true)
     expect(io.checks.some((check) => check.ok && check.message.startsWith('Protocol version:'))).toBe(true)
     expect(io.outLines).toEqual([])
+
+    // Four tones, not two. A boolean has to round `optional-gap` and `unknown`
+    // to pass or fail, and rounding them to pass put a tick beside things the
+    // user had declined and beside things nothing had checked.
+    const tone = (prefix: string): Tone | undefined =>
+      io.checks.find((check) => check.message.startsWith(prefix))?.tone
+    expect(tone('This machine:')).toBe('bad')
+    expect(tone('Protocol version:')).toBe('ok')
+    // Never evaluated: the account cannot be checked without a credential.
+    expect(tone('Account:')).toBe('pending')
+    // Legitimately declined rather than broken.
+    expect(tone('Project identity:')).toBe('warn')
   })
 
   it('keeps doctor JSON as one machine-readable stdout document', async () => {
@@ -1181,7 +1953,7 @@ describe('init', () => {
       source: 'Raidiant-io/notifai',
       sourceType: 'github',
       sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
-      ref: 'v0.2.1',
+      ref: 'v0.4.0',
     }
   }
 
@@ -1284,7 +2056,7 @@ describe('init', () => {
   })
 
   it('pins the skill installer to the tagged public release syntax', () => {
-    expect(SKILLS_SOURCE).toBe('Raidiant-io/notifai#v0.2.1')
+    expect(SKILLS_SOURCE).toBe('Raidiant-io/notifai#v0.4.0')
     expect(SKILLS_SOURCE).not.toContain('@v')
   })
 
@@ -1307,7 +2079,7 @@ describe('init', () => {
             source: 'Raidiant-io/notifai',
             sourceType: 'github',
             sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
-            ref: 'v0.2.1',
+            ref: 'v0.4.0',
           },
         ],
       }),
@@ -2035,7 +2807,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 = {
@@ -2043,7 +2817,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 {
@@ -2069,6 +2843,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 () => {
@@ -2107,8 +2902,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-'))
@@ -2151,7 +2946,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.',
     )
@@ -2169,8 +2964,11 @@ 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)
@@ -2179,6 +2977,40 @@ describe('asking before the hooks have ever run', () => {
     )
   })
 
+  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()
@@ -2207,7 +3039,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.2.1',
+                  ref: 'v0.4.0',
                 },
               ]
             : [],
@@ -2244,7 +3076,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', () => {
@@ -2262,7 +3094,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 = []
 
@@ -2270,6 +3102,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()
@@ -2287,10 +3193,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 = {
@@ -2300,12 +3227,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 () => {
@@ -2383,7 +3311,7 @@ describe('asking before the hooks have ever run', () => {
     expect(said).toContain('hook_reply_timeout_seconds=120 (project-local:')
   })
 
-  it('fails doctor when runtime waits outgrow an installed Stop timeout', async () => {
+  it('keeps an installed Stop timeout valid when runtime 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') }
@@ -2395,9 +3323,11 @@ describe('asking before the hooks have ever run', () => {
     writeFileSync(path.join(cwd, '.notifai', 'config.local.toml'), 'ask_grace_seconds = 400\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 \(timeout\)/)
+    expect(io.outLines.join('\n')).toContain(
+      'declared Stop timeouts match the fixed 540s process budget where required; Codex uses host defaults',
+    )
   })
 
   it('documents the failing exit contract in doctor JSON', async () => {
@@ -2415,10 +3345,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'),
       }),
     })
 
@@ -2447,7 +3374,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 = {
@@ -2465,7 +3392,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', () => {