@raidiant/notifai 0.5.0 → 1.0.0

package/src/commands.test.ts

@@ -50,12 +50,28 @@ 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'
 
+/**
+ * The release tag this build pins the agent skill to.
+ *
+ * Read from the manifest for the same reason the CLI itself does: a fixture
+ * carrying a literal tag stops matching the moment the version is bumped, and
+ * a test that has to be hand-edited on every release is a copy of the constant
+ * it is supposed to be checking.
+ */
+const RELEASE_REF = `v${
+  (
+    JSON.parse(
+      readFileSync(fileURLToPath(new URL('../package.json', import.meta.url)), 'utf8'),
+    ) as { version: string }
+  ).version
+}`
+
 class CapturedIo implements CommandIo {
   outLines: string[] = []
   errLines: string[] = []
@@ -107,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)
   }
@@ -387,7 +414,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 () => {
@@ -1237,6 +1266,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)
@@ -1250,9 +1359,10 @@ describe('harness activation guidance', () => {
       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', () => {
@@ -1269,6 +1379,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 }
+
+    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()
@@ -1294,8 +1450,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')
@@ -1586,10 +1743,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)
@@ -1771,11 +1954,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 () => {
@@ -1798,13 +1981,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)
@@ -1974,7 +2158,7 @@ describe('init', () => {
       source: 'Raidiant-io/notifai',
       sourceType: 'github',
       sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
-      ref: 'v0.5.0',
+      ref: RELEASE_REF,
     }
   }
 
@@ -2004,13 +2188,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')
@@ -2022,9 +2214,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-')
   })
 
@@ -2076,8 +2269,9 @@ describe('init', () => {
     expect(io.errLines).toEqual([])
   })
 
-  it('pins the skill installer to the tagged public release syntax', () => {
-    expect(SKILLS_SOURCE).toBe('Raidiant-io/notifai#v0.5.0')
+  it('pins the skill installer to the tagged release this build actually is', () => {
+    expect(SKILLS_SOURCE).toBe(`Raidiant-io/notifai#${RELEASE_REF}`)
+    // `#` selects a Git ref; `@` would select a skill name instead.
     expect(SKILLS_SOURCE).not.toContain('@v')
   })
 
@@ -2100,7 +2294,7 @@ describe('init', () => {
             source: 'Raidiant-io/notifai',
             sourceType: 'github',
             sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
-            ref: 'v0.5.0',
+            ref: RELEASE_REF,
           },
         ],
       }),
@@ -2255,6 +2449,48 @@ 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', 'hooks.json'))).toBe(true)
+    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()
@@ -2489,9 +2725,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')
@@ -2647,9 +2880,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 () => {
@@ -2820,6 +3051,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
@@ -3237,7 +3588,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.5.0',
+                  ref: RELEASE_REF,
                 },
               ]
             : [],
@@ -3490,13 +3841,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, {})