@raidiant/notifai 1.0.1 → 2.0.0

package/src/commands.test.ts

@@ -1,4 +1,13 @@
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, symlinkSync, writeFileSync } from 'node:fs'
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -10,15 +19,17 @@ import type {
   SubmissionReceipt,
   SubmitNotificationRequestT,
 } from '@raidiant/notifai-protocol'
-import { describe, expect, it } from 'vitest'
+import { afterEach, describe, expect, it } from 'vitest'
 import { ApiCallError, NetworkError, type ApiClient } from './client.js'
 import type { ClaudeWakeAdapters } from './claude-wake.js'
 import {
+  acknowledgeCommand,
   askCommand,
   accessStatusCommand,
   buildQuestions,
   assessReadiness,
   capabilitiesCommand,
+  closeCommand,
   configExplainCommand,
   configSetCommand,
   configShowCommand,
@@ -51,7 +62,7 @@ import {
 } from './install-hooks.js'
 import { readSessionState, writeProjectSession, writeSessionState } from './hooks.js'
 import { nativeSkills as realNativeSkills, type NativeSkill, type NativeSkills, type SkillScope } from './native-skills.js'
-import { CONFIG_KEYS, loadConfig, personalProjectConfigPath } from './config.js'
+import { CONFIG_KEYS, loadConfig, personalProjectConfigPath, stateDir } from './config.js'
 import { createLogger, logsDiskUsage, readLogRecords } from './logging.js'
 import { hookAdapterPath, inspectHookAdapter } from './hook-adapter.js'
 import type { Tone } from './ui/theme.js'
@@ -161,6 +172,29 @@ class InteractiveIo extends CapturedIo {
 }
 
 function trustInstalledCodexHooks(cwd: string, env: NodeJS.ProcessEnv): void {
+  const home = env['HOME']
+  if (home === undefined || home === '') {
+    throw new Error(
+      'trustInstalledCodexHooks requires env.HOME; refusing to use the real home directory',
+    )
+  }
+  const resolvedHome = path.resolve(home)
+  const tmpRoot = path.resolve(os.tmpdir())
+  const underTmp = resolvedHome === tmpRoot || resolvedHome.startsWith(`${tmpRoot}${path.sep}`)
+  if (!underTmp) {
+    throw new Error(
+      `trustInstalledCodexHooks will only write under ${tmpRoot}, not ${resolvedHome}`,
+    )
+  }
+  const codexHome = env['CODEX_HOME'] !== undefined && env['CODEX_HOME'] !== ''
+    ? path.resolve(env['CODEX_HOME'])
+    : path.join(resolvedHome, '.codex')
+  if (codexHome !== tmpRoot && !codexHome.startsWith(`${tmpRoot}${path.sep}`)) {
+    throw new Error(
+      `trustInstalledCodexHooks will only write under ${tmpRoot}, not ${codexHome}`,
+    )
+  }
+  const file = path.join(codexHome, 'config.toml')
   const installations = findInstallations(cwd, env).filter(
     (installation) => installation.harness === 'codex',
   )
@@ -170,9 +204,7 @@ function trustInstalledCodexHooks(cwd: string, env: NodeJS.ProcessEnv): void {
       return `[hooks.state.${JSON.stringify(key)}]\ntrusted_hash = ${JSON.stringify(codexHookIdentityHash(handler))}\n`
     }),
   )
-  const codexHome = env['CODEX_HOME'] as string
-  mkdirSync(codexHome, { recursive: true })
-  const file = path.join(codexHome, 'config.toml')
+  mkdirSync(path.dirname(file), { recursive: true })
   // Trust lives in the same config.toml as inline [hooks]. Overwriting the
   // file would delete the global handlers this helper is trying to trust.
   const existing = existsSync(file) ? readFileSync(file, 'utf8').trimEnd() : ''
@@ -219,6 +251,7 @@ function isolatedEnv(cwd: string): NodeJS.ProcessEnv {
     HOME: home,
     CLAUDE_CONFIG_DIR: path.join(home, '.claude'),
     CODEX_HOME: path.join(home, '.codex'),
+    OPENCODE_CONFIG_DIR: path.join(home, '.config', 'opencode'),
     XDG_CONFIG_HOME: path.join(cwd, 'config'),
     XDG_STATE_HOME: path.join(cwd, 'state'),
   }
