@raidiant/notifai 8.0.0 → 9.1.0

package/src/commands.test.ts

@@ -63,17 +63,26 @@ import {
 import {
   applyPlan,
   buildHookConfig,
+  hookCommand,
   codexHookIdentityHash,
   codexTrustKey,
   findInstallations,
+  handlerEvent,
+  settingsFile,
 } 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, stateDir } from './config.js'
-import { createLogger, logsDiskUsage, readLogRecords } from './logging.js'
+import { CONFIG_KEYS, loadConfig, personalProjectConfigPath, sessionConfigPath, stateDir } from './config.js'
+import { SETUP_PROOF_STALE_MS, writeSetupProof } from './commands-setup-proof.js'
+import { resetLatestPublishedCliVersionForTest } from './cli-release.js'
+import { activeLogPath, createLogger, logsDiskUsage, readLogRecords } from './logging.js'
 import { hookAdapterPath, inspectHookAdapter } from './hook-adapter.js'
 import type { Tone } from './ui/theme.js'
 
+afterEach(() => {
+  resetLatestPublishedCliVersionForTest()
+})
+
 /**
  * The release tag this build pins the agent skill to.
  *
@@ -328,6 +337,7 @@ function makeDeps(io: CapturedIo, client: ApiClient): CommandDeps {
     hookAdapterHome: path.join(testRoot, 'home'),
     cwd: os.tmpdir(),
     clientFactory: () => withCompatibilityDefaults(client),
+    fetchImpl: async () => new Response('{}', { status: 503 }),
   }
 }
 
@@ -382,6 +392,8 @@ const reply: ReplyView = {
   device_id: 'dev_test',
   device_name: 'iPhone',
   text: 'yes, after the migration',
+  answers: [],
+  source: null,
   created_at: '2026-08-01T18:01:00.000Z',
 }
 
@@ -573,6 +585,131 @@ describe('command contracts', () => {
     expect(io.errLines.join('\n')).toContain('project')
   })
 
+  it('persists one opaque retry attempt after an ambiguous submit failure', async () => {
+    const io = new CapturedIo()
+    let attemptedKey = ''
+    const client = {
+      submit: async (body: SubmitNotificationRequestT) => {
+        attemptedKey = body.idempotency_key
+        throw new NetworkError('Connection closed before a response arrived')
+      },
+    } as unknown as ApiClient
+
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-send-attempt-'))
+    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: 'send' })
+    expect(
+      await sendCommand(deps, {
+        kind: 'done',
+        title: 'Checks finished',
+        body: 'All checks passed.',
+      }),
+    ).toBe(EXIT.network)
+
+    expect(attemptedKey).toMatch(/^cli-/)
+    expect(io.errLines.join('\n')).toContain('exact semantic send with `--retry`')
+    expect(io.errLines.join('\n')).toMatch(/Opaque retry attempt: sat_/)
+    expect(
+      readLogRecords(deps.env, { event: ['send.attempt'] }).records.at(-1)?.data,
+    ).toMatchObject({
+      idempotency_key: attemptedKey,
+      attempt_id: expect.stringMatching(/^sat_/),
+      replay: false,
+    })
+    rmSync(root, { recursive: true, force: true })
+  })
+
+  it('prints an opaque retry instruction for an ambiguous server failure', async () => {
+    const io = new CapturedIo()
+    const client = {
+      submit: async () => {
+        throw new ApiCallError(503, 'temporarily_unavailable', 'Try again later.')
+      },
+    } as unknown as ApiClient
+
+    expect(
+      await sendCommand(makeDeps(io, client), {
+        kind: 'failed',
+        title: 'Validation could not finish',
+        body: 'The service failed while accepting the result.',
+      }),
+    ).toBe(EXIT.network)
+    expect(io.errLines.join('\n')).toContain('exact semantic send with `--retry`')
+  })
+
+  it('reuses the opaque attempt key only after an explicit exact semantic retry', async () => {
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-send-retry-'))
+    const io = new CapturedIo()
+    const keys: string[] = []
+    let calls = 0
+    const client = {
+      submit: async (body: SubmitNotificationRequestT) => {
+        keys.push(body.idempotency_key)
+        calls += 1
+        if (calls === 1) throw new NetworkError('killed after an ambiguous boundary')
+        return { ...receipt, replayed: true }
+      },
+    } as unknown as ApiClient
+    const deps = {
+      ...makeDeps(io, client),
+      cwd: root,
+      env: { XDG_CONFIG_HOME: path.join(root, 'config'), XDG_STATE_HOME: path.join(root, 'state') },
+    }
+    const semantic = { kind: 'done', title: 'Recovery completed', body: 'The exact work is done.' }
+
+    expect(await sendCommand(deps, semantic)).toBe(EXIT.network)
+    expect(await sendCommand(deps, { ...semantic, retry: true })).toBe(EXIT.ok)
+    expect(keys).toHaveLength(2)
+    expect(keys[1]).toBe(keys[0])
+    expect(await sendCommand(deps, { ...semantic, retry: true })).toBe(EXIT.usage)
+  })
+
+  it('routes a send with no active Companion devices into the setup coordinator', async () => {
+    const io = new CapturedIo()
+    const client = {
+      submit: async () => {
+        throw new ApiCallError(
+          409,
+          'no_active_devices',
+          'No enabled active Device Installation can receive this request.',
+          'Open the Companion App and enable notifications.',
+        )
+      },
+    } as unknown as ApiClient
+
+    expect(
+      await sendCommand(makeDeps(io, client), {
+        kind: 'done',
+        title: 'Checks finished',
+        body: 'All checks passed.',
+      }),
+    ).toBe(EXIT.failed)
+
+    expect(io.errLines.join('\n')).toMatch(/next:.*`notifai init`.*Companion/i)
+    expect(io.errLines.join('\n')).toContain('exact original Notification Request with `--retry`')
+    expect(io.errLines.join('\n')).toMatch(/verification request does not replace this Agent Event/i)
+  })
+
+  it('routes a send from an unpaired machine into the same setup coordinator', async () => {
+    const io = new CapturedIo()
+    const deps = makeDeps(io, {} as ApiClient)
+    deps.store.load = () => null
+
+    expect(
+      await sendCommand(deps, {
+        kind: 'done',
+        title: 'Checks finished',
+        body: 'All checks passed.',
+      }),
+    ).toBe(EXIT.auth)
+
+    expect(io.errLines.join('\n')).toMatch(/`notifai init`.*login.*device setup/i)
+  })
+
   it('authors and validates an Android-specific Notification Request', async () => {
     const io = new CapturedIo()
     let submitted: SubmitNotificationRequestT | undefined
@@ -1032,11 +1169,13 @@ describe('command contracts', () => {
       expect(grammar).not.toContain(".option('--detail")
       expect(grammar).not.toContain(".option('--session <")
       expect(grammar).toContain(".option('--body-file")
-      expect(grammar).toContain(".option('--session-id")
       expect(grammar).toContain("'--session-label <text>'")
       expect(grammar).toContain("'--image <path|url|media_id>'")
       expect(grammar).toContain("'--image-alt <text>'")
     }
+    expect(sendGrammar).toContain(".option('--session-id")
+    expect(sendGrammar).toContain(".option('--retry'")
+    expect(askGrammar).not.toContain(".option('--session-id")
     // Kind now selects the sound, so the help must say so — and must not carry
     // the retired separation it replaced.
     expect(source).toContain('Kind is required, and it selects the sound')
@@ -1209,8 +1348,11 @@ describe('command contracts', () => {
       request_id: receipt.request_id,
       sequence: reply.seq,
       device: reply.device_name,
-      text: reply.text,
+      text_chars: reply.text.length,
+      answers_count: reply.answers.length,
     })
+    const raw = readFileSync(activeLogPath(deps.env), 'utf8')
+    expect(raw).not.toContain(reply.text)
   })
 
   it('backs off and retries a transient network error while waiting', async () => {
@@ -1501,9 +1643,13 @@ describe('command contracts', () => {
       'acknowledgement.attempted',
       'acknowledgement.outcome',
     ])
+    const raw = readFileSync(activeLogPath(deps.env), 'utf8')
+    expect(raw).not.toContain('I will deploy staging now.')
+    expect(events[0]?.data).toMatchObject({ characters: 'I will deploy staging now.'.length })
+    expect(events[1]?.data).toMatchObject({ text_chars: 'I will deploy staging now.'.length })
   })
 
-  it('clears a matching active-session obligation after acknowledgement success', async () => {
+  it('clears the stable-id session obligation after acknowledgement from another checkout', async () => {
     const io = new CapturedIo()
     const client = {
       putAgentAcknowledgement: async () => ({
@@ -1526,6 +1672,7 @@ describe('command contracts', () => {
       acknowledgement_due: [{ request_id: receipt.request_id, recorded_at: now }],
     })
     writeProjectSession(deps.cwd, deps.env, 'ack-session', now, 'codex')
+    deps.cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-ack-other-checkout-'))
 
     expect(
       await acknowledgeCommand(deps, receipt.request_id, {
@@ -1719,6 +1866,114 @@ describe('command contracts', () => {
     })
   })
 
+  it('close --pending withdraws an unpushed registration so a later Stop cannot send it', async () => {
+    const io = new CapturedIo()
+    const client = {
+      closeReplies: async () => {
+        throw new Error('unpushed questions must not call the server')
+      },
+    } as unknown as ApiClient
+    const deps = makeDeps(io, client)
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-close-unpushed-'))
+    deps.cwd = root
+    deps.env = {
+      XDG_CONFIG_HOME: path.join(root, 'config'),
+      XDG_STATE_HOME: path.join(root, 'state'),
+    }
+    writeSessionState('close-unpushed', deps.env, {
+      pending: [{ question: 'Ship it?', question_id: 'q_local' }],
+    })
+    writeProjectSession(root, deps.env, 'close-unpushed', Date.now(), 'codex')
+
+    expect(await closeCommand(deps, undefined, { pending: true, json: true })).toBe(EXIT.ok)
+    expect(JSON.parse(io.outLines[0] ?? '{}')).toEqual({
+      session_id: 'close-unpushed',
+      withdrawn: [{ question: 'Ship it?', question_id: 'q_local' }],
+      closed: [],
+    })
+    expect(readSessionState('close-unpushed', deps.env).pending).toBeUndefined()
+  })
+
+  it('close withdraws one unpushed question by stable id from another checkout', async () => {
+    const io = new CapturedIo()
+    const client = {
+      closeReplies: async () => {
+        throw new Error('unpushed questions must not call the server')
+      },
+    } as unknown as ApiClient
+    const deps = makeDeps(io, client)
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-close-one-unpushed-'))
+    deps.cwd = root
+    deps.env = {
+      XDG_CONFIG_HOME: path.join(root, 'config'),
+      XDG_STATE_HOME: path.join(root, 'state'),
+    }
+    writeSessionState('close-one', deps.env, {
+      pending: [
+        { question: 'Ship it?', question_id: 'q_local' },
+        { question: 'Keep this?', question_id: 'q_keep' },
+      ],
+    })
+    writeProjectSession(root, deps.env, 'close-one', Date.now(), 'codex')
+    deps.cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-close-other-checkout-'))
+
+    expect(await closeCommand(deps, 'q_local', { json: true })).toBe(EXIT.ok)
+    expect(JSON.parse(io.outLines[0] ?? '{}')).toEqual({
+      session_id: 'close-one',
+      withdrawn: [{ question: 'Ship it?', question_id: 'q_local' }],
+      closed: [],
+    })
+    expect(readSessionState('close-one', deps.env).pending?.map((entry) => entry.question_id)).toEqual([
+      'q_keep',
+    ])
+  })
+
+  it('close --pending closes live questions and leaves nothing for a later Stop to push', async () => {
+    const io = new CapturedIo()
+    const closed: string[] = []
+    const client = {
+      closeReplies: async (requestId: string) => {
+        closed.push(requestId)
+        return replyResponse([])
+      },
+    } as unknown as ApiClient
+    const deps = makeDeps(io, client)
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-close-pending-mix-'))
+    deps.cwd = root
+    deps.env = {
+      XDG_CONFIG_HOME: path.join(root, 'config'),
+      XDG_STATE_HOME: path.join(root, 'state'),
+    }
+    writeSessionState('close-mix', deps.env, {
+      pending: [
+        { question: 'Unpushed?', question_id: 'q_local' },
+        {
+          question: 'Already on a device?',
+          request_id: receipt.request_id,
+          collapse_key: 'question-live',
+          device_ids: ['dev_iphone'],
+        },
+      ],
+    })
+    writeProjectSession(root, deps.env, 'close-mix', Date.now(), 'codex')
+
+    expect(await closeCommand(deps, undefined, { pending: true, json: true })).toBe(EXIT.ok)
+    expect(closed).toEqual([receipt.request_id])
+    expect(JSON.parse(io.outLines[0] ?? '{}')).toMatchObject({
+      session_id: 'close-mix',
+      withdrawn: [{ question: 'Unpushed?', question_id: 'q_local' }],
+      closed: [receipt.request_id],
+    })
+    expect(readSessionState('close-mix', deps.env).pending).toBeUndefined()
+  })
+
+  it('close requires a request id or --pending', async () => {
+    const io = new CapturedIo()
+    const client = {} as unknown as ApiClient
+    expect(await closeCommand(makeDeps(io, client), undefined, {})).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toContain('Pass a request id or --pending.')
+  })
+
   it('passes the replies cursor and prints replies for later retrieval', async () => {
     const io = new CapturedIo()
     let requested: { waitSeconds: number; afterSeq: number } | undefined
@@ -1746,7 +2001,7 @@ describe('command contracts', () => {
     expect(readLogRecords(deps.env, { event: ['reply.received'] }).records).toHaveLength(1)
   })
 
-  it('resolves replies --pending through the project session pointer and prints its id', async () => {
+  it('resolves replies --pending by exact session from another checkout', async () => {
     const io = new CapturedIo()
     const client = {
       replies: async () => replyResponse([reply]),
@@ -1757,11 +2012,15 @@ describe('command contracts', () => {
     deps.env = {
       XDG_CONFIG_HOME: path.join(root, 'config'),
       XDG_STATE_HOME: path.join(root, 'state'),
+      CODEX_THREAD_ID: 'pending-session',
     }
     writeSessionState('pending-session', deps.env, {
+      harness: 'codex',
+      last_prompt_at: Date.now(),
       pending: [{ question: 'Deploy?', request_id: receipt.request_id }],
     })
     writeProjectSession(root, deps.env, 'pending-session', Date.now(), 'codex')
+    deps.cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-pending-other-checkout-'))
 
     expect(await repliesCommand(deps, undefined, { pending: true })).toBe(EXIT.ok)
     expect(io.outLines).toEqual([
@@ -1797,8 +2056,9 @@ describe('command contracts', () => {
     writeProjectSession(root, deps.env, 'pending-multi', Date.now(), 'codex')
 
     expect(await repliesCommand(deps, undefined, { pending: true })).toBe(EXIT.ok)
-    expect(io.outLines[0]).toBe('pending request req_first')
-    expect(io.outLines[1]).toContain('yes, after the migration')
+    expect(io.outLines[0]).toBe('unpushed question: Not yet asked?')
+    expect(io.outLines.join('\n')).toContain('pending request req_first')
+    expect(io.outLines.join('\n')).toContain('yes, after the migration')
     expect(io.outLines.join('\n')).toContain('req_second')
   })
 
@@ -1995,13 +2255,188 @@ describe('command contracts', () => {
   })
 })
 
+describe('credential origin pinning', () => {
+  it('never sends the machine bearer to a flag or env origin override', async () => {
+    const io = new CapturedIo()
+    const seen: { baseUrl: string; bearer: string | null }[] = []
+    const client = {
+      submit: async () => receipt,
+    } as unknown as ApiClient
+    const deps = makeDeps(io, client)
+    deps.env = { ...deps.env, NOTIFAI_BASE_URL: 'https://attacker.example' }
+    deps.clientFactory = (baseUrl, bearer) => {
+      seen.push({ baseUrl, bearer })
+      return withCompatibilityDefaults(client)
+    }
+
+    expect(
+      await sendCommand(deps, {
+        kind: 'update',
+        title: 'T',
+        body: 'B',
+        baseUrl: 'https://attacker.flag',
+      }),
+    ).toBe(EXIT.ok)
+
+    expect(seen).toEqual([
+      {
+        baseUrl: 'https://test.notifai.invalid',
+        bearer: 'Bearer nfm_mac_test.test-secret',
+      },
+    ])
+    expect(io.errLines.join('\n')).toContain('Ignoring base_url from flag')
+    expect(io.errLines.join('\n')).not.toContain('test-secret')
+    expect(io.errLines.join('\n')).not.toContain('nfm_')
+    expect(io.errLines.join('\n')).not.toContain('https://attacker.example')
+    expect(io.errLines.join('\n')).not.toContain('https://attacker.flag')
+  })
+
+  it('lets unsigned-in login target an origin override', async () => {
+    const io = new CapturedIo()
+    const seen: { baseUrl: string; bearer: string | null }[] = []
+    let beginBody: Parameters<ApiClient['beginPairing']>[0] | null = null
+    let now = 0
+    const client = {
+      beginPairing: async (body: Parameters<ApiClient['beginPairing']>[0]) => {
+        beginBody = body
+        return {
+          pairing_id: 'pair_test',
+          code: 'ABCD-EFGH',
+          approve_url: 'https://selfhost.example/pair/ABCD-EFGH',
+          expires_at: new Date(10_000).toISOString(),
+          poll_interval_seconds: 1,
+        }
+      },
+      pollPairing: async () => ({ status: 'approved', machine_id: 'mac_new' }),
+    } as unknown as ApiClient
+    const saved: { baseUrl?: string } = {}
+    const deps: CommandDeps = {
+      ...makeDeps(io, client),
+      now: () => now,
+      sleep: async (milliseconds: number) => {
+        now += milliseconds
+      },
+      store: {
+        load: () => null,
+        save: (credential) => {
+          saved.baseUrl = credential.baseUrl
+        },
+        clear: () => {},
+        describe: () => 'test credential store',
+      },
+      clientFactory: (baseUrl, bearer) => {
+        seen.push({ baseUrl, bearer })
+        return withCompatibilityDefaults(client)
+      },
+    }
+
+    expect(await loginCommand(deps, { baseUrl: 'https://selfhost.example', open: false })).toBe(
+      EXIT.ok,
+    )
+    expect(seen[0]).toEqual({ baseUrl: 'https://selfhost.example', bearer: null })
+    expect(saved.baseUrl).toBe('https://selfhost.example')
+    expect(beginBody).toMatchObject({
+      machine_name: expect.any(String),
+      credential_hash: expect.stringMatching(/^[a-f0-9]{64}$/),
+      poll_verifier_hash: expect.stringMatching(/^[a-f0-9]{64}$/),
+      confirmation_hash: expect.stringMatching(/^[a-f0-9]{64}$/),
+    })
+    expect(io.outLines[1]).toMatch(
+      /^Approve this machine at: https:\/\/selfhost\.example\/pair\/ABCD-EFGH#confirmation_secret=[A-Za-z0-9_-]{43}$/,
+    )
+  })
+
+  it('stops login when the approving account has no product access', async () => {
+    const io = new CapturedIo()
+    let now = 0
+    const client = {
+      beginPairing: async () => ({
+        pairing_id: 'pair_test',
+        code: 'ABCD-EFGH',
+        approve_url: 'https://app.notifai.sh/pair/ABCD-EFGH',
+        expires_at: new Date(10_000).toISOString(),
+        poll_interval_seconds: 1,
+      }),
+      pollPairing: async () => ({
+        status: 'no_active_plan',
+        next_action: 'Ask the account owner for Alpha access.',
+      }),
+    } as unknown as ApiClient
+    const deps: CommandDeps = {
+      ...makeDeps(io, client),
+      now: () => now,
+      sleep: async (milliseconds: number) => {
+        now += milliseconds
+      },
+    }
+
+    expect(await loginCommand(deps, { open: false })).toBe(EXIT.auth)
+    expect(io.errLines).toEqual([
+      'This account has no active plan or temporary Alpha access.',
+      'next: Ask the account owner for Alpha access.',
+      'After access is granted, run `notifai login` again.',
+    ])
+  })
+
+  it('keeps notification titles out of send logs', async () => {
+    const io = new CapturedIo()
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-send-log-'))
+    const client = { submit: async () => receipt } as unknown as ApiClient
+    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: 'send', settings: { level: 'debug' } })
+
+    expect(
+      await sendCommand(deps, {
+        kind: 'update',
+        title: 'SECRET_SEND_TITLE',
+        body: 'SECRET_SEND_BODY',
+      }),
+    ).toBe(EXIT.ok)
+    const raw = readFileSync(activeLogPath(deps.env), 'utf8')
+    expect(raw).not.toContain('SECRET_SEND_TITLE')
+    expect(raw).not.toContain('SECRET_SEND_BODY')
+    const submitted = readLogRecords(deps.env, { event: ['send.submitted'] }).records
+    expect(submitted[0]?.data).toMatchObject({
+      request_id: receipt.request_id,
+      title_chars: 'SECRET_SEND_TITLE'.length,
+    })
+  })
+
+  it('refuses a shell-escaped backslash-n body unless the literal flag is set', async () => {
+    const io = new CapturedIo()
+    expect(
+      await sendCommand(makeDeps(io, {} as ApiClient), {
+        kind: 'update',
+        title: 'Escaped',
+        body: 'line1\\nline2',
+      }),
+    ).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toContain('--body-file -')
+    expect(io.errLines.join('\n')).toContain('--literal-backslash-n')
+
+    io.errLines = []
+    const client = { submit: async () => receipt } as unknown as ApiClient
+    expect(
+      await sendCommand(makeDeps(io, client), {
+        kind: 'update',
+        title: 'Escaped',
+        body: 'line1\\nline2',
+        literalBackslashN: true,
+      }),
+    ).toBe(EXIT.ok)
+  })
+})
+
 describe('delivery evidence status', () => {
   function snapshot(
     companionReceipt: EvidenceSnapshot['deliveries'][number]['companion_receipt'],
   ): EvidenceSnapshot {
     return {
       request_id: 'req_status_test',
-      event: 'tests_passed',
       accepted_at: '2026-08-05T13:05:48.000Z',
       overall: 'provider_accepted_all',
       deliveries: [
@@ -2097,18 +2532,65 @@ describe('delivery evidence status', () => {
     expect(said).toContain('Reply received: yes')
     expect(said).toContain('answers are on the server')
   })
-})
-
-describe('Cursor hook commands', () => {
-  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-'))
-    const io = new CapturedIo()
-    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
 
-    expect(
+  it('treats an ordinary status Companion Receipt as doctor delivery proof', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-status-proof-'))
+    const evidence = snapshot({
+      state: 'observed',
+      observed_at: '2026-08-05T13:17:17.000Z',
+      latency_ms: 1_000,
+    })
+    const device = {
+      device_id: evidence.deliveries[0]!.device_id,
+      display_name: 'iPhone',
+      platform: 'ios' as const,
+      permission_status: 'authorized',
+      registration_healthy: true,
+      app_version: '0.1.0',
+      app_build: '42',
+      os_version: '19.0',
+      capabilities: ['answer'] as const,
+      support: currentSupport,
+      support_state: 'current' as const,
+      derived_status: 'working' as const,
+      status_message: null,
+      last_seen_at: '2026-08-05T18:00:00.000Z',
+    }
+    const client = {
+      health: async () => true,
+      listDevices: async () => ({ devices: [device] }),
+      accessStatus: async () => ({
+        status: 'active',
+        reason: 'alpha_grant',
+        expires_at: null,
+        email: 'proof@example.com',
+      }),
+      evidence: async () => evidence,
+    } as unknown as ApiClient
+    const io = new CapturedIo()
+    const deps = { ...makeDeps(io, client), cwd, env: isolatedEnv(cwd) }
+
+    expect(await statusCommand(deps, evidence.request_id, { json: true })).toBe(EXIT.ok)
+
+    const doctorIo = new CapturedIo()
+    expect(await doctorCommand({ ...deps, io: doctorIo }, { json: true })).toBe(EXIT.ok)
+    const report = JSON.parse(doctorIo.outLines.join('\n')) as {
+      states: { id: string; status: string }[]
+    }
+    expect(report.states.find((state) => state.id === 'proof')).toMatchObject({ status: 'ready' })
+  })
+})
+
+describe('Cursor hook commands', () => {
+  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-'))
+    const io = new CapturedIo()
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
+
+    expect(
       hooksInstallCommand(deps, { harness: 'cursor', execPath, scriptPath }),
     ).toBe(EXIT.ok)
 
@@ -2122,12 +2604,17 @@ describe('Cursor hook commands', () => {
     expect(Object.keys(installed.hooks).sort()).toEqual([
       'beforeSubmitPrompt',
       'sessionEnd',
+      'sessionStart',
       'stop',
     ])
     expect(installed.hooks['beforeSubmitPrompt']?.[0]?.command).toContain(
       'hook user-prompt-submit --owner notifai --harness cursor',
     )
     expect(installed.hooks['stop']?.[0]).toMatchObject({
+      command: expect.stringContaining('hook activation-stop --owner notifai --harness cursor'),
+      loop_limit: 1,
+    })
+    expect(installed.hooks['stop']?.[1]).toMatchObject({
       command: expect.stringContaining('hook stop --owner notifai --harness cursor'),
       loop_limit: 3,
     })
@@ -2163,7 +2650,7 @@ describe('Cursor hook commands', () => {
     expect(io.outLines).toContain(
       `ok    Question routing: cursor project (${path.join(cwd, '.cursor', 'hooks.json')})`,
     )
-    expect(io.outLines.some((line) => line.includes('Cursor: send one prompt'))).toBe(true)
+    expect(io.outLines.some((line) => line.includes('Cursor: start one fresh conversation'))).toBe(true)
   })
 
   it('uninstalls only Notifai Cursor hooks and preserves foreign hooks', () => {
@@ -2242,13 +2729,7 @@ describe('Codex hook representation', () => {
     expect(io.outLines.join('\n')).toMatch(/Stop and the existing one will both fire/i)
   })
 
-  /**
-   * The foreign `hooks.json` stays byte-identical and Notifai lands inline.
-   * Codex will now warn that the layer uses both representations; the install
-   * output says why, because that warning is Codex reporting a merge, not a
-   * fault, and a silent one would read as Notifai's bug.
-   */
-  it('leaves a foreign hooks.json alone and installs inline instead', () => {
+  it('joins a populated hooks.json without introducing a second representation', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-json-install-'))
     const layer = path.join(cwd, '.codex')
     const json = path.join(layer, 'hooks.json')
@@ -2266,17 +2747,12 @@ describe('Codex hook representation', () => {
 
     expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
 
-    const beforeJson = readFileSync(json, 'utf8')
-    expect(beforeJson).toContain('gdh-stop')
-    expect(beforeJson).not.toContain('--owner notifai')
-    const after = readFileSync(toml, 'utf8')
-    // The user's file arrives back as the file they wrote, plus our hooks.
-    expect(after).toContain(beforeToml.trimEnd())
-    expect(after).toContain('--owner notifai')
-    expect(io.outLines.join('\n')).toContain(toml)
-    expect(io.outLines.join('\n')).toMatch(/Notifai will not modify it/)
-    expect(io.outLines.join('\n')).toMatch(/not a Notifai fault/)
-    expect(io.outLines.join('\n')).not.toMatch(/installed in both/i)
+    const afterJson = readFileSync(json, 'utf8')
+    expect(afterJson).toContain('gdh-stop')
+    expect(afterJson).toContain('--owner notifai')
+    expect(readFileSync(toml, 'utf8')).toBe(beforeToml)
+    expect(io.outLines.join('\n')).toContain(json)
+    expect(io.outLines.join('\n')).not.toMatch(/both representations|not a Notifai fault/i)
   })
 
   it('leaves config.toml byte-identical when uninstall finds no Notifai hooks', () => {
@@ -2293,6 +2769,50 @@ describe('Codex hook representation', () => {
     expect(io.outLines.join('\n')).toContain('No Notifai hooks found')
   })
 
+  it('leaves config.toml byte-identical on a no-op reinstall', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-noop-install-'))
+    const io = new CapturedIo()
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    const toml = path.join(cwd, '.codex', 'config.toml')
+    const before = readFileSync(toml, 'utf8')
+    io.outLines = []
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    expect(readFileSync(toml, 'utf8')).toBe(before)
+  })
+
+  it('deletes an emptied hooks.json instead of leaving an empty residue', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-empty-json-'))
+    const layer = path.join(cwd, '.codex')
+    const json = path.join(layer, 'hooks.json')
+    mkdirSync(layer, { recursive: true })
+    applyPlan(json, {
+      hooks: {
+        Stop: [{ hooks: [{ type: 'command', command: hookCommand(scriptPath, 'stop', 'codex') }] }],
+      },
+    })
+    const io = new CapturedIo()
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
+    expect(hooksUninstallCommand(deps, { harness: 'codex', scriptPath })).toBe(EXIT.ok)
+    expect(existsSync(json)).toBe(false)
+  })
+
+  it('global install does not leave a dead project .codex after uninstalling that layer', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-global-migrate-'))
+    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'))).toBe(true)
+    expect(hooksInstallCommand(deps, { harness: 'codex', global: true, execPath, scriptPath })).toBe(
+      EXIT.ok,
+    )
+    expect(existsSync(path.join(cwd, '.codex', 'hooks.json'))).toBe(false)
+    const leftover = existsSync(path.join(cwd, '.codex'))
+      ? readdirSync(path.join(cwd, '.codex'))
+      : []
+    expect(leftover.every((name) => name !== 'hooks.json')).toBe(true)
+  })
+
   /**
    * Notifai in one file, someone else's hooks in the other: every handler
    * fires once, so doctor has nothing to report and the foreign file is not
@@ -2386,7 +2906,7 @@ describe('harness activation guidance', () => {
   const execPath = process.execPath
   const scriptPath = fileURLToPath(import.meta.url)
 
-  it('does not require a Claude Code restart for project hook files', () => {
+  it('requires a fresh Claude Code session so SessionStart can activate it', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-claude-activation-'))
     const io = new CapturedIo()
     const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
@@ -2397,11 +2917,11 @@ describe('harness activation guidance', () => {
 
     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).toContain('Start one fresh Claude Code session, send one prompt, then run `notifai doctor`.')
     expect(output).not.toMatch(/timeout|asynchronous|600s/i)
   })
 
-  it('does not invent a Codex hook trust gate', () => {
+  it('names Codex trust and fresh-session activation in the correct order', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-activation-'))
     const io = new CapturedIo()
     const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
@@ -2411,8 +2931,8 @@ describe('harness activation guidance', () => {
     )
 
     const output = io.outLines.join('\n')
-    expect(output).toContain('Send one Codex prompt, then check `notifai doctor`.')
-    expect(output).not.toMatch(/trust|approve/i)
+    expect(output).toContain('Approve the Notifai handlers in `/hooks` if Codex asks')
+    expect(output).toMatch(/approve[\s\S]*start one fresh Codex session[\s\S]*`notifai doctor`/i)
   })
 
   it('names the installed harness in the close, never a different one', () => {
@@ -2424,7 +2944,7 @@ describe('harness activation guidance', () => {
 
     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).toContain('Start one fresh Cursor conversation, send one prompt, finish its first turn, then run `notifai doctor`.')
     expect(output).not.toMatch(/Codex|Claude Code|OpenCode/)
     expect(output).not.toMatch(/timeout|worktree|fails closed/i)
   })
@@ -2487,7 +3007,7 @@ describe('harness activation guidance', () => {
     )
 
     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')).toContain('Restart OpenCode, start one fresh session, send one prompt, then run `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')
@@ -2632,6 +3152,141 @@ describe('stable hook installation', () => {
       findInstallations(cwd, env, deps.hookAdapterHome).filter((item) => item.harness === 'codex'),
     ).toEqual([expect.objectContaining({ global: true })])
   })
+
+  it('refreshes stale global lifecycle coverage instead of declining a project install', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-hooks-global-stale-'))
+    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: 'cursor',
+        global: true,
+        execPath,
+        scriptPath,
+      }),
+    ).toBe(EXIT.ok)
+    const globalFile = settingsFile('cursor', true, cwd, env)
+    const settings = JSON.parse(readFileSync(globalFile, 'utf8')) as {
+      hooks: { stop: Array<{ command?: string }> }
+    }
+    settings.hooks.stop = settings.hooks.stop.filter(
+      (handler) => !handler.command?.includes(' hook activation-stop '),
+    )
+    writeFileSync(globalFile, `${JSON.stringify(settings, null, 2)}\n`)
+
+    io.outLines = []
+    expect(hooksInstallCommand(deps, { harness: 'cursor', execPath, scriptPath })).toBe(EXIT.ok)
+    expect(existsSync(path.join(cwd, '.cursor', 'hooks.json'))).toBe(false)
+    const installation = findInstallations(cwd, env, deps.hookAdapterHome).find(
+      (item) => item.harness === 'cursor' && item.global,
+    )
+    expect(installation?.handlers.map((handler) => handlerEvent(handler.command))).toContain(
+      'activation-stop',
+    )
+    expect(io.outLines.join('\n')).toMatch(/Installed cursor hooks/)
+  })
+
+  it('refreshes a stale global Stop shape instead of declining a project install', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-hooks-global-shape-'))
+    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: 'cursor',
+        global: true,
+        execPath,
+        scriptPath,
+      }),
+    ).toBe(EXIT.ok)
+    const globalFile = settingsFile('cursor', true, cwd, env)
+    const settings = JSON.parse(readFileSync(globalFile, 'utf8')) as {
+      hooks: { stop: Array<{ command?: string; timeout?: number }> }
+    }
+    const stop = settings.hooks.stop.find((handler) => handler.command?.includes(' hook stop '))
+    expect(stop).toBeDefined()
+    stop!.timeout = 1
+    writeFileSync(globalFile, `${JSON.stringify(settings, null, 2)}\n`)
+
+    io.outLines = []
+    expect(hooksInstallCommand(deps, { harness: 'cursor', execPath, scriptPath })).toBe(EXIT.ok)
+    expect(existsSync(path.join(cwd, '.cursor', 'hooks.json'))).toBe(false)
+    const refreshed = JSON.parse(readFileSync(globalFile, 'utf8')) as {
+      hooks: { stop: Array<{ command?: string; timeout?: number }> }
+    }
+    expect(
+      refreshed.hooks.stop.find((handler) => handler.command?.includes(' hook stop '))?.timeout,
+    ).toBeGreaterThan(1)
+    expect(io.outLines.join('\n')).toMatch(/Installed cursor hooks/)
+  })
+
+  it('consolidates duplicate global Codex representations before declining a project install', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-hooks-global-codex-duplicate-'))
+    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)
+    const json = path.join(env.CODEX_HOME!, 'hooks.json')
+    applyPlan(json, {
+      hooks: {
+        ...buildHookConfig({ adapterPath: hookAdapterPath(deps.hookAdapterHome), harness: 'codex' }),
+        PostToolUse: [{ hooks: [{ type: 'command', command: 'foreign-post-tool' }] }],
+      },
+    })
+
+    io.outLines = []
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    expect(existsSync(path.join(cwd, '.codex', 'config.toml'))).toBe(false)
+    expect(readFileSync(json, 'utf8')).toContain('foreign-post-tool')
+    expect(readFileSync(json, 'utf8')).not.toContain('--owner notifai')
+    expect(
+      findInstallations(cwd, env, deps.hookAdapterHome).filter(
+        (installation) => installation.harness === 'codex',
+      ),
+    ).toEqual([expect.objectContaining({ global: true })])
+    expect(io.outLines.join('\n')).toMatch(/Installed codex hooks/)
+  })
+
+  it('refreshes an obsolete global OpenCode plugin instead of treating empty event requirements as coverage', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-hooks-global-opencode-stale-'))
+    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: 'opencode',
+        global: true,
+        execPath,
+        scriptPath,
+      }),
+    ).toBe(EXIT.ok)
+    const globalFile = settingsFile('opencode', true, cwd, env)
+    const current = readFileSync(globalFile, 'utf8')
+    writeFileSync(globalFile, current.replace('const ADAPTER_VERSION = 11', 'const ADAPTER_VERSION = 10'))
+
+    io.outLines = []
+    expect(hooksInstallCommand(deps, { harness: 'opencode', execPath, scriptPath })).toBe(EXIT.ok)
+    expect(existsSync(path.join(cwd, '.opencode', 'plugins', 'notifai.js'))).toBe(false)
+    const refreshed = readFileSync(globalFile, 'utf8')
+    expect(refreshed).toContain('const ADAPTER_VERSION = 11')
+    expect(refreshed).toContain('experimental.chat.system.transform')
+    expect(io.outLines.join('\n')).toMatch(/Installed opencode hooks/)
+  })
 })
 
 describe('projectSlugFrom', () => {
@@ -2967,7 +3622,7 @@ describe('interactive command UX', () => {
       beginPairing: async () => ({
         pairing_id: 'pair_test',
         code: 'ABCD-EFGH',
-        approve_url: 'https://test.notifai.invalid/pair/ABCD-EFGH',
+        approve_url: 'https://app.notifai.sh/pair/ABCD-EFGH',
         expires_at: new Date(10_000).toISOString(),
         poll_interval_seconds: 1,
       }),
@@ -2997,7 +3652,9 @@ describe('interactive command UX', () => {
     expect(io.notes).toEqual([
       {
         title: 'Approve this machine',
-        message: 'Code: ABCD-EFGH\nhttps://test.notifai.invalid/pair/ABCD-EFGH',
+        message: expect.stringMatching(
+          /^Code: ABCD-EFGH\nhttps:\/\/app\.notifai\.sh\/pair\/ABCD-EFGH#confirmation_secret=[A-Za-z0-9_-]{43}$/,
+        ),
       },
     ])
     expect(io.spinnerEvents).toEqual([
@@ -3016,7 +3673,7 @@ describe('interactive command UX', () => {
       beginPairing: async () => ({
         pairing_id: 'pair_test',
         code: 'ABCD-EFGH',
-        approve_url: 'https://test.notifai.invalid/pair/ABCD-EFGH',
+        approve_url: 'https://app.notifai.sh/pair/ABCD-EFGH',
         expires_at: new Date(10_000).toISOString(),
         poll_interval_seconds: 1,
       }),
@@ -3033,7 +3690,9 @@ describe('interactive command UX', () => {
     expect(await loginCommand(deps, { open: false })).toBe(EXIT.ok)
     expect(io.outLines.slice(0, 3)).toEqual([
       'Pairing code: ABCD-EFGH',
-      'Approve this machine at: https://test.notifai.invalid/pair/ABCD-EFGH',
+      expect.stringMatching(
+        /^Approve this machine at: https:\/\/app\.notifai\.sh\/pair\/ABCD-EFGH#confirmation_secret=[A-Za-z0-9_-]{43}$/,
+      ),
       'Waiting for approval…',
     ])
   })
@@ -3174,6 +3833,26 @@ describe('interactive command UX', () => {
     expect(io.intros).toEqual([])
     expect(io.checks).toEqual([])
   })
+
+  it('consults npm latest from an interactive doctor without failing the run', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-doctor-registry-'))
+    const io = new InteractiveIo()
+    const client = {
+      health: async () => 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' },
+      fetchImpl: async () => new Response(JSON.stringify({ latest: '99.0.0' }), { status: 200 }),
+    }
+
+    expect(await doctorCommand(deps, {})).toBe(EXIT.failed)
+    expect(io.outLines).toContain('A newer Notifai is available.')
+    expect(io.outLines).toContain('npm install -g @raidiant/notifai')
+  })
 })
 
 describe('compatibility-first update guidance', () => {
@@ -3421,7 +4100,6 @@ describe('init', () => {
   ): EvidenceSnapshot {
     return {
       request_id: requestId,
-      event: 'setup_verified',
       accepted_at: '2026-08-05T18:00:00.000Z',
       overall: 'provider_accepted_all',
       deliveries: [
@@ -3659,18 +4337,22 @@ describe('init', () => {
     } as unknown as ApiClient
     const nativeSkills: NativeSkills = {
       add: async () => 0,
+      remove: async () => 0,
       list: async (scope) => ({
-        skills: [
-          {
-            name: 'notifai',
-            scope,
-            path: path.join(cwd, '.agents', 'skills', 'notifai'),
-            source: 'Raidiant-io/notifai',
-            sourceType: 'github',
-            sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
-            ref: RELEASE_REF,
-          },
-        ],
+        skills:
+          scope === 'project'
+            ? [
+                {
+                  name: 'notifai',
+                  scope,
+                  path: path.join(cwd, '.agents', 'skills', 'notifai'),
+                  source: 'Raidiant-io/notifai',
+                  sourceType: 'github',
+                  sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
+                  ref: RELEASE_REF,
+                },
+              ]
+            : [],
       }),
     }
     const readiness = await assessReadiness(
@@ -3696,9 +4378,10 @@ describe('init', () => {
       const calls: SkillScope[] = []
       const nativeSkills: NativeSkills = {
         add: async () => 0,
+        remove: async () => 0,
         list: async (selected) => {
           calls.push(selected)
-          return { skills: [managedSkill(selected, cwd)] }
+          return { skills: selected === scope ? [managedSkill(selected, cwd)] : [] }
         },
       }
 
@@ -3710,7 +4393,7 @@ describe('init', () => {
         status: 'ready',
         detail: `installed from ${SKILLS_SOURCE} in the ${scope} scope`,
       })
-      expect(calls).toEqual([scope])
+      expect(calls).toEqual(['project', 'global'])
     },
   )
 
@@ -3726,8 +4409,12 @@ describe('init', () => {
       } as unknown as ApiClient
       const nativeSkills: NativeSkills = {
         add: async () => 0,
+        remove: async () => 0,
         list: async (selected) => ({
-          skills: [{ ...managedSkill(selected, cwd), source: null, sourceType: null, ref: null }],
+          skills:
+            selected === scope
+              ? [{ ...managedSkill(selected, cwd), source: null, sourceType: null, ref: null }]
+              : [],
         }),
       }
 
@@ -3742,6 +4429,192 @@ describe('init', () => {
     },
   )
 
+  it('reports a duplicate notifai skill across project and global scope', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'assess-skill-duplicate-'))
+    const io = new CapturedIo()
+    const client = {
+      health: async () => true,
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+      listDevices: async () => ({ devices: [] }),
+    } as unknown as ApiClient
+    const nativeSkills: NativeSkills = {
+      add: async () => 0,
+      remove: async () => 0,
+      list: async (scope) => ({
+        skills: [
+          {
+            ...managedSkill(scope, cwd),
+            ref: scope === 'project' ? RELEASE_REF : 'v0.2.1',
+            path:
+              scope === 'project'
+                ? path.join(cwd, '.agents', 'skills', 'notifai')
+                : path.join(cwd, 'home', '.agents', 'skills', 'notifai'),
+          },
+        ],
+      }),
+    }
+
+    const readiness = await assessReadiness({ ...makeDeps(io, client), cwd, nativeSkills })
+    const skill = readiness.states.find((state) => state.id === 'skill')
+    expect(skill).toMatchObject({
+      status: 'gap',
+      detail: `project (${RELEASE_REF}) and global (v0.2.1) are both installed, so the harness lists both. Keep either project or global and uninstall the other.`,
+      technical: {
+        project: {
+          ref: RELEASE_REF,
+          path: path.join(cwd, '.agents', 'skills', 'notifai'),
+          current: true,
+        },
+        global: {
+          ref: 'v0.2.1',
+          path: path.join(cwd, 'home', '.agents', 'skills', 'notifai'),
+          current: false,
+        },
+        resolution: 'both-listed',
+      },
+    })
+
+    expect(await doctorCommand({ ...makeDeps(io, client), cwd, nativeSkills }, { json: true })).toBe(
+      EXIT.failed,
+    )
+    const payload = JSON.parse(io.outLines[0] ?? '{}') as {
+      ok: boolean
+      states: Array<{ id: string; status: string; detail: string }>
+    }
+    expect(payload.ok).toBe(false)
+    expect(payload.states.find((state) => state.id === 'skill')).toMatchObject({
+      status: 'gap',
+      detail: expect.stringContaining('harness lists both'),
+    })
+  })
+
+  it('does not treat a current pin as ready when a stale duplicate is also installed', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'assess-skill-shadow-'))
+    const io = new CapturedIo()
+    const client = {
+      health: async () => true,
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+      listDevices: async () => ({ devices: [] }),
+    } as unknown as ApiClient
+    const nativeSkills: NativeSkills = {
+      add: async () => 0,
+      remove: async () => 0,
+      list: async (scope) => ({
+        skills: [
+          {
+            ...managedSkill(scope, cwd),
+            ref: scope === 'global' ? RELEASE_REF : 'v0.2.1',
+          },
+        ],
+      }),
+    }
+
+    const readiness = await assessReadiness(
+      { ...makeDeps(io, client), cwd, nativeSkills },
+      { skillScope: 'global' },
+    )
+    expect(readiness.states.find((state) => state.id === 'skill')).toMatchObject({
+      status: 'gap',
+      detail: `project (v0.2.1) and global (${RELEASE_REF}) are both installed, so the harness lists both. Keep either project or global and uninstall the other.`,
+    })
+  })
+
+  it('uninstalls the other skill scope before installing the chosen one', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-skill-duplicate-prevented-'))
+    const io = new CapturedIo()
+    const removed: SkillScope[] = []
+    const added: Array<SkillScope | undefined> = []
+    let globalPresent = true
+    const nativeSkills: NativeSkills = {
+      add: async (options) => {
+        added.push(options.scope)
+        return 0
+      },
+      remove: async (options) => {
+        removed.push(options.scope)
+        if (options.scope === 'global') globalPresent = false
+        return 0
+      },
+      list: async (scope) => ({
+        skills: scope === 'global' && globalPresent ? [{ ...managedSkill('global', cwd), ref: 'v0.2.1' }] : [],
+      }),
+    }
+
+    expect(
+      await initCommand(setupReadyDeps(io, cwd, nativeSkills, { submit: 0 }), {
+        skills: true,
+        setupScope: 'project',
+        hooks: false,
+      }),
+    ).toBe(EXIT.ok)
+    expect(removed).toEqual(['global'])
+    expect(added).toEqual(['project'])
+  })
+
+  it('clears a pre-existing skill duplicate by keeping the chosen setup scope', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-skill-duplicate-clear-'))
+    const io = new CapturedIo()
+    const removed: SkillScope[] = []
+    const present = new Set<SkillScope>(['project', 'global'])
+    const nativeSkills: NativeSkills = {
+      add: async (options) => {
+        if (options.scope !== undefined) present.add(options.scope)
+        return 0
+      },
+      remove: async (options) => {
+        removed.push(options.scope)
+        present.delete(options.scope)
+        return 0
+      },
+      list: async (scope) => ({
+        skills: present.has(scope)
+          ? [
+              {
+                ...managedSkill(scope, cwd),
+                ref: scope === 'project' ? RELEASE_REF : 'v0.2.1',
+              },
+            ]
+          : [],
+      }),
+    }
+
+    expect(
+      await initCommand(setupReadyDeps(io, cwd, nativeSkills, { submit: 0 }), {
+        skills: true,
+        setupScope: 'project',
+        hooks: false,
+      }),
+    ).toBe(EXIT.ok)
+    expect(removed).toEqual(['global'])
+    expect([...present]).toEqual(['project'])
+  })
+
+  it('updates the existing skill scope instead of adding a second copy', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-skill-update-existing-'))
+    const io = new InteractiveIo()
+    const received: Array<SkillScope | undefined> = []
+    const installed = true
+    const nativeSkills: NativeSkills = {
+      add: async (options) => {
+        received.push(options.scope)
+        return 0
+      },
+      remove: async () => 0,
+      list: async (scope) => ({
+        skills: installed && scope === 'global' ? [{ ...managedSkill('global', cwd), ref: 'v0.2.1' }] : [],
+      }),
+    }
+
+    expect(
+      await initCommand(setupReadyDeps(io, cwd, nativeSkills, { submit: 0 }), {
+        skills: true,
+        hooks: false,
+      }),
+    ).toBe(EXIT.ok)
+    expect(received).toEqual(['global'])
+    expect(io.outLines.join('\n')).toContain('global scope')
+  })
+
   it('requires an explicit skill scope before unattended installation', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-skill-scope-required-'))
     const io = new CapturedIo()
@@ -3751,6 +4624,7 @@ describe('init', () => {
         addCalls += 1
         return 0
       },
+      remove: async () => 0,
       list: async () => ({ skills: [] }),
     }
 
@@ -3758,7 +4632,7 @@ describe('init', () => {
       EXIT.usage,
     )
     expect(addCalls).toBe(0)
-    expect(io.errLines.join('\n')).toContain('--skills-scope project')
+    expect(io.errLines.join('\n')).toContain('--setup-scope project')
   })
 
   it('rejects an invalid unattended skill scope instead of guessing', async () => {
@@ -3786,6 +4660,7 @@ describe('init', () => {
           installed = true
           return 0
         },
+        remove: async () => 0,
         list: async (selected) => ({
           skills: installed && selected === scope ? [managedSkill(scope, cwd)] : [],
         }),
@@ -3802,27 +4677,82 @@ describe('init', () => {
     },
   )
 
-  it('lets the native interactive flow choose scope and resumes after cancellation', async () => {
-    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-skill-cancelled-'))
+  it('asks one setup-scope question and passes that scope to the native installer', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-skill-setup-scope-ask-'))
     const io = new InteractiveIo()
+    io.selectAnswer = 'project'
     const calls: { submit: number } = { submit: 0 }
-    let receivedScope: SkillScope | undefined = 'global'
+    let receivedScope: SkillScope | undefined
     const nativeSkills: NativeSkills = {
       add: async (options) => {
         receivedScope = options.scope
         return 0
       },
+      remove: async () => 0,
       list: async () => ({ skills: [] }),
     }
 
     expect(await initCommand(setupReadyDeps(io, cwd, nativeSkills, calls), { skills: true, hooks: false })).toBe(
       EXIT.ok,
     )
-    expect(receivedScope).toBeUndefined()
+    expect(io.prompts[0]).toContain('this project only, or to every project on this machine')
+    expect(receivedScope).toBe('project')
     expect(calls.submit).toBe(1)
     expect(io.outLines.join('\n')).toContain('All set.')
   })
 
+  it('accepts --setup-scope as the unattended skill, hooks, and config scope', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-setup-scope-flag-'))
+    const io = new CapturedIo()
+    let receivedScope: SkillScope | undefined
+    const nativeSkills: NativeSkills = {
+      add: async (options) => {
+        receivedScope = options.scope
+        return 0
+      },
+      remove: async () => 0,
+      list: async (scope) => ({
+        skills: receivedScope === scope ? [managedSkill(scope, cwd)] : [],
+      }),
+    }
+
+    expect(
+      await initCommand(setupReadyDeps(io, cwd, nativeSkills, { submit: 0 }), {
+        skills: true,
+        setupScope: 'project',
+        hooks: false,
+      }),
+    ).toBe(EXIT.ok)
+    expect(receivedScope).toBe('project')
+    expect(existsSync(path.join(cwd, '.notifai', 'config.toml'))).toBe(true)
+  })
+
+  it('stamps project identity outside the repo when setup-scope is global', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-setup-scope-global-config-'))
+    const io = new CapturedIo()
+    const deps: CommandDeps = {
+      ...makeDeps(io, {} as ApiClient),
+      cwd,
+      env: isolatedEnv(cwd),
+      store: { load: () => null, save: () => {}, clear: () => {}, describe: () => 'empty store' },
+    }
+
+    expect(await initCommand(deps, { setupScope: 'global', skills: false, hooks: false })).toBe(EXIT.failed)
+    expect(existsSync(path.join(cwd, '.notifai', 'config.toml'))).toBe(false)
+    expect(readFileSync(personalProjectConfigPath(cwd, deps.env), 'utf8')).toMatch(/project = "/)
+  })
+
+  it('rejects disagreeing --setup-scope and --skills-scope', async () => {
+    const io = new CapturedIo()
+    expect(
+      await initCommand(
+        { ...makeDeps(io, {} as ApiClient), cwd: mkdtempSync(path.join(os.tmpdir(), 'init-scope-conflict-')) },
+        { skills: true, setupScope: 'project', skillsScope: 'global' },
+      ),
+    ).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toContain('disagree')
+  })
+
   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'))
@@ -3831,6 +4761,7 @@ describe('init', () => {
     const calls = { submit: 0 }
     const nativeSkills: NativeSkills = {
       add: async () => 0,
+      remove: async () => 0,
       list: async () => ({ skills: [] }),
     }
     const deps = setupReadyDeps(io, cwd, nativeSkills, calls)
@@ -3855,6 +4786,7 @@ describe('init', () => {
     const calls = { submit: 0 }
     const nativeSkills: NativeSkills = {
       add: async () => 0,
+      remove: async () => 0,
       list: async () => ({ skills: [] }),
     }
     const deps = setupReadyDeps(io, cwd, nativeSkills, calls)
@@ -3872,6 +4804,7 @@ describe('init', () => {
     const calls: { submit: number } = { submit: 0 }
     const nativeSkills: NativeSkills = {
       add: async () => 1,
+      remove: async () => 0,
       list: async () => ({ skills: [] }),
     }
 
@@ -4012,6 +4945,7 @@ describe('init', () => {
       nativeSkills: {
         list: async () => ({ skills: [] }),
         add: async () => 0,
+        remove: async () => 0,
       } satisfies NativeSkills,
     }
 
@@ -4109,7 +5043,7 @@ describe('init', () => {
     )
     expect(io.outLines.join('\n')).toContain('All set.')
     expect(submitCalls).toBe(1)
-    expect(submittedDraft?.draft.event).toBe('setup_verified')
+    expect(submittedDraft?.draft).not.toHaveProperty('event')
     expect(submittedDraft?.draft.targets).toEqual({ mode: 'selected', device_ids: ['dev_iphone'] })
 
     io.outLines = []
@@ -4267,6 +5201,52 @@ describe('init', () => {
     expect(io.outLines.join('\n')).toContain('All set.')
   })
 
+  it('replaces a stale unknown setup proof instead of rechecking it forever', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-proof-stale-'))
+    const io = new CapturedIo()
+    let submitCalls = 0
+    const client = {
+      health: async () => true,
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+      listDevices: async () => ({ devices: [readyIphone] }),
+      submit: async () => {
+        submitCalls += 1
+        return setupReceipt('req_fresh')
+      },
+      evidence: async (requestId: string) =>
+        setupEvidence(
+          requestId,
+          requestId === 'req_fresh'
+            ? {
+                state: 'observed',
+                observed_at: '2026-08-25T00:00:02.000Z',
+                latency_ms: 1_000,
+              }
+            : { state: 'unknown', observed_at: null, latency_ms: null },
+        ),
+    } as unknown as ApiClient
+    const now = Date.parse('2026-08-25T00:00:00.000Z')
+    mkdirSync(path.join(cwd, '.notifai'), { recursive: true })
+    writeFileSync(path.join(cwd, '.notifai', 'config.toml'), 'project = "stale-proof"\n')
+    const deps: CommandDeps = {
+      ...makeDeps(io, client),
+      cwd,
+      env: isolatedEnv(cwd),
+      now: () => now,
+    }
+    writeSetupProof(deps, {
+      request_id: 'req_old',
+      device_id: readyIphone.device_id,
+      project: 'stale-proof',
+      started_at: new Date(now - SETUP_PROOF_STALE_MS - 1).toISOString(),
+    })
+
+    expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.ok)
+    expect(submitCalls).toBe(1)
+    expect(io.outLines.join('\n')).toContain('older than 24h without a Companion Receipt')
+    expect(io.outLines.join('\n')).toContain('All set.')
+  })
+
   it('reports a proof-state write failure instead of crashing or sending twice', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-proof-unwritable-'))
     const io = new CapturedIo()
@@ -4386,42 +5366,6 @@ describe('init', () => {
     )
   })
 
-  it('stops login when the approval page reports no Alpha access', async () => {
-    const io = new CapturedIo()
-    let now = 0
-    let polls = 0
-    const client = {
-      beginPairing: async () => ({
-        pairing_id: 'pair_no_plan',
-        code: 'NOPE-PLAN',
-        approve_url: 'https://test.notifai.invalid/approve?code=NOPE-PLAN',
-        expires_at: new Date(60_000).toISOString(),
-        poll_interval_seconds: 1,
-      }),
-      pollPairing: async () => {
-        polls += 1
-        return {
-          status: 'no_active_plan' as const,
-          next_action: 'Open https://test.notifai.invalid/support to request Alpha access, then retry.',
-        }
-      },
-    } as unknown as ApiClient
-    const deps = {
-      ...makeDeps(io, client),
-      now: () => now,
-      sleep: async (milliseconds: number) => {
-        now += milliseconds
-      },
-    }
-
-    expect(await loginCommand(deps, { open: false })).toBe(EXIT.auth)
-    expect(polls).toBe(1)
-    expect(io.errLines.join('\n')).toContain('no active plan or temporary Alpha access')
-    expect(io.errLines.join('\n')).toContain(
-      'Open https://test.notifai.invalid/support to request Alpha access, then retry.',
-    )
-  })
-
   it('treats a revoked credential as the one blocker and points back to pairing', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-revoked-'))
     const io = new CapturedIo()
@@ -4446,7 +5390,7 @@ describe('init', () => {
     expect(out.match(/^Next:/gm)).toHaveLength(1)
   })
 
-  it('scopes proof to each project worktree even on the same paired machine', async () => {
+  it('reuses proof across worktrees of one Project on the same Approved Machine', async () => {
     const stateRoot = mkdtempSync(path.join(os.tmpdir(), 'init-worktrees-state-'))
     let submitCalls = 0
     const client = {
@@ -4478,7 +5422,62 @@ describe('init', () => {
       ).toBe(EXIT.ok)
     }
 
-    expect(submitCalls).toBe(2)
+    expect(submitCalls).toBe(1)
+  })
+
+  it('returns one authoritative structured final readiness without duplicate probes', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-json-ready-'))
+    const io = new InteractiveIo()
+    let healthCalls = 0
+    let compatibilityCalls = 0
+    let deviceCalls = 0
+    const client = {
+      health: async () => {
+        healthCalls += 1
+        return true
+      },
+      compatibility: async () => {
+        compatibilityCalls += 1
+        return currentCompatibility
+      },
+      listDevices: async () => {
+        deviceCalls += 1
+        return { devices: [readyIphone] }
+      },
+      evidence: async (requestId: string) =>
+        setupEvidence(requestId, {
+          state: 'observed',
+          observed_at: '2026-08-25T00:00:02.000Z',
+          latency_ms: 1_000,
+        }),
+    } as unknown as ApiClient
+    mkdirSync(path.join(cwd, '.notifai'), { recursive: true })
+    writeFileSync(path.join(cwd, '.notifai', 'config.toml'), 'project = "json-ready"\n')
+    const deps = { ...makeDeps(io, client), cwd, env: isolatedEnv(cwd) }
+    writeSetupProof(deps, {
+      request_id: 'req_json_ready',
+      device_id: readyIphone.device_id,
+      project: 'json-ready',
+      started_at: '2026-08-25T00:00:00.000Z',
+    })
+
+    expect(await initCommand(deps, { json: true, hooks: false, skills: false })).toBe(EXIT.ok)
+    expect(io.prompts).toEqual([])
+    expect(io.outLines).toHaveLength(1)
+    const result = JSON.parse(io.outLines[0] ?? '{}') as {
+      ready: boolean
+      can_send: boolean
+      question_routing_ready: boolean
+      states: Array<{ id: string; status: string; remedy: unknown }>
+    }
+    expect(result.ready).toBe(true)
+    expect(result.can_send).toBe(true)
+    expect(result.question_routing_ready).toBe(false)
+    expect(result.states.length).toBeGreaterThan(8)
+    expect(result.states.every((state) => 'remedy' in state)).toBe(true)
+    expect(healthCalls).toBe(1)
+    expect(compatibilityCalls).toBe(1)
+    expect(deviceCalls).toBe(1)
   })
 })
 
@@ -4600,6 +5599,54 @@ describe('readiness assessment cost', () => {
       detail: `installed from ${SKILLS_SOURCE} in the project scope`,
     })
   })
+
+  it('detects a lock-file duplicate across project and global scope', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'assess-lock-skill-duplicate-'))
+    const env = { ...isolatedEnv(cwd), PATH: '/nonexistent' }
+    writeFileSync(
+      path.join(cwd, 'skills-lock.json'),
+      `${JSON.stringify({
+        skills: {
+          notifai: {
+            source: 'Raidiant-io/notifai',
+            sourceType: 'github',
+            ref: RELEASE_REF,
+          },
+        },
+      })}\n`,
+    )
+    mkdirSync(path.join(env.XDG_STATE_HOME!, 'skills'), { recursive: true })
+    writeFileSync(
+      path.join(env.XDG_STATE_HOME!, 'skills', '.skill-lock.json'),
+      `${JSON.stringify({
+        skills: {
+          notifai: {
+            source: 'Raidiant-io/notifai',
+            sourceType: 'github',
+            ref: 'v0.2.1',
+          },
+        },
+      })}\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,
+      nativeSkills: realNativeSkills,
+    })
+    expect(readiness.states.find((state) => state.id === 'skill')).toMatchObject({
+      status: 'gap',
+      detail: `project (${RELEASE_REF}) and global (v0.2.1) are both installed, so the harness lists both. Keep either project or global and uninstall the other.`,
+      technical: { resolution: 'both-listed' },
+    })
+  })
 })
 
 describe('an outage is not an answer', () => {
@@ -4750,8 +5797,8 @@ describe('asking before the hooks have ever run', () => {
 
     expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
     const said = io.errLines.join(' ')
-    expect(said).toMatch(/active Codex session/i)
-    expect(said).toContain('notifai hooks install --harness codex')
+    expect(said).toMatch(/Codex hooks are not installed/i)
+    expect(said).toContain('notifai init --json')
     expect(said).not.toMatch(/Claude Code: send one new prompt|OpenCode: restart/)
   })
 
@@ -4768,12 +5815,13 @@ 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-other-thread', env, { last_prompt_at: 42 })
+    trustInstalledCodexHooks(cwd, env)
+    writeSessionState('codex-other-thread', env, { harness: 'codex', last_prompt_at: 42 })
     writeProjectSession(cwd, env, 'codex-other-thread', 42, 'codex')
     io.outLines = []
 
     expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
-    expect(io.errLines.join(' ')).toMatch(/active Codex session:.*has not published/i)
+    expect(io.errLines.join(' ')).toMatch(/exact Codex session has not fired UserPromptSubmit/i)
     expect(io.outLines).not.toContain(
       'Question registered. Ask it in the conversation as usual and end your turn.',
     )
@@ -4793,16 +5841,14 @@ describe('asking before the hooks have ever run', () => {
 
     expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
     trustInstalledCodexHooks(cwd, env)
-    writeSessionState('codex-current-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeSessionState('codex-current-thread', env, { harness: 'codex', 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 })
+    writeSessionState('claude-concurrent', env, { harness: 'claude-code', last_prompt_at: 43, last_stop_at: 43 })
     writeProjectSession(cwd, env, 'claude-concurrent', 43, 'claude-code')
     io.outLines = []
 
     expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.ok)
-    expect(io.outLines).toContain(
-      'Question registered. Ask it in the conversation, state the concrete work you will resume when the answer arrives, then end your turn.',
-    )
+    expect(io.outLines.some((line) => line.startsWith('Question registered (q_'))).toBe(true)
     expect(readSessionState('codex-current-thread', env).pending?.[0]?.source).toMatchObject({
       session_id: 'codex-current-thread',
       harness: 'codex',
@@ -4812,6 +5858,49 @@ describe('asking before the hooks have ever run', () => {
     ).toBe('Gentle Salmon')
   })
 
+  it('uses exact lifecycle state across checkouts while Project stays invocation-owned', () => {
+    const first = scratchDir('notifai-exact-session-first-')
+    const second = scratchDir('notifai-exact-session-second-')
+    const io = new CapturedIo()
+    const env = {
+      ...isolatedEnv(first),
+      CLAUDECODE: '1',
+      CLAUDE_CODE_SESSION_ID: 'claude-cross-checkout',
+    }
+    const firstDeps = { ...makeDeps(io, {} as ApiClient), cwd: first, env, now: () => 42 }
+    expect(
+      hooksInstallCommand(firstDeps, {
+        harness: 'claude-code',
+        execPath,
+        scriptPath,
+      }),
+    ).toBe(EXIT.ok)
+    writeSessionState('claude-cross-checkout', env, {
+      harness: 'claude-code',
+      activation_cwd: first,
+      last_prompt_at: 42,
+      last_stop_at: 41,
+    })
+    writeProjectSession(first, env, 'claude-cross-checkout', 42, 'claude-code')
+    mkdirSync(path.join(second, '.notifai'), { recursive: true })
+    writeFileSync(
+      path.join(second, '.notifai', 'config.toml'),
+      'project = "second-project"\nask_notifications = false\n',
+    )
+    mkdirSync(path.dirname(sessionConfigPath('claude-cross-checkout', env)), { recursive: true })
+    writeFileSync(sessionConfigPath('claude-cross-checkout', env), 'ask_notifications = true\n')
+    io.outLines = []
+
+    const secondDeps = { ...firstDeps, cwd: second }
+    expect(askCommand(secondDeps, 'Use this checkout?', {})).toBe(EXIT.ok)
+    const pending = readSessionState('claude-cross-checkout', env).pending?.[0]
+    expect(pending?.project).toBe('second-project')
+    expect(pending?.source).toMatchObject({
+      session_id: 'claude-cross-checkout',
+      harness: 'claude-code',
+    })
+  })
+
   it('uploads ask images before registration and freezes canonical body media', async () => {
     const cwd = scratchDir('notifai-ask-media-')
     const first = path.join(cwd, 'first.png')
@@ -4846,7 +5935,7 @@ describe('asking before the hooks have ever run', () => {
 
     expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
     trustInstalledCodexHooks(cwd, env)
-    writeSessionState('codex-media-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeSessionState('codex-media-thread', env, { harness: 'codex', last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'codex-media-thread', 42, 'codex')
     io.outLines = []
 
@@ -4897,7 +5986,7 @@ describe('asking before the hooks have ever run', () => {
       hooksInstallCommand(deps, { harness: 'claude-code', global: true, execPath, scriptPath }),
     ).toBe(EXIT.ok)
     trustInstalledCodexHooks(cwd, env)
-    writeSessionState('codex-current-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeSessionState('codex-current-thread', env, { harness: 'codex', last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'codex-current-thread', 42, 'codex')
     io.outLines = []
 
@@ -4927,9 +6016,9 @@ describe('asking before the hooks have ever run', () => {
     trustInstalledCodexHooks(cwd, env)
     // Both sessions are live here. The parent fired when its own turn began;
     // the child fired for the turn that is running this command.
-    writeSessionState('codex-orchestrator', env, { last_prompt_at: 40, last_stop_at: 39 })
+    writeSessionState('codex-orchestrator', env, { harness: 'codex', last_prompt_at: 40, last_stop_at: 39 })
     writeProjectSession(cwd, env, 'codex-orchestrator', 40, 'codex')
-    writeSessionState('claude-current', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeSessionState('claude-current', env, { harness: 'claude-code', last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'claude-current', 42, 'claude-code')
     io.outLines = []
 
@@ -4962,7 +6051,7 @@ describe('asking before the hooks have ever run', () => {
     expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
       EXIT.ok,
     )
-    writeSessionState('orca-claude-question', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeSessionState('orca-claude-question', env, { harness: 'claude-code', last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'orca-claude-question', 42, 'claude-code')
     io.outLines = []
 
@@ -4990,7 +6079,7 @@ describe('asking before the hooks have ever run', () => {
       hooksInstallCommand(deps, { harness: 'claude-code', global: true, execPath, scriptPath }),
     ).toBe(EXIT.ok)
     trustInstalledCodexHooks(cwd, env)
-    writeSessionState('codex-current-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeSessionState('codex-current-thread', env, { harness: 'codex', last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'codex-current-thread', 42, 'codex')
 
     const readiness = await assessReadiness(deps)
@@ -5024,11 +6113,11 @@ describe('asking before the hooks have ever run', () => {
     const fired = readiness.states.find((state) => state.id === 'hooks-fired')
     expect(fired?.status).toBe('optional-gap')
     expect(fired?.detail).toMatch(/Claude Code/)
-    expect(fired?.detail).toMatch(/Codex: send one prompt/)
+    expect(fired?.detail).toMatch(/Codex: approve[\s\S]*start one fresh session/i)
 
     io.errLines = []
     expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
-    expect(io.errLines.join(' ')).toMatch(/Several harness markers are present/i)
+    expect(io.errLines.join(' ')).toMatch(/Several harness sessions could own this shell/i)
   })
 
   it('makes one work-resumption commitment per offered answer part of the asking turn', () => {
@@ -5045,7 +6134,7 @@ describe('asking before the hooks have ever run', () => {
 
     expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
     trustInstalledCodexHooks(cwd, env)
-    writeSessionState('codex-commitment-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeSessionState('codex-commitment-thread', env, { harness: 'codex', last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'codex-commitment-thread', 42, 'codex')
     io.outLines = []
 
@@ -5081,7 +6170,7 @@ describe('asking before the hooks have ever run', () => {
 
     expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
     trustInstalledCodexHooks(cwd, env)
-    writeSessionState('codex-free-text-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeSessionState('codex-free-text-thread', env, { harness: 'codex', last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'codex-free-text-thread', 42, 'codex')
     io.outLines = []
 
@@ -5113,7 +6202,7 @@ describe('asking before the hooks have ever run', () => {
       configFile,
       readFileSync(configFile, 'utf8').replace(codexHookIdentityHash(stop!), 'sha256:obsolete'),
     )
-    writeSessionState('codex-current-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeSessionState('codex-current-thread', env, { harness: 'codex', last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'codex-current-thread', 42, 'codex')
     io.outLines = []
 
@@ -5144,6 +6233,7 @@ describe('asking before the hooks have ever run', () => {
     } as unknown as ApiClient
     const nativeSkills: NativeSkills = {
       add: async () => 0,
+      remove: async () => 0,
       list: async (scope) => ({
         skills:
           scope === 'global'
@@ -5187,12 +6277,12 @@ describe('asking before the hooks have ever run', () => {
     expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
       EXIT.ok,
     )
-    writeSessionState('claude-other', env, { last_prompt_at: 42 })
+    writeSessionState('claude-other', env, { harness: 'claude-code', last_prompt_at: 42 })
     writeProjectSession(cwd, env, 'claude-other', 42, 'claude-code')
     io.outLines = []
 
     expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
-    expect(io.errLines.join(' ')).toMatch(/active Claude Code session:.*has not published/i)
+    expect(io.errLines.join(' ')).toMatch(/exact Claude Code session has not fired UserPromptSubmit/i)
   })
 
   it('accepts a Claude Code subprocess when its documented session id owns the pointer', () => {
@@ -5210,7 +6300,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, last_stop_at: 41 })
+    writeSessionState('claude-parent-loop', env, { harness: 'claude-code', last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'claude-parent-loop', 42, 'claude-code')
     io.outLines = []
 
@@ -5231,7 +6321,7 @@ describe('asking before the hooks have ever run', () => {
     expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
       EXIT.ok,
     )
-    writeSessionState('claude-last-writer', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeSessionState('claude-last-writer', env, { harness: 'claude-code', last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'claude-last-writer', 42, 'claude-code')
     io.outLines = []
 
@@ -5260,7 +6350,7 @@ describe('asking before the hooks have ever run', () => {
       }),
     })
     trustInstalledCodexHooks(cwd, env)
-    writeSessionState('codex-current-thread', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeSessionState('codex-current-thread', env, { harness: 'codex', last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'codex-current-thread', 42, 'codex')
     io.outLines = []
 
@@ -5283,7 +6373,7 @@ describe('asking before the hooks have ever run', () => {
     expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
       EXIT.ok,
     )
-    writeSessionState('claude-current', env, { last_prompt_at: 42 })
+    writeSessionState('claude-current', env, { harness: 'claude-code', last_prompt_at: 42 })
     writeProjectSession(cwd, env, 'claude-current', 42, 'claude-code')
     io.outLines = []
 
@@ -5308,12 +6398,12 @@ describe('asking before the hooks have ever run', () => {
     }
     const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
     expect(hooksInstallCommand(deps, { harness: 'opencode', execPath, scriptPath })).toBe(EXIT.ok)
-    writeSessionState('opencode-other', env, { last_prompt_at: 42 })
+    writeSessionState('opencode-other', env, { harness: 'opencode', last_prompt_at: 42 })
     writeProjectSession(cwd, env, 'opencode-other', 42, 'opencode')
     io.outLines = []
 
     expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
-    expect(io.errLines.join(' ')).toMatch(/active OpenCode session:.*has not published/i)
+    expect(io.errLines.join(' ')).toMatch(/no proven answer continuation/i)
   })
 
   it('rejects OpenCode before registration even with an exact matching pointer', () => {
@@ -5328,7 +6418,7 @@ describe('asking before the hooks have ever run', () => {
     }
     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 })
+    writeSessionState('opencode-current', env, { harness: 'opencode', last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'opencode-current', 42, 'opencode')
     io.outLines = []
 
@@ -5347,7 +6437,7 @@ 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, last_stop_at: 41 })
+    writeSessionState('cursor-live', env, { harness: 'cursor', last_prompt_at: 42, last_stop_at: 41 })
     writeProjectSession(cwd, env, 'cursor-live', 42, 'cursor')
     io.outLines = []
 
@@ -5370,7 +6460,7 @@ 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-live', env, { last_prompt_at: 42 })
+    writeSessionState('codex-live', env, { harness: 'codex', last_prompt_at: 42 })
     writeProjectSession(cwd, env, 'codex-live', 42, 'codex')
     io.outLines = []
 
@@ -5401,7 +6491,7 @@ describe('asking before the hooks have ever run', () => {
 
     const pointer = readiness.states.find((s) => s.id === 'hooks-active-session')
     expect(pointer?.status).toBe('optional-gap')
-    expect(pointer?.detail).toMatch(/has not published a live pointer/)
+    expect(pointer?.detail).toMatch(/has not published exact lifecycle state/)
     expect(pointer?.remedy?.summary).toMatch(/send one Claude Code prompt/)
     expect(pointer?.remedy?.by === 'user-here' ? pointer.remedy.command : '').toBe(
       'notifai doctor',
@@ -5447,6 +6537,28 @@ describe('asking before the hooks have ever run', () => {
     expect(io.outLines.join('\n')).toMatch(/ok\s+Turn\-end hook shape/)
   })
 
+  it('diagnoses an older hook install that lacks proactive lifecycle handlers', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-doctor-missing-lifecycle-'))
+    const io = new PlainInteractiveIo()
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
+    expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
+      EXIT.ok,
+    )
+    const settingsPath = path.join(cwd, '.claude', 'settings.local.json')
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8')) as {
+      hooks: Record<string, unknown>
+    }
+    delete settings.hooks.SessionStart
+    delete settings.hooks.SubagentStart
+    writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`)
+
+    const readiness = await assessReadiness(deps)
+    const current = readiness.states.find((state) => state.id === 'hooks-stale')
+    expect(current?.status).toBe('gap')
+    expect(current?.detail).toMatch(/missing session-start, subagent-start/i)
+    expect(current?.detail).toMatch(/notifai hooks install/i)
+  })
+
   it('names an old blocking Claude Stop handler as the reason no wake can happen', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-doctor-stale-shape-'))
     const io = new PlainInteractiveIo()
@@ -5598,7 +6710,7 @@ describe('asking before the hooks have ever run', () => {
     expect(payload).toMatchObject({ ok: false, exit_code: EXIT.failed })
   })
 
-  it('tells Claude Code to send a prompt without falsely requiring a restart', () => {
+  it('returns a stable exact-session failure when lifecycle context is absent', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-firstrun-'))
     mkdirSync(path.join(cwd, '.claude'), { recursive: true })
     applyPlan(path.join(cwd, '.claude', 'settings.local.json'), {
@@ -5610,13 +6722,18 @@ describe('asking before the hooks have ever run', () => {
     const io = new CapturedIo()
     const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: { XDG_STATE_HOME: cwd } }
 
-    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
-    const said = io.errLines.join(' ')
-    expect(said).toMatch(/project hook files reload without a restart/i)
-    expect(said).not.toMatch(/Run `notifai hooks install` and send one prompt/)
+    expect(askCommand(deps, 'Ship it?', { json: true })).toBe(EXIT.usage)
+    expect(JSON.parse(io.outLines.at(-1) ?? '{}')).toMatchObject({
+      ok: false,
+      registered: false,
+      code: 'session_identity_missing',
+      check_id: 'exact_session',
+      exit_code: EXIT.usage,
+      remedy: expect.stringMatching(/exact session|blocking/i),
+    })
   })
 
-  it('gives Cursor its prompt-and-doctor activation path', () => {
+  it('does not guess a Cursor conversation when lifecycle context is absent', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-cursor-first-run-'))
     const io = new CapturedIo()
     const deps = {
@@ -5628,11 +6745,14 @@ describe('asking before the hooks have ever run', () => {
     expect(hooksInstallCommand(deps, { harness: 'cursor', execPath, scriptPath })).toBe(EXIT.ok)
     io.outLines = []
 
-    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
-    expect(io.errLines.join(' ')).toMatch(/Cursor: send one prompt, then run `notifai doctor`/)
+    expect(askCommand(deps, 'Ship it?', { json: true })).toBe(EXIT.usage)
+    expect(JSON.parse(io.outLines.at(-1) ?? '{}')).toMatchObject({
+      code: 'session_identity_missing',
+      check_id: 'exact_session',
+    })
   })
 
-  it('keeps OpenCode activation separate from unsupported answer continuation', () => {
+  it('does not infer OpenCode from an installed adapter alone', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-opencode-first-run-'))
     const io = new CapturedIo()
     const deps = {
@@ -5647,13 +6767,14 @@ describe('asking before the hooks have ever run', () => {
     expect(hooksInstallCommand(deps, { harness: 'opencode', execPath, scriptPath })).toBe(EXIT.ok)
     io.outLines = []
 
-    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('non-blocking question continuation is intentionally unsupported')
+    expect(askCommand(deps, 'Ship it?', { json: true })).toBe(EXIT.usage)
+    expect(JSON.parse(io.outLines.at(-1) ?? '{}')).toMatchObject({
+      code: 'session_identity_missing',
+      check_id: 'exact_session',
+    })
   })
 
-  it('says to install when nothing is installed at all', () => {
+  it('does not turn missing harness identity into an installation guess', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-noinstall-'))
     const io = new CapturedIo()
     const deps = {
@@ -5668,8 +6789,11 @@ describe('asking before the hooks have ever run', () => {
       },
     }
 
-    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
-    expect(io.errLines.join(' ')).toMatch(/hooks install/)
+    expect(askCommand(deps, 'Ship it?', { json: true })).toBe(EXIT.usage)
+    expect(JSON.parse(io.outLines.at(-1) ?? '{}')).toMatchObject({
+      code: 'session_identity_missing',
+      check_id: 'exact_session',
+    })
   })
 })