@raidiant/notifai 0.5.1 → 1.0.1

package/src/commands.test.ts

@@ -50,8 +50,8 @@ import {
   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 { nativeSkills as realNativeSkills, type NativeSkill, type NativeSkills, type SkillScope } from './native-skills.js'
+import { CONFIG_KEYS, loadConfig, personalProjectConfigPath } from './config.js'
 import { createLogger, logsDiskUsage, readLogRecords } from './logging.js'
 import { hookAdapterPath, inspectHookAdapter } from './hook-adapter.js'
 import type { Tone } from './ui/theme.js'
@@ -123,6 +123,17 @@ class InteractiveIo extends CapturedIo {
     return this.selectAnswer
   }
 
+  multiselectAnswer: string[] | null = null
+
+  async multiselect(
+    message: string,
+    _options: { value: string; label: string; hint?: string }[],
+    _initial?: string[],
+  ): Promise<string[] | null> {
+    this.prompts.push(message)
+    return this.multiselectAnswer
+  }
+
   async intro(title: string) {
     this.intros.push(title)
   }
@@ -161,7 +172,11 @@ function trustInstalledCodexHooks(cwd: string, env: NodeJS.ProcessEnv): void {
   )
   const codexHome = env['CODEX_HOME'] as string
   mkdirSync(codexHome, { recursive: true })
-  writeFileSync(path.join(codexHome, 'config.toml'), sections.join('\n'))
+  const file = path.join(codexHome, 'config.toml')
+  // 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() : ''
+  writeFileSync(file, [existing, ...sections].filter((block) => block.length > 0).join('\n') + '\n')
 }
 
 function makeDeps(io: CapturedIo, client: ApiClient): CommandDeps {
@@ -403,7 +418,9 @@ describe('command contracts', () => {
     expect(source).not.toContain(".option('--badge")
     expect(source).not.toContain(".option('--relevance")
     expect(source).not.toContain(".option('--target-content-id")
-    expect(source).toContain('Kind profiles')
+    expect(source).toContain('Kind profiles apply automatically')
+    expect(source).toContain('Pass --sound or --level only to override')
+    expect(source).toContain('override kind profile / saved config')
   })
 
   it('rejects a question nobody will wait for', async () => {
@@ -1165,7 +1182,7 @@ describe('Cursor hook commands', () => {
   it('installs native Cursor hooks with bounded chained answer continuations', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-cursor-install-'))
     const io = new CapturedIo()
-    const deps = { ...makeDeps(io, {} as ApiClient), cwd }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
 
     expect(
       hooksInstallCommand(deps, { harness: 'cursor', execPath, scriptPath }),
@@ -1227,7 +1244,7 @@ describe('Cursor hook commands', () => {
   it('uninstalls only Notifai Cursor hooks and preserves foreign hooks', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-cursor-uninstall-'))
     const io = new CapturedIo()
-    const deps = { ...makeDeps(io, {} as ApiClient), cwd }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
     expect(
       hooksInstallCommand(deps, { harness: 'cursor', execPath, scriptPath }),
     ).toBe(EXIT.ok)
@@ -1253,6 +1270,86 @@ describe('Cursor hook commands', () => {
   })
 })
 
+describe('Codex hook representation', () => {
+  const execPath = process.execPath
+  const scriptPath = fileURLToPath(import.meta.url)
+
+  function writeInlineStop(repo: string, command: string): string {
+    const file = path.join(repo, '.codex', 'config.toml')
+    mkdirSync(path.dirname(file), { recursive: true })
+    writeFileSync(
+      file,
+      ['[[hooks.Stop]]', '', '[[hooks.Stop.hooks]]', 'type = "command"', `command = "${command}"`, ''].join(
+        '\n',
+      ),
+    )
+    return file
+  }
+
+  it('installs into existing inline [hooks] and does not create hooks.json', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-inline-install-'))
+    const toml = writeInlineStop(cwd, 'gdh-stop')
+    const io = new CapturedIo()
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
+
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+
+    expect(existsSync(path.join(cwd, '.codex', 'hooks.json'))).toBe(false)
+    const text = readFileSync(toml, 'utf8')
+    expect(text).toContain('gdh-stop')
+    expect(text).toContain('--owner notifai')
+    expect(text).toContain('[[hooks.UserPromptSubmit]]')
+    expect(io.outLines.join('\n')).toContain(toml)
+    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 () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-collapse-'))
+    const toml = writeInlineStop(cwd, 'gdh-stop')
+    const json = path.join(cwd, '.codex', 'hooks.json')
+    const env = isolatedEnv(cwd)
+    const io = new CapturedIo()
+    const client = {
+      health: async () => false,
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+      listDevices: async () => ({ devices: [] }),
+    } as unknown as ApiClient
+    const deps = { ...makeDeps(io, client), cwd, env }
+
+    applyPlan(json, {
+      hooks: buildHookConfig({
+        adapterPath: hookAdapterPath(deps.hookAdapterHome),
+        harness: 'codex',
+      }),
+    })
+
+    io.outLines = []
+    expect(await doctorCommand(deps, {})).toBe(EXIT.failed)
+    const before = io.outLines.join('\n')
+    expect(before).toMatch(/hooks \(codex representation\)/)
+    expect(before).toMatch(/prefer a single representation/)
+    expect(before).toMatch(/Stop handlers will both (run|fire)/i)
+    expect(before).toContain('notifai hooks install --harness codex')
+
+    io.outLines = []
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    expect(existsSync(json)).toBe(false)
+    expect(readFileSync(toml, 'utf8')).toContain('gdh-stop')
+    expect(readFileSync(toml, 'utf8')).toContain('--owner notifai')
+    expect(io.outLines.join('\n')).toMatch(/collaps/i)
+
+    const installations = findInstallations(cwd, env, deps.hookAdapterHome).filter(
+      (installation) => installation.harness === 'codex',
+    )
+    expect(installations).toHaveLength(1)
+    expect(installations[0]?.file).toBe(toml)
+
+    expect(hooksUninstallCommand(deps, { harness: 'codex', scriptPath })).toBe(EXIT.ok)
+    expect(readFileSync(toml, 'utf8')).toContain('gdh-stop')
+    expect(readFileSync(toml, 'utf8')).not.toContain('--owner notifai')
+  })
+})
+
 describe('harness activation guidance', () => {
   const execPath = process.execPath
   const scriptPath = fileURLToPath(import.meta.url)
@@ -1260,21 +1357,22 @@ describe('harness activation guidance', () => {
   it('does not require a Claude Code restart for project hook files', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-claude-activation-'))
     const io = new CapturedIo()
-    const deps = { ...makeDeps(io, {} as ApiClient), cwd }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
 
     expect(
       hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath }),
     ).toBe(EXIT.ok)
 
-    expect(io.outLines.join('\n')).toContain(
-      'Claude Code reloads project hook files without a restart.',
-    )
+    const output = io.outLines.join('\n')
+    expect(output).toContain('Installed claude-code hooks in')
+    expect(output).toContain('Send one Claude Code prompt, then check `notifai doctor`.')
+    expect(output).not.toMatch(/timeout|asynchronous|600s/i)
   })
 
   it('does not invent a Codex hook trust gate', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-activation-'))
     const io = new CapturedIo()
-    const deps = { ...makeDeps(io, {} as ApiClient), cwd }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
 
     expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(
       EXIT.ok,
@@ -1285,6 +1383,52 @@ describe('harness activation guidance', () => {
     expect(output).not.toMatch(/trust|approve/i)
   })
 
+  it('names the installed harness in the close, never a different one', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-cursor-close-'))
+    const io = new CapturedIo()
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
+
+    expect(hooksInstallCommand(deps, { harness: 'cursor', execPath, scriptPath })).toBe(EXIT.ok)
+
+    const output = io.outLines.join('\n')
+    expect(output).toContain('Installed cursor hooks in')
+    expect(output).toContain('Send one Cursor prompt, then check `notifai doctor`.')
+    expect(output).not.toMatch(/Codex|Claude Code|OpenCode/)
+    expect(output).not.toMatch(/timeout|worktree|fails closed/i)
+  })
+
+  it('pins hooks to npx when that is how this CLI is running', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-npx-hooks-'))
+    const npmCli = path.join(cwd, 'npm-cli.js')
+    writeFileSync(npmCli, '')
+    const io = new CapturedIo()
+    const deps = {
+      ...makeDeps(io, {} as ApiClient),
+      cwd,
+      env: {
+        npm_command: 'exec',
+        npm_execpath: npmCli,
+        HOME: path.join(cwd, 'home'),
+        XDG_CONFIG_HOME: path.join(cwd, 'config'),
+        XDG_STATE_HOME: path.join(cwd, 'state'),
+      },
+    }
+
+    expect(
+      hooksInstallCommand(deps, {
+        harness: 'claude-code',
+        execPath: process.execPath,
+        scriptPath: path.join(cwd, '_npx', 'hash', 'node_modules', '@raidiant', 'notifai', 'dist', 'main.js'),
+      }),
+    ).toBe(EXIT.ok)
+
+    const inspected = inspectHookAdapter(deps.hookAdapterHome)
+    expect(inspected.problems).toEqual([])
+    expect(inspected.target && 'spec' in inspected.target ? inspected.target.spec : null).toMatch(
+      /^@raidiant\/notifai@/,
+    )
+  })
+
   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()
@@ -1310,8 +1454,9 @@ describe('harness activation guidance', () => {
       EXIT.ok,
     )
 
-    expect(io.outLines.join('\n')).toContain('Permission prompts stay in OpenCode.')
-    expect(io.outLines.join('\n')).toContain('does not expose a proven exactly-once continuation')
+    expect(io.outLines.join('\n')).toContain('Installed opencode hooks in')
+    expect(io.outLines.join('\n')).toContain('Send one OpenCode prompt, then check `notifai doctor`.')
+    expect(io.outLines.join('\n')).not.toMatch(/Permission prompts|exactly-once continuation/)
     const pluginFile = path.join(cwd, '.opencode', 'plugins', 'notifai.js')
     const plugin = readFileSync(pluginFile, 'utf8')
     expect(plugin).toContain('const TIMEOUT_MS = 540000')
@@ -1416,10 +1561,11 @@ describe('stable hook installation', () => {
     ).toBe(EXIT.ok)
     const global = readFileSync(path.join(env.CLAUDE_CONFIG_DIR, 'settings.json'), 'utf8')
     expect(global).toBe(firstDefinition)
+    expect(readFileSync(local, 'utf8')).not.toContain('--owner notifai')
 
     io.outLines = []
     await doctorCommand(deps, {})
-    expect(io.outLines.join('\n')).toMatch(/hooks \(duplicates\).*project or global routing/is)
+    expect(io.outLines.join('\n')).not.toMatch(/hooks \(duplicates\)/)
 
     expect(hooksUninstallCommand(deps, { harness: 'claude-code' })).toBe(EXIT.ok)
     expect(existsSync(hookAdapterPath(deps.hookAdapterHome))).toBe(true)
@@ -1429,6 +1575,27 @@ describe('stable hook installation', () => {
       ),
     ).toHaveLength(1)
   })
+
+  it('does not add a project copy when global hooks already cover the machine', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-hooks-global-enough-'))
+    const io = new CapturedIo()
+    const env = isolatedEnv(cwd)
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env }
+    const execPath = process.execPath
+    const scriptPath = fileURLToPath(import.meta.url)
+
+    expect(hooksInstallCommand(deps, { harness: 'codex', global: true, execPath, scriptPath })).toBe(
+      EXIT.ok,
+    )
+    io.outLines = []
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    expect(existsSync(path.join(cwd, '.codex', 'config.toml'))).toBe(false)
+    expect(io.outLines.join('\n')).toMatch(/already cover this machine/)
+    expect(io.outLines.join('\n')).toMatch(/uninstall --harness codex --global/)
+    expect(
+      findInstallations(cwd, env, deps.hookAdapterHome).filter((item) => item.harness === 'codex'),
+    ).toEqual([expect.objectContaining({ global: true })])
+  })
 })
 
 describe('projectSlugFrom', () => {
@@ -1602,10 +1769,36 @@ describe('config surfaces', () => {
     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 = "/)
+    expect(io.outLines[0]).toMatch(/^wait_seconds = /)
     for (const line of io.outLines) expect(line).toMatch(/^[a-z_]+ = /)
   })
 
+  it('gives agents the current value, source, and one-line meaning', () => {
+    const io = new CapturedIo()
+    expect(configShowCommand(configDeps(io), { json: true })).toBe(EXIT.ok)
+    const parsed = JSON.parse(io.outLines.join('\n')) as Record<
+      string,
+      { value: unknown; source: string; summary: string }
+    >
+    expect(parsed['base_url']).toBeUndefined()
+    expect(parsed['ttl_seconds']).toEqual({
+      value: 86400,
+      source: 'default',
+      summary: expect.stringContaining('deliver'),
+    })
+    expect(parsed['ask_grace_seconds']?.value).toBe(0)
+    expect(parsed['ask_grace_seconds']?.summary).toBeTruthy()
+    expect(Object.keys(parsed).sort()).toEqual([...CONFIG_KEYS].sort())
+  })
+
+  it('refuses to treat the service origin as a setting', async () => {
+    const io = new CapturedIo()
+    expect(await configSetCommand(configDeps(io), 'base_url', 'https://attacker.example', { yes: true })).toBe(
+      EXIT.usage,
+    )
+    expect(io.errLines[0]).toBe('Unknown setting "base_url".')
+  })
+
   it('explains each setting once a human is at the terminal', () => {
     const io = new InteractiveIo()
     expect(configShowCommand(configDeps(io), {})).toBe(EXIT.ok)
@@ -1787,11 +1980,11 @@ describe('interactive command UX', () => {
     }
 
     expect(await configSetCommand(deps, 'sound', 'done', {})).toBe(EXIT.ok)
+    const localFile = personalProjectConfigPath(cwd, deps.env)
     expect(io.prompts[0]).toBe('Where should this setting live?')
-    expect(io.prompts[1]).toContain(path.join(cwd, '.notifai', 'config.local.toml'))
-    expect(readFileSync(path.join(cwd, '.notifai', 'config.local.toml'), 'utf8')).toContain(
-      'sound = "done"',
-    )
+    expect(io.prompts[1]).toContain(localFile)
+    expect(readFileSync(localFile, 'utf8')).toContain('sound = "done"')
+    expect(existsSync(path.join(cwd, '.notifai', 'config.local.toml'))).toBe(false)
   })
 
   it('bypasses interactive config selection with --yes and uses the global default', async () => {
@@ -1814,13 +2007,14 @@ describe('interactive command UX', () => {
     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')
+    const env = { XDG_CONFIG_HOME: path.join(cwd, 'xdg') }
+    const localFile = personalProjectConfigPath(cwd, env)
     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') },
+      env,
     }
 
     expect(await configUnsetCommand(deps, 'sound', {})).toBe(EXIT.ok)
@@ -2020,13 +2214,21 @@ describe('init', () => {
       cwd,
       env: isolatedEnv(cwd),
       nativeSkills,
+      hookInstallTarget: {
+        execPath: process.execPath,
+        scriptPath: fileURLToPath(import.meta.url),
+      },
     }
   }
 
   it('writes the project identifier into .notifai/config.toml and is idempotent', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'My Project-'))
     const io = new CapturedIo()
-    const deps = { ...makeDeps(io, {} as ApiClient), cwd }
+    const deps: CommandDeps = {
+      ...makeDeps(io, {} as ApiClient),
+      cwd,
+      store: { load: () => null, save: () => {}, clear: () => {}, describe: () => 'empty store' },
+    }
 
     expect(await initCommand(deps, {})).toBe(EXIT.failed)
     const configPath = path.join(cwd, '.notifai', 'config.toml')
@@ -2038,9 +2240,10 @@ describe('init', () => {
 
     io.outLines = []
     expect(await initCommand(deps, { skills: false })).toBe(EXIT.failed)
-    // Idempotent: the second run re-derives the same slug and says so as a
-    // settled state rather than repeating the write.
-    expect(io.outLines.join('\n')).toContain('Project identity: "my-project-')
+    // Idempotent: the second run re-derives the same slug and does not reprint
+    // doctor's ready-state dump.
+    expect(io.outLines.join('\n')).toMatch(/^Next:/m)
+    expect(io.outLines.join('\n')).not.toContain('Project identity:')
     expect(readFileSync(configPath, 'utf8')).toContain('project = "my-project-')
   })
 
@@ -2272,6 +2475,49 @@ describe('init', () => {
     expect(io.outLines.join('\n')).toContain('All set.')
   })
 
+  it('installs every detected project harness when --hooks is set', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-hooks-all-detected-'))
+    mkdirSync(path.join(cwd, '.claude'))
+    mkdirSync(path.join(cwd, '.codex'))
+    const io = new CapturedIo()
+    const calls = { submit: 0 }
+    const nativeSkills: NativeSkills = {
+      add: async () => 0,
+      list: async () => ({ skills: [] }),
+    }
+    const deps = setupReadyDeps(io, cwd, nativeSkills, calls)
+    await initCommand(deps, { hooks: true, skills: false })
+    const wired = findInstallations(cwd, deps.env, deps.hookAdapterHome).map(
+      (installation) => installation.harness,
+    )
+    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(io.outLines.join('\n')).toContain('Installed claude-code hooks')
+    expect(io.outLines.join('\n')).toContain('Installed codex hooks')
+  })
+
+  it('lets a human keep a subset of the detected harnesses', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-hooks-pick-'))
+    mkdirSync(path.join(cwd, '.claude'))
+    mkdirSync(path.join(cwd, '.codex'))
+    const io = new InteractiveIo()
+    io.multiselectAnswer = ['claude-code']
+    const calls = { submit: 0 }
+    const nativeSkills: NativeSkills = {
+      add: async () => 0,
+      list: async () => ({ skills: [] }),
+    }
+    const deps = setupReadyDeps(io, cwd, nativeSkills, calls)
+    expect(await initCommand(deps, { skills: false })).toBe(EXIT.ok)
+    expect(io.prompts.some((prompt) => prompt.includes('Which agent harnesses'))).toBe(true)
+    const wired = findInstallations(cwd, deps.env, deps.hookAdapterHome).map(
+      (installation) => installation.harness,
+    )
+    expect(wired).toEqual(['claude-code'])
+  })
+
   it('reports an optional native installer failure without blocking remaining setup', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-skill-failed-'))
     const io = new InteractiveIo()
@@ -2413,6 +2659,7 @@ describe('init', () => {
       ...makeDeps(io, client),
       cwd,
       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'),
@@ -2506,9 +2753,6 @@ 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')
@@ -2664,9 +2908,7 @@ describe('init', () => {
     expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.ok)
     expect(submitCalls).toBe(2)
     expect(io.outLines.join('\n')).toContain('saved proof had expired; sent replacement req_replacement')
-    expect(io.outLines.join('\n')).toContain(
-      "Companion Receipt (the app's delivery confirmation) observed from iPhone",
-    )
+    expect(io.outLines.join('\n')).toContain('All set.')
   })
 
   it('reports a proof-state write failure instead of crashing or sending twice', async () => {
@@ -2837,6 +3079,126 @@ describe('init', () => {
   })
 })
 
+describe('readiness assessment cost', () => {
+  it('does not re-probe the service after init closes a local-only gap', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-local-reassess-'))
+    const io = new CapturedIo()
+    let healthCalls = 0
+    const client = {
+      health: async () => {
+        healthCalls += 1
+        return true
+      },
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+    } as unknown as ApiClient
+    const deps: CommandDeps = {
+      ...makeDeps(io, client),
+      cwd,
+      env: isolatedEnv(cwd),
+      store: { load: () => null, save: () => {}, clear: () => {}, describe: () => 'empty store' },
+    }
+
+    expect(await initCommand(deps, {})).toBe(EXIT.failed)
+    expect(healthCalls).toBe(1)
+    expect(readFileSync(path.join(cwd, '.notifai', 'config.toml'), 'utf8')).toContain('project =')
+  })
+
+  it('reuses remote probes when only local state could have changed', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'assess-local-only-'))
+    const io = new CapturedIo()
+    let healthCalls = 0
+    let deviceCalls = 0
+    let evidenceCalls = 0
+    const client = {
+      health: async () => {
+        healthCalls += 1
+        return true
+      },
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+      listDevices: async () => {
+        deviceCalls += 1
+        return { devices: [] }
+      },
+      accessStatus: async () => ({ email: 'user@example.com' }),
+      evidence: async () => {
+        evidenceCalls += 1
+        throw new Error('unused')
+      },
+    } as unknown as ApiClient
+    const deps = { ...makeDeps(io, client), cwd, env: isolatedEnv(cwd) }
+
+    const previous = await assessReadiness(deps)
+    expect(healthCalls).toBe(1)
+    expect(deviceCalls).toBe(1)
+
+    const next = await assessReadiness(deps, { previous, refresh: ['local'] })
+    expect(healthCalls).toBe(1)
+    expect(deviceCalls).toBe(1)
+    expect(evidenceCalls).toBe(0)
+    expect(next.states.find((state) => state.id === 'server')).toEqual(
+      previous.states.find((state) => state.id === 'server'),
+    )
+  })
+
+  it('renders a supplied doctor report without probing again', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'doctor-reuse-'))
+    const io = new CapturedIo()
+    let healthCalls = 0
+    const client = {
+      health: async () => {
+        healthCalls += 1
+        return true
+      },
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+    } as unknown as ApiClient
+    const deps: CommandDeps = {
+      ...makeDeps(io, client),
+      cwd,
+      env: isolatedEnv(cwd),
+      store: { load: () => null, save: () => {}, clear: () => {}, describe: () => 'empty store' },
+    }
+
+    const readiness = await assessReadiness(deps)
+    expect(healthCalls).toBe(1)
+    expect(await doctorCommand(deps, { json: true }, { readiness })).toBe(EXIT.failed)
+    expect(healthCalls).toBe(1)
+    expect(JSON.parse(io.outLines[0] ?? '{}')).toHaveProperty('states')
+  })
+
+  it('treats a lock-file pin as installed without asking npx', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'assess-lock-skill-'))
+    writeFileSync(
+      path.join(cwd, 'skills-lock.json'),
+      `${JSON.stringify({
+        skills: {
+          notifai: {
+            source: 'Raidiant-io/notifai',
+            sourceType: 'github',
+            ref: RELEASE_REF,
+          },
+        },
+      })}\n`,
+    )
+    const io = new CapturedIo()
+    const client = {
+      health: async () => true,
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+      listDevices: async () => ({ devices: [] }),
+    } as unknown as ApiClient
+
+    const readiness = await assessReadiness({
+      ...makeDeps(io, client),
+      cwd,
+      env: { ...isolatedEnv(cwd), PATH: '/nonexistent' },
+      nativeSkills: realNativeSkills,
+    })
+    expect(readiness.states.find((state) => state.id === 'skill')).toMatchObject({
+      status: 'ready',
+      detail: `installed from ${SKILLS_SOURCE} in the project scope`,
+    })
+  })
+})
+
 describe('an outage is not an answer', () => {
   /**
    * The dangerous shape: the first poll succeeds, then connectivity drops and
@@ -3351,9 +3713,12 @@ 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)
-    expect(
-      hooksInstallCommand(deps, { harness: 'codex', global: true, execPath, scriptPath }),
-    ).toBe(EXIT.ok)
+    applyPlan(path.join(env.CODEX_HOME, 'config.toml'), {
+      hooks: buildHookConfig({
+        adapterPath: hookAdapterPath(deps.hookAdapterHome),
+        harness: 'codex',
+      }),
+    })
     trustInstalledCodexHooks(cwd, env)
     writeSessionState('codex-current-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'codex-current-thread', 42, 'codex')
@@ -3507,13 +3872,12 @@ describe('asking before the hooks have ever run', () => {
 
   it('shows resolved question-routing values with their winning config sources', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-doctor-routing-config-'))
-    mkdirSync(path.join(cwd, '.notifai'), { recursive: true })
-    writeFileSync(
-      path.join(cwd, '.notifai', 'config.local.toml'),
-      'ask_notifications = false\nask_grace_seconds = 90\n',
-    )
+    const env = { XDG_CONFIG_HOME: path.join(cwd, 'xdg') }
+    const localFile = personalProjectConfigPath(cwd, env)
+    mkdirSync(path.dirname(localFile), { recursive: true })
+    writeFileSync(localFile, 'ask_notifications = false\nask_grace_seconds = 90\n')
     const io = new CapturedIo()
-    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: {} }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env }
 
     await doctorCommand(deps, {})
 
@@ -3717,7 +4081,7 @@ describe('asking before the hooks have ever run', () => {
     const deps = {
       ...makeDeps(io, {} as ApiClient),
       cwd,
-      env: { XDG_STATE_HOME: path.join(cwd, 'state') },
+      env: isolatedEnv(cwd),
     }
 
     expect(hooksInstallCommand(deps, { harness: 'cursor', execPath, scriptPath })).toBe(EXIT.ok)
@@ -3754,7 +4118,12 @@ describe('asking before the hooks have ever run', () => {
     const deps = {
       ...makeDeps(io, {} as ApiClient),
       cwd,
-      env: { XDG_STATE_HOME: cwd, CODEX_HOME: path.join(cwd, 'none'), CLAUDE_CONFIG_DIR: path.join(cwd, 'none') },
+      env: {
+        HOME: path.join(cwd, 'home'),
+        XDG_STATE_HOME: cwd,
+        CODEX_HOME: path.join(cwd, 'none'),
+        CLAUDE_CONFIG_DIR: path.join(cwd, 'none'),
+      },
     }
 
     expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)