@@ -226,6 +259,8 @@ function isolatedEnv(cwd: string): NodeJS.ProcessEnv {
 
 const receipt: SubmissionReceipt = {
   request_id: 'req_reply_test',
+  reply_expires_at: '2026-08-02T18:00:00.000Z',
+  agent_acknowledgement_required: true,
   replayed: false,
   overall: 'provider_accepted_all',
   deliveries: [
@@ -254,10 +289,18 @@ const reply: ReplyView = {
   created_at: '2026-08-01T18:01:00.000Z',
 }
 
-function replyResponse(replies: ReplyView[] = []): ListRepliesResponse {
+function replyResponse(
+  replies: ReplyView[] = [],
+  options: {
+    required?: boolean
+    acknowledgement?: ListRepliesResponse['agent_acknowledgement']
+  } = {},
+): ListRepliesResponse {
   return {
     request_id: receipt.request_id,
     reply_expires_at: '2026-08-02T18:00:00.000Z',
+    agent_acknowledgement_required: options.required ?? true,
+    agent_acknowledgement: options.acknowledgement ?? null,
     replies,
   }
 }
@@ -604,7 +647,11 @@ describe('command contracts', () => {
     ).toBe(EXIT.ok)
     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')
+    expect(io.outLines).toContain('reply from iPhone: yes, after the migration')
+    expect(io.outLines).toContain('Agent Acknowledgement required.')
+    expect(io.outLines.join('\n')).toContain(
+      `notifai acknowledge ${receipt.request_id} --text <text>`,
+    )
     const received = readLogRecords(deps.env, { event: ['reply.received'] }).records
     expect(received).toHaveLength(1)
     expect(received[0]?.data).toMatchObject({
@@ -687,7 +734,11 @@ describe('command contracts', () => {
       }),
     ).toBe(EXIT.ok)
     expect(replyCalls).toBe(3)
-    expect(io.outLines.at(-1)).toBe('reply from iPhone: yes, after the migration')
+    expect(io.outLines).toContain('reply from iPhone: yes, after the migration')
+    expect(io.outLines).toContain('Agent Acknowledgement required.')
+    expect(io.outLines.join('\n')).toContain(
+      `notifai acknowledge ${receipt.request_id} --text <text>`,
+    )
     expect(io.errLines.join('\n')).not.toContain('internal_error')
   })
 
@@ -768,9 +819,14 @@ describe('command contracts', () => {
     expect(JSON.parse(io.outLines[1] ?? '{}')).toEqual({
       type: 'reply_result',
       request_id: receipt.request_id,
+      reply_expires_at: '2026-08-02T18:00:00.000Z',
       replies: [],
+      agent_acknowledgement_required: true,
+      agent_acknowledgement: null,
+      acknowledgement_command: null,
       degraded: false,
     })
+    expect(io.outLines).not.toContain('Agent Acknowledgement required.')
     expect(io.errLines.join('\n')).toContain(`notifai replies ${receipt.request_id}`)
     expect(io.errLines.join('\n')).toContain(`notifai close ${receipt.request_id}`)
   })
@@ -796,11 +852,227 @@ describe('command contracts', () => {
     expect(JSON.parse(io.outLines[1] ?? '{}')).toEqual({
       type: 'reply_result',
       request_id: receipt.request_id,
+      reply_expires_at: '2026-08-02T18:00:00.000Z',
       replies: [reply],
+      agent_acknowledgement_required: true,
+      agent_acknowledgement: null,
+      acknowledgement_command: `notifai acknowledge ${receipt.request_id} --text <text>`,
       degraded: false,
     })
   })
 
+  it('acknowledges non-interactively, trims text, emits JSON, and logs request identity', async () => {
+    const io = new CapturedIo()
+    let submitted: { requestId: string; text: string } | undefined
+    const client = {
+      putAgentAcknowledgement: async (requestId: string, body: { text: string }) => {
+        submitted = { requestId, text: body.text }
+        return {
+          status: 'recorded' as const,
+          agent_acknowledgement: {
+            text: body.text,
+            created_at: '2026-08-13T12:01:00.000Z',
+          },
+        }
+      },
+    } as unknown as ApiClient
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-acknowledge-log-'))
+    const deps = makeDeps(io, client)
+    deps.env = {
+      XDG_CONFIG_HOME: path.join(root, 'config'),
+      XDG_STATE_HOME: path.join(root, 'state'),
+    }
+    deps.logger = createLogger({ env: deps.env, cmd: 'acknowledge' })
+
+    expect(
+      await acknowledgeCommand(deps, receipt.request_id, {
+        text: '  I will deploy staging now.  ',
+        json: true,
+      }),
+    ).toBe(EXIT.ok)
+    expect(submitted).toEqual({
+      requestId: receipt.request_id,
+      text: 'I will deploy staging now.',
+    })
+    expect(JSON.parse(io.outLines[0] ?? '{}')).toEqual({
+      request_id: receipt.request_id,
+      outcome: 'recorded',
+      acknowledgement: {
+        text: 'I will deploy staging now.',
+        created_at: '2026-08-13T12:01:00.000Z',
+      },
+      agent_acknowledgement_required: true,
+    })
+    const events = readLogRecords(deps.env, {
+      request: receipt.request_id,
+      event: ['acknowledgement.attempted', 'acknowledgement.outcome'],
+    }).records
+    expect(events.map((event) => event.event)).toEqual([
+      'acknowledgement.attempted',
+      'acknowledgement.outcome',
+    ])
+  })
+
+  it('clears a matching active-session obligation after acknowledgement success', async () => {
+    const io = new CapturedIo()
+    const client = {
+      putAgentAcknowledgement: async () => ({
+        status: 'recorded' as const,
+        agent_acknowledgement: {
+          text: 'I will deploy staging now.',
+          created_at: '2026-08-13T12:01:00.000Z',
+        },
+      }),
+    } as unknown as ApiClient
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-ack-clear-'))
+    const deps = makeDeps(io, client)
+    deps.env = {
+      XDG_CONFIG_HOME: path.join(root, 'config'),
+      XDG_STATE_HOME: path.join(root, 'state'),
+    }
+    const now = 1_800_000_000_000
+    deps.now = () => now
+    writeSessionState('ack-session', deps.env, {
+      acknowledgement_due: [{ request_id: receipt.request_id, recorded_at: now }],
+    })
+    writeProjectSession(deps.cwd, deps.env, 'ack-session', now, 'codex')
+
+    expect(
+      await acknowledgeCommand(deps, receipt.request_id, {
+        text: 'I will deploy staging now.',
+      }),
+    ).toBe(EXIT.ok)
+    expect(readSessionState('ack-session', deps.env).acknowledgement_due).toBeUndefined()
+  })
+
+  it('reports idempotent acknowledgement replay in concise human output', async () => {
+    const io = new CapturedIo()
+    const client = {
+      putAgentAcknowledgement: async () => ({
+        status: 'replayed' as const,
+        agent_acknowledgement: {
+          text: 'I will deploy staging now.',
+          created_at: '2026-08-13T12:01:00.000Z',
+        },
+      }),
+    } as unknown as ApiClient
+
+    expect(
+      await acknowledgeCommand(makeDeps(io, client), receipt.request_id, {
+        text: 'I will deploy staging now.',
+      }),
+    ).toBe(EXIT.ok)
+    expect(io.outLines).toEqual([
+      `Agent Acknowledgement replayed for ${receipt.request_id} at 2026-08-13T12:01:00.000Z.`,
+    ])
+  })
+
+  it.each([
+    { text: undefined, message: '--text is required' },
+    { text: '   ', message: '--text is required' },
+    { text: 'x'.repeat(1001), message: 'at most 1000 characters' },
+  ])('rejects invalid acknowledgement text before network: $message', async ({ text, message }) => {
+    const io = new CapturedIo()
+    let calls = 0
+    const client = {
+      putAgentAcknowledgement: async () => {
+        calls += 1
+        throw new Error('should not be reached')
+      },
+    } as unknown as ApiClient
+
+    expect(
+      await acknowledgeCommand(makeDeps(io, client), receipt.request_id, { text }),
+    ).toBe(EXIT.usage)
+    expect(calls).toBe(0)
+    expect(io.errLines.join('\n')).toContain(message)
+  })
+
+  it.each([
+    [new ApiCallError(409, 'conflict', 'A different acknowledgement is already recorded.'), EXIT.failed, 'conflict'],
+    [new ApiCallError(409, 'reply_not_enabled', 'Agent Acknowledgements are disabled.'), EXIT.failed, 'reply_not_enabled'],
+    [new ApiCallError(409, 'conflict', 'No user reply has been recorded yet.'), EXIT.failed, 'No user reply'],
+    [new ApiCallError(404, 'not_found', 'This request is unavailable or its content was purged.'), EXIT.failed, 'purged'],
+    [new ApiCallError(401, 'machine_revoked', 'This machine was revoked.'), EXIT.auth, 'machine_revoked'],
+    [new NetworkError('Could not reach the service'), EXIT.network, 'Could not reach'],
+  ] as const)(
+    'maps stable acknowledgement failure %#',
+    async (error, expectedExit, expectedCopy) => {
+      const io = new CapturedIo()
+      const client = {
+        putAgentAcknowledgement: async () => {
+          throw error
+        },
+      } as unknown as ApiClient
+
+      expect(
+        await acknowledgeCommand(makeDeps(io, client), receipt.request_id, { text: 'Next work.' }),
+      ).toBe(expectedExit)
+      expect(io.errLines.join('\n')).toContain(expectedCopy)
+    },
+  )
+
+  it('reports required-but-not-yet-due state before any user reply', async () => {
+    const io = new CapturedIo()
+    const client = {
+      replies: async () => replyResponse([]),
+    } as unknown as ApiClient
+
+    expect(await repliesCommand(makeDeps(io, client), receipt.request_id, {})).toBe(EXIT.noReply)
+    expect(io.outLines).toContain(
+      'Agent Acknowledgement: required after a user reply; no reply is recorded yet.',
+    )
+    expect(io.outLines.join('\n')).not.toContain('notifai acknowledge')
+  })
+
+  it('exposes disabled acknowledgement state without a follow-up command', async () => {
+    const io = new CapturedIo()
+    const client = {
+      replies: async () => replyResponse([reply], { required: false }),
+    } as unknown as ApiClient
+
+    expect(await repliesCommand(makeDeps(io, client), receipt.request_id, {})).toBe(EXIT.ok)
+    expect(io.outLines).toContain('Agent Acknowledgement: not required for this request.')
+    expect(io.outLines.join('\n')).not.toContain('notifai acknowledge')
+  })
+
+  it('exposes an existing acknowledgement without repeating the follow-up command', async () => {
+    const io = new CapturedIo()
+    const acknowledgement = {
+      text: 'I will deploy staging now.',
+      created_at: '2026-08-13T12:01:00.000Z',
+    }
+    const client = {
+      replies: async () => replyResponse([reply], { acknowledgement }),
+    } as unknown as ApiClient
+
+    expect(
+      await repliesCommand(makeDeps(io, client), receipt.request_id, { json: true }),
+    ).toBe(EXIT.ok)
+    expect(JSON.parse(io.outLines[0] ?? '{}')).toMatchObject({
+      agent_acknowledgement_required: true,
+      agent_acknowledgement: acknowledgement,
+      acknowledgement_command: null,
+    })
+  })
+
+  it('close exposes the acknowledgement requirement and exact follow-up command', async () => {
+    const io = new CapturedIo()
+    const client = {
+      closeReplies: async () => replyResponse([reply]),
+    } as unknown as ApiClient
+
+    expect(await closeCommand(makeDeps(io, client), receipt.request_id, { json: true })).toBe(
+      EXIT.ok,
+    )
+    expect(JSON.parse(io.outLines[0] ?? '{}')).toMatchObject({
+      request_id: receipt.request_id,
+      agent_acknowledgement_required: true,
+      agent_acknowledgement: null,
+      acknowledgement_command: `notifai acknowledge ${receipt.request_id} --text <text>`,
+    })
+  })
+
   it('passes the replies cursor and prints replies for later retrieval', async () => {
     const io = new CapturedIo()
     let requested: { waitSeconds: number; afterSeq: number } | undefined
@@ -820,7 +1092,11 @@ describe('command contracts', () => {
 
     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(io.outLines).toEqual([
+      'reply from iPhone: yes, after the migration',
+      'Agent Acknowledgement required.',
+      `next: Run \`notifai acknowledge ${receipt.request_id} --text <text>\` with concrete text saying what you will do because of the reply.`,
+    ])
     expect(readLogRecords(deps.env, { event: ['reply.received'] }).records).toHaveLength(1)
   })
 
@@ -845,6 +1121,8 @@ describe('command contracts', () => {
     expect(io.outLines).toEqual([
       `pending request ${receipt.request_id}`,
       'reply from iPhone: yes, after the migration',
+      'Agent Acknowledgement required.',
+      `next: Run \`notifai acknowledge ${receipt.request_id} --text <text>\` with concrete text saying what you will do because of the reply.`,
     ])
   })
 
@@ -1225,6 +1503,7 @@ describe('Cursor hook commands', () => {
         XDG_STATE_HOME: path.join(cwd, 'state'),
         CODEX_HOME: path.join(cwd, 'codex'),
         CLAUDE_CONFIG_DIR: path.join(cwd, 'claude'),
+        OPENCODE_CONFIG_DIR: path.join(cwd, 'opencode'),
       },
       store: { load: () => null, save: () => {}, clear: () => {}, describe: () => 'empty store' },
     }
@@ -1303,7 +1582,7 @@ describe('Codex hook representation', () => {
     expect(io.outLines.join('\n')).toMatch(/Stop and the existing one will both fire/i)
   })
 
-  it('collapses a leftover hooks.json onto inline [hooks] and says both Stops will run', async () => {
+  it('preserves a foreign inline Stop while collapsing our duplicate definition', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-collapse-'))
     const toml = writeInlineStop(cwd, 'gdh-stop')
     const json = path.join(cwd, '.codex', 'hooks.json')
@@ -1485,7 +1764,11 @@ describe('harness activation guidance', () => {
     const deps = {
       ...makeDeps(io, {} as ApiClient),
       cwd,
-      env: { XDG_STATE_HOME: path.join(cwd, 'state') },
+      env: {
+        HOME: path.join(cwd, 'home'),
+        XDG_STATE_HOME: path.join(cwd, 'state'),
+        OPENCODE_CONFIG_DIR: path.join(cwd, 'opencode-home'),
+      },
     }
 
     expect(hooksInstallCommand(deps, { harness: 'opencode', execPath, scriptPath })).toBe(
@@ -2120,6 +2403,7 @@ describe('init', () => {
     platform: 'ios' as const,
     permission_status: 'authorized',
     registration_healthy: true,
+    reply_protocol_version: 2,
     last_seen_at: '2026-08-05T18:00:00.000Z',
   }
 
@@ -2492,8 +2776,8 @@ describe('init', () => {
     )
     expect(wired).toEqual(['claude-code', 'codex'])
     expect(existsSync(path.join(cwd, '.claude', 'settings.local.json'))).toBe(true)
-    expect(existsSync(path.join(cwd, '.codex', 'config.toml'))).toBe(true)
-    expect(existsSync(path.join(cwd, '.codex', 'hooks.json'))).toBe(false)
+    expect(existsSync(path.join(cwd, '.codex', 'hooks.json'))).toBe(true)
+    expect(existsSync(path.join(cwd, '.codex', 'config.toml'))).toBe(false)
     expect(io.outLines.join('\n')).toContain('Installed claude-code hooks')
     expect(io.outLines.join('\n')).toContain('Installed codex hooks')
   })
@@ -2664,6 +2948,7 @@ describe('init', () => {
         XDG_STATE_HOME: path.join(cwd, 'state'),
         CODEX_HOME: path.join(cwd, 'codex'),
         CLAUDE_CONFIG_DIR: path.join(cwd, 'claude'),
+        OPENCODE_CONFIG_DIR: path.join(cwd, 'opencode'),
       },
     }
 
@@ -2753,6 +3038,9 @@ describe('init', () => {
     expect(io.notes.some((n) => n.message.includes('I will wait up to 10 minutes'))).toBe(true)
     expect(io.spinnerEvents).toContain('stop:iPhone is ready to receive')
     expect(io.spinnerEvents).toContain('stop:Receipt observed from iPhone')
+    expect(io.outLines.join('\n')).toContain(
+      "Companion Receipt (the app's delivery confirmation) observed from iPhone.",
+    )
     expect(io.outLines.join('\n')).toContain('All set.')
     expect(submitCalls).toBe(1)
     expect(submittedDraft?.draft.event).toBe('setup_verified')
@@ -2895,6 +3183,8 @@ describe('init', () => {
     expect(io.outLines.join('\n')).toContain('Next: Delivery proof')
     expect(io.outLines.join('\n')).toContain('Provider accepted the notification')
     expect(io.outLines.join('\n')).toContain('Proof may still arrive')
+    const proofDir = path.join(stateDir(deps.env), 'setup-proofs')
+    expect(readdirSync(proofDir).some((name) => name.endsWith('.json'))).toBe(true)
 
     io.outLines = []
     io.errLines = []
@@ -3304,6 +3594,27 @@ describe('an outage is not an answer', () => {
 describe('asking before the hooks have ever run', () => {
   const execPath = process.execPath
   const scriptPath = fileURLToPath(import.meta.url)
+  const scratch: string[] = []
+
+  function scratchDir(prefix: string): string {
+    const dir = mkdtempSync(path.join(os.tmpdir(), prefix))
+    scratch.push(dir)
+    return dir
+  }
+
+  afterEach(() => {
+    while (scratch.length > 0) {
+      rmSync(scratch.pop()!, { recursive: true, force: true })
+    }
+  })
+
+  it('refuses to write Codex trust outside the isolated test account', () => {
+    expect(() => trustInstalledCodexHooks(os.tmpdir(), {})).toThrow(/requires env.HOME/)
+    expect(() => trustInstalledCodexHooks(os.tmpdir(), { HOME: path.dirname(os.tmpdir()) })).toThrow(
+      /will only write under/,
+    )
+    expect(os.homedir()).toBe(process.env['NOTIFAI_TEST_HOME'])
+  })
 
   it('names the active Codex harness instead of unrelated installed adapters', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-codex-missing-'))
@@ -3311,6 +3622,7 @@ describe('asking before the hooks have ever run', () => {
     const env = {
       XDG_CONFIG_HOME: path.join(cwd, 'config'),
       XDG_STATE_HOME: path.join(cwd, 'state'),
+      HOME: path.join(cwd, 'home'),
       CODEX_HOME: path.join(cwd, 'codex-home'),
       CODEX_THREAD_ID: 'codex-current-thread',
       CLAUDE_CONFIG_DIR: path.join(cwd, 'claude-home'),
@@ -3335,6 +3647,7 @@ describe('asking before the hooks have ever run', () => {
     const env = {
       XDG_CONFIG_HOME: path.join(cwd, 'config'),
       XDG_STATE_HOME: path.join(cwd, 'state'),
+      HOME: path.join(cwd, 'home'),
       CODEX_HOME: path.join(cwd, 'codex-home'),
       CODEX_THREAD_ID: 'codex-current-thread',
     }
@@ -3353,11 +3666,12 @@ describe('asking before the hooks have ever run', () => {
   })
 
   it('registers only when the active Codex thread owns the project pointer', () => {
-    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-codex-matching-'))
+    const cwd = scratchDir('notifai-active-codex-matching-')
     const io = new CapturedIo()
     const env = {
       XDG_CONFIG_HOME: path.join(cwd, 'config'),
       XDG_STATE_HOME: path.join(cwd, 'state'),
+      HOME: path.join(cwd, 'home'),
       CODEX_HOME: path.join(cwd, 'codex-home'),
       CODEX_THREAD_ID: 'codex-current-thread',
     }
@@ -3497,11 +3811,12 @@ describe('asking before the hooks have ever run', () => {
   })
 
   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 cwd = scratchDir('notifai-ask-commitment-')
     const io = new CapturedIo()
     const env = {
       XDG_CONFIG_HOME: path.join(cwd, 'config'),
       XDG_STATE_HOME: path.join(cwd, 'state'),
+      HOME: path.join(cwd, 'home'),
       CODEX_HOME: path.join(cwd, 'codex-home'),
       CODEX_THREAD_ID: 'codex-commitment-thread',
     }
@@ -3532,11 +3847,12 @@ describe('asking before the hooks have ever run', () => {
   })
 
   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 cwd = scratchDir('notifai-ask-free-text-')
     const io = new CapturedIo()
     const env = {
       XDG_CONFIG_HOME: path.join(cwd, 'config'),
       XDG_STATE_HOME: path.join(cwd, 'state'),
+      HOME: path.join(cwd, 'home'),
       CODEX_HOME: path.join(cwd, 'codex-home'),
       CODEX_THREAD_ID: 'codex-free-text-thread',
     }
@@ -3555,11 +3871,12 @@ 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 cwd = scratchDir('notifai-codex-stale-trust-')
     const io = new CapturedIo()
     const env = {
       XDG_CONFIG_HOME: path.join(cwd, 'config'),
       XDG_STATE_HOME: path.join(cwd, 'state'),
+      HOME: path.join(cwd, 'home'),
       CODEX_HOME: path.join(cwd, 'codex-home'),
       CODEX_THREAD_ID: 'codex-current-thread',
     }
@@ -3570,7 +3887,7 @@ describe('asking before the hooks have ever run', () => {
       .find((installation) => installation.harness === 'codex')
       ?.handlers.find((handler) => handler.event === 'Stop')
     expect(stop).toBeDefined()
-    const configFile = path.join(env.CODEX_HOME, 'config.toml')
+    const configFile = path.join(env.CODEX_HOME!, 'config.toml')
     writeFileSync(
       configFile,
       readFileSync(configFile, 'utf8').replace(codexHookIdentityHash(stop!), 'sha256:obsolete'),
@@ -3594,6 +3911,7 @@ describe('asking before the hooks have ever run', () => {
     const env = {
       XDG_CONFIG_HOME: path.join(cwd, 'config'),
       XDG_STATE_HOME: path.join(cwd, 'state'),
+      HOME: path.join(cwd, 'home'),
       CODEX_HOME: path.join(cwd, 'codex-home'),
       CODEX_THREAD_ID: 'codex-current-thread',
       CLAUDE_CONFIG_DIR: path.join(cwd, 'claude-home'),
@@ -3702,7 +4020,7 @@ describe('asking before the hooks have ever run', () => {
   })
 
   it('rejects duplicate active Codex definitions before registration', () => {
-    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-codex-duplicate-'))
+    const cwd = scratchDir('notifai-active-codex-duplicate-')
     const io = new CapturedIo()
     const env = {
       HOME: path.join(cwd, 'home'),
@@ -3713,7 +4031,8 @@ 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)
-    applyPlan(path.join(env.CODEX_HOME, 'config.toml'), {
+    mkdirSync(env.CODEX_HOME!, { recursive: true })
+    applyPlan(path.join(env.CODEX_HOME!, 'config.toml'), {
       hooks: buildHookConfig({
         adapterPath: hookAdapterPath(deps.hookAdapterHome),
         harness: 'codex',
@@ -3822,6 +4141,7 @@ describe('asking before the hooks have ever run', () => {
     const env = {
       XDG_CONFIG_HOME: path.join(cwd, 'config'),
       XDG_STATE_HOME: path.join(cwd, 'state'),
+      HOME: path.join(cwd, 'home'),
       CODEX_HOME: path.join(cwd, 'codex-home'),
       CLAUDE_CONFIG_DIR: path.join(cwd, 'claude-home'),
       CLAUDECODE: '1',
@@ -3844,6 +4164,7 @@ describe('asking before the hooks have ever run', () => {
       XDG_CONFIG_HOME: path.join(cwd, 'config'),
       XDG_STATE_HOME: path.join(cwd, 'state'),
       CLAUDE_CONFIG_DIR: path.join(cwd, 'claude-home'),
+      HOME: path.join(cwd, 'home'),
       CODEX_HOME: path.join(cwd, 'codex-home'),
       CLAUDECODE: '1',
       CLAUDE_CODE_SESSION_ID: 'claude-current',
@@ -4026,7 +4347,12 @@ describe('asking before the hooks have ever run', () => {
       ...isolatedEnv(cwd),
       CODEX_THREAD_ID: '9f1c2b3a-4d5e-6f70-8192-a3b4c5d6e7f8',
     }
-    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env }
+    const deps = {
+      ...makeDeps(io, {} as ApiClient),
+      cwd,
+      env,
+      hookPlatform: 'darwin' as NodeJS.Platform,
+    }
     expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
 
     io.outLines = []
@@ -4037,14 +4363,8 @@ describe('asking before the hooks have ever run', () => {
     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')
-    }
+    expect(out).toMatch(/ok\s+hooks \(wake route\)/)
+    expect(out).toContain('can prove a stopped thread unowned before resuming it')
   })
 
   it('documents the failing exit contract in doctor JSON', async () => {
@@ -4123,6 +4443,7 @@ describe('asking before the hooks have ever run', () => {
         XDG_STATE_HOME: cwd,
         CODEX_HOME: path.join(cwd, 'none'),
         CLAUDE_CONFIG_DIR: path.join(cwd, 'none'),
+        OPENCODE_CONFIG_DIR: path.join(cwd, 'none'),
       },
     }