@raidiant/notifai 0.1.7 → 0.2.0

package/src/commands.test.ts

@@ -13,6 +13,8 @@ import { describe, expect, it } from 'vitest'
 import { ApiCallError, NetworkError, type ApiClient } from './client.js'
 import {
   askCommand,
+  accessStatusCommand,
+  buildQuestions,
   assessReadiness,
   capabilitiesCommand,
   configSetCommand,
@@ -34,10 +36,13 @@ import {
   type CommandSpinner,
 } from './commands.js'
 import { applyPlan, buildHookConfig } from './install-hooks.js'
+import { readSessionState, writeProjectSession, writeSessionState } from './hooks.js'
+import type { NativeSkill, NativeSkills, SkillScope } from './native-skills.js'
 
 class CapturedIo implements CommandIo {
   outLines: string[] = []
   errLines: string[] = []
+  openedUrls: string[] = []
 
   out(line: string) {
     this.outLines.push(line)
@@ -51,12 +56,16 @@ class CapturedIo implements CommandIo {
     return false
   }
 
-  openUrl() {}
+  openUrl(url: string) {
+    this.openedUrls.push(url)
+  }
 }
 
 class InteractiveIo extends CapturedIo {
   interactive = true
   selectAnswer: string | null = 'global'
+  /** When set, answers are consumed in order; falls back to confirmAnswer. */
+  confirmAnswers: boolean[] | null = null
   confirmAnswer = true
   prompts: string[] = []
   notes: { message: string; title?: string }[] = []
@@ -67,6 +76,9 @@ class InteractiveIo extends CapturedIo {
 
   override async confirm(question: string) {
     this.prompts.push(question)
+    if (this.confirmAnswers !== null && this.confirmAnswers.length > 0) {
+      return this.confirmAnswers.shift()!
+    }
     return this.confirmAnswer
   }
 
@@ -163,6 +175,23 @@ function replyResponse(replies: ReplyView[] = []): ListRepliesResponse {
 }
 
 describe('command contracts', () => {
+  it('shows an actionable no-plan access state', async () => {
+    const io = new CapturedIo()
+    const client = {
+      accessStatus: async () => ({
+        status: 'no_active_plan',
+        reason: 'no_active_grant',
+        expires_at: null,
+      }),
+    } as unknown as ApiClient
+
+    expect(await accessStatusCommand(makeDeps(io, client), {})).toBe(EXIT.failed)
+    expect(io.outLines).toEqual([
+      'No active plan or temporary Alpha access for this account.',
+      'next: Open https://test.notifai.invalid/support to request Alpha access, then retry.',
+    ])
+  })
+
   it('renders capability field paths instead of array indexes', async () => {
     const io = new CapturedIo()
     const document: CapabilityDocument = {
@@ -217,9 +246,91 @@ describe('command contracts', () => {
       },
     } as unknown as ApiClient
 
-    expect(await sendCommand(makeDeps(io, client), { title: 'T', body: 'B', badge: -1 })).toBe(EXIT.usage)
+    expect(
+      await sendCommand(makeDeps(io, client), {
+        title: 'T',
+        body: 'B',
+        project: 'Invalid Project!',
+      }),
+    ).toBe(EXIT.usage)
+    expect(submitCalls).toBe(0)
+    expect(io.errLines.join('\n')).toContain('project')
+  })
+
+  it('rejects done plus reply before authentication or submission', async () => {
+    const io = new CapturedIo()
+    let submitCalls = 0
+    const client = {
+      submit: async () => {
+        submitCalls += 1
+        return receipt
+      },
+    } as unknown as ApiClient
+
+    expect(
+      await sendCommand(makeDeps(io, client), {
+        title: 'Done',
+        body: 'Answer?',
+        kind: 'done',
+        reply: true,
+      }),
+    ).toBe(EXIT.usage)
     expect(submitCalls).toBe(0)
-    expect(io.errLines.join('\n')).toContain('platform.ios.badge')
+    expect(io.errLines.join('\n')).toContain('--kind done cannot be combined with --reply')
+  })
+
+  it.each([
+    {
+      flags: { title: 'A title that is deliberately longer than forty characters', body: 'Plain.' },
+      warning: /titles work best around 40/i,
+    },
+    {
+      flags: { title: 'Details', body: '**bold Markdown**' },
+      warning: /--body looks like Markdown.*--detail/i,
+    },
+    {
+      flags: { title: 'Done · build', body: 'All green.' },
+      warning: /Use --kind done/i,
+    },
+    {
+      flags: { title: 'Failed · build', body: 'One integration test failed.' },
+      warning: /Use --kind done/i,
+    },
+    {
+      flags: { title: 'Update', body: 'Still relevant.', ttl: 259_201 },
+      warning: /longer than 72 hours/i,
+    },
+  ])('warns without rejecting a send: $warning', async ({ flags, warning }) => {
+    const io = new CapturedIo()
+    const client = { submit: async () => receipt } as unknown as ApiClient
+
+    expect(await sendCommand(makeDeps(io, client), flags)).toBe(EXIT.ok)
+    expect(io.errLines.join('\n')).toMatch(warning)
+  })
+
+  it('warns when a collapse key comes from machine-global config', async () => {
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-global-collapse-'))
+    const configDir = path.join(root, 'notifai')
+    mkdirSync(configDir, { recursive: true })
+    writeFileSync(path.join(configDir, 'config.toml'), 'collapse_key = "global-key"\n')
+    const io = new CapturedIo()
+    const client = { submit: async () => receipt } as unknown as ApiClient
+    const deps = {
+      ...makeDeps(io, client),
+      env: { XDG_CONFIG_HOME: root },
+      cwd: root,
+    }
+
+    expect(await sendCommand(deps, { title: 'Update', body: 'Still relevant.' })).toBe(EXIT.ok)
+    expect(io.errLines.join('\n')).toMatch(/machine-global config/i)
+  })
+
+  it('removes unmanaged provider fields from the public send flags', () => {
+    const source = readFileSync(new URL('./main.ts', import.meta.url), 'utf8')
+    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')
   })
 
   it('rejects a question nobody will wait for', async () => {
@@ -269,7 +380,10 @@ describe('command contracts', () => {
         replyTimeout: 30,
       }),
     ).toBe(EXIT.ok)
-    expect(submitted?.draft.reply).toEqual({ expires_in_seconds: 3_600 })
+    expect(submitted?.draft.reply).toEqual({
+      expires_in_seconds: 3_600,
+      questions: [{ id: 'q1', text: 'Deploy?' }],
+    })
   })
 
   it('rejects --reply-timeout 0, the other spelling of nobody waiting', async () => {
@@ -431,12 +545,13 @@ describe('command contracts', () => {
     expect(sleeps).toEqual([250])
   })
 
-  it('returns exit 3 with one JSON object when no reply arrives before the timeout', async () => {
+  it('prints an NDJSON receipt before waiting and a result record on exit 3', async () => {
     const io = new CapturedIo()
     let now = 0
     const client = {
       submit: async () => receipt,
       replies: async (_requestId: string, options: { waitSeconds: number }) => {
+        expect(JSON.parse(io.outLines[0] ?? '{}')).toEqual({ type: 'receipt', receipt })
         now += options.waitSeconds * 1_000
         return replyResponse()
       },
@@ -452,13 +567,20 @@ describe('command contracts', () => {
         json: true,
       }),
     ).toBe(EXIT.noReply)
-    expect(io.outLines).toHaveLength(1)
+    expect(io.outLines).toHaveLength(2)
     // `degraded` is part of the shape on every reply wait, not only when it is
     // true: an agent must be able to read it without knowing it might be absent.
-    expect(JSON.parse(io.outLines[0] ?? '{}')).toEqual({ receipt, replies: [], degraded: false })
+    expect(JSON.parse(io.outLines[1] ?? '{}')).toEqual({
+      type: 'reply_result',
+      request_id: receipt.request_id,
+      replies: [],
+      degraded: false,
+    })
+    expect(io.errLines.join('\n')).toContain(`notifai replies ${receipt.request_id}`)
+    expect(io.errLines.join('\n')).toContain(`notifai close ${receipt.request_id}`)
   })
 
-  it('prints the stable send JSON shape when a reply is received', async () => {
+  it('prints the receipt and reply result as two NDJSON records when answered', async () => {
     const io = new CapturedIo()
     const client = {
       submit: async () => receipt,
@@ -474,9 +596,11 @@ describe('command contracts', () => {
         json: true,
       }),
     ).toBe(EXIT.ok)
-    expect(io.outLines).toHaveLength(1)
-    expect(JSON.parse(io.outLines[0] ?? '{}')).toEqual({
-      receipt,
+    expect(io.outLines).toHaveLength(2)
+    expect(JSON.parse(io.outLines[0] ?? '{}')).toEqual({ type: 'receipt', receipt })
+    expect(JSON.parse(io.outLines[1] ?? '{}')).toEqual({
+      type: 'reply_result',
+      request_id: receipt.request_id,
       replies: [reply],
       degraded: false,
     })
@@ -496,6 +620,30 @@ describe('command contracts', () => {
     expect(requested).toEqual({ waitSeconds: 0, afterSeq: 7 })
     expect(io.outLines).toEqual(['reply from iPhone: yes, after the migration'])
   })
+
+  it('resolves replies --pending through the project session pointer and prints its id', async () => {
+    const io = new CapturedIo()
+    const client = {
+      replies: async () => replyResponse([reply]),
+    } as unknown as ApiClient
+    const deps = makeDeps(io, client)
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-pending-replies-'))
+    deps.cwd = root
+    deps.env = {
+      XDG_CONFIG_HOME: path.join(root, 'config'),
+      XDG_STATE_HOME: path.join(root, 'state'),
+    }
+    writeSessionState('pending-session', deps.env, {
+      pending: { question: 'Deploy?', request_id: receipt.request_id },
+    })
+    writeProjectSession(root, deps.env, 'pending-session', Date.now(), 'codex')
+
+    expect(await repliesCommand(deps, undefined, { pending: true })).toBe(EXIT.ok)
+    expect(io.outLines).toEqual([
+      `pending request ${receipt.request_id}`,
+      'reply from iPhone: yes, after the migration',
+    ])
+  })
 })
 
 describe('delivery evidence status', () => {
@@ -549,7 +697,7 @@ describe('delivery evidence status', () => {
     expect(await statusCommand(makeDeps(io, client), 'req_status_test', {})).toBe(EXIT.ok)
     const said = io.outLines.join('\n')
     expect(said).toContain('Provider Acceptance: accepted')
-    expect(said).toContain('Companion Receipt: unknown')
+    expect(said).toContain("Companion Receipt (the app's delivery confirmation): unknown")
     expect(said).toContain('not a failure')
     expect(said).toContain('attempt_started')
   })
@@ -567,7 +715,7 @@ describe('delivery evidence status', () => {
 
     expect(await statusCommand(makeDeps(io, client), 'req_status_test', {})).toBe(EXIT.ok)
     const said = io.outLines.join('\n')
-    expect(said).toContain('Companion Receipt: observed')
+    expect(said).toContain("Companion Receipt (the app's delivery confirmation): observed")
     expect(said).toContain('11m 27s after Provider Acceptance')
   })
 })
@@ -576,7 +724,7 @@ describe('Cursor hook commands', () => {
   const execPath = '/usr/local/bin/node'
   const scriptPath = '/opt/notifai/dist/main.js'
 
-  it('installs native Cursor hooks with a single bounded answer continuation', () => {
+  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 }
@@ -602,7 +750,7 @@ describe('Cursor hook commands', () => {
     )
     expect(installed.hooks['stop']?.[0]).toMatchObject({
       command: expect.stringContaining('hook stop --owner notifai --harness cursor'),
-      loop_limit: 1,
+      loop_limit: 3,
     })
   })
 
@@ -638,7 +786,7 @@ describe('Cursor hook commands', () => {
     expect(io.outLines.some((line) => line.includes('Cursor: send one prompt'))).toBe(true)
   })
 
-  it('uninstalls only NotifAI Cursor hooks and preserves foreign hooks', () => {
+  it('uninstalls only Notifai Cursor hooks and preserves foreign hooks', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-cursor-uninstall-'))
     const io = new CapturedIo()
     const deps = { ...makeDeps(io, {} as ApiClient), cwd }
@@ -714,7 +862,7 @@ describe('harness activation guidance', () => {
     )
 
     expect(io.outLines.join('\n')).toContain('Permission prompts stay in OpenCode.')
-    expect(io.outLines.join('\n')).toContain('cannot reliably resume an idle agent turn')
+    expect(io.outLines.join('\n')).toContain('next user prompt')
     const pluginFile = path.join(cwd, '.opencode', 'plugins', 'notifai.js')
     const plugin = readFileSync(pluginFile, 'utf8')
     expect(plugin).toContain('const TIMEOUT_MS = 540000')
@@ -735,7 +883,7 @@ describe('harness activation guidance', () => {
 describe('projectSlugFrom', () => {
   it('canonicalizes directory names into contract-valid slugs', () => {
     expect(projectSlugFrom('My App')).toBe('my-app')
-    expect(projectSlugFrom('NotifAI')).toBe('notifai')
+    expect(projectSlugFrom('Notifai')).toBe('notifai')
     expect(projectSlugFrom('--weird__Name.2')).toBe('weird__name.2')
     expect(projectSlugFrom('!!!')).toBe('project')
   })
@@ -777,7 +925,7 @@ describe('interactive command UX', () => {
     }
 
     expect(await loginCommand(deps, { name: 'workstation', open: false })).toBe(EXIT.ok)
-    expect(io.intros).toEqual(['NotifAI sign in'])
+    expect(io.intros).toEqual(['Notifai sign in'])
     expect(io.notes).toEqual([
       {
         title: 'Approve this machine',
@@ -785,8 +933,8 @@ describe('interactive command UX', () => {
       },
     ])
     expect(io.spinnerEvents).toEqual([
-      'start:Waiting for approval…',
-      'message:Waiting for approval…',
+      'start:Waiting for approval… code ABCD-EFGH · 10s left',
+      'message:Waiting for approval… code ABCD-EFGH · 9s left',
       'stop:Machine "workstation" approved',
     ])
     expect(io.outLines).toEqual([])
@@ -899,7 +1047,7 @@ describe('interactive command UX', () => {
     }
 
     expect(await doctorCommand(deps, {})).toBe(EXIT.failed)
-    expect(io.intros).toEqual(['NotifAI doctor'])
+    expect(io.intros).toEqual(['Notifai doctor'])
     expect(io.checks.some((check) => !check.ok && check.message.startsWith('This machine:'))).toBe(true)
     expect(io.checks.some((check) => check.ok && check.message.startsWith('Protocol version:'))).toBe(true)
     expect(io.outLines).toEqual([])
@@ -995,6 +1143,47 @@ describe('init', () => {
     }
   }
 
+  function managedSkill(scope: SkillScope, cwd: string): NativeSkill {
+    return {
+      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: 'v0.2.0',
+    }
+  }
+
+  function setupReadyDeps(
+    io: CapturedIo,
+    cwd: string,
+    nativeSkills: NativeSkills,
+    calls: { submit: number },
+  ): CommandDeps {
+    const client = {
+      health: async () => true,
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+      listDevices: async () => ({ devices: [readyIphone] }),
+      submit: async () => {
+        calls.submit += 1
+        return setupReceipt()
+      },
+      evidence: async () =>
+        setupEvidence('req_setup', {
+          state: 'observed',
+          observed_at: '2026-08-05T18:00:02.000Z',
+          latency_ms: 1_000,
+        }),
+    } as unknown as ApiClient
+    return {
+      ...makeDeps(io, client),
+      cwd,
+      env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
+      nativeSkills,
+    }
+  }
+
   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()
@@ -1033,6 +1222,7 @@ describe('init', () => {
     const out = io.outLines.join('\n')
     expect(out).toContain('Next: This machine')
     expect(out).toContain('notifai login')
+    expect(out).toContain('Then re-run `notifai init` and it will pick up from here.')
     // The device gap is real and downstream; it must stay hidden until the
     // sign-in that would let anyone actually check it has happened.
     expect(out).not.toContain('companion app')
@@ -1064,45 +1254,201 @@ describe('init', () => {
   })
 
   it('pins the skill installer to the tagged public release syntax', () => {
-    expect(SKILLS_SOURCE).toBe('RafaelVidaurre/notifai#v0.1.7')
+    expect(SKILLS_SOURCE).toBe('Raidiant-io/notifai#v0.2.0')
     expect(SKILLS_SOURCE).not.toContain('@v')
   })
 
   it('recognizes a skill installed from the exact immutable release', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-pinned-skill-'))
-    mkdirSync(path.join(cwd, '.agents', 'skills', 'notifai'), { recursive: true })
-    writeFileSync(path.join(cwd, '.agents', 'skills', 'notifai', 'SKILL.md'), '# notifai\n')
-    writeFileSync(
-      path.join(cwd, 'skills-lock.json'),
-      `${JSON.stringify(
-        {
-          version: 1,
-          skills: {
-            notifai: {
-              source: 'RafaelVidaurre/notifai',
-              ref: 'v0.1.7',
-              sourceType: 'github',
-              skillPath: 'skills/notifai/SKILL.md',
-            },
-          },
-        },
-        null,
-        2,
-      )}\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 })
+    const nativeSkills: NativeSkills = {
+      add: 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: 'v0.2.0',
+          },
+        ],
+      }),
+    }
+    const readiness = await assessReadiness(
+      { ...makeDeps(io, client), cwd, nativeSkills },
+      { skillScope: 'project' },
+    )
     expect(readiness.states.find((state) => state.id === 'skill')).toMatchObject({
       status: 'ready',
-      detail: `installed from ${SKILLS_SOURCE} in this project`,
+      detail: `installed from ${SKILLS_SOURCE} in the project scope`,
     })
   })
 
+  it.each(['project', 'global'] as const)(
+    'recognizes native installer provenance in the selected %s scope',
+    async (scope) => {
+      const cwd = mkdtempSync(path.join(os.tmpdir(), `init-managed-${scope}-`))
+      const io = new CapturedIo()
+      const client = {
+        health: async () => true,
+        capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+        listDevices: async () => ({ devices: [] }),
+      } as unknown as ApiClient
+      const calls: SkillScope[] = []
+      const nativeSkills: NativeSkills = {
+        add: async () => 0,
+        list: async (selected) => {
+          calls.push(selected)
+          return { skills: [managedSkill(selected, cwd)] }
+        },
+      }
+
+      const readiness = await assessReadiness(
+        { ...makeDeps(io, client), cwd, nativeSkills },
+        { skillScope: scope },
+      )
+      expect(readiness.states.find((state) => state.id === 'skill')).toMatchObject({
+        status: 'ready',
+        detail: `installed from ${SKILLS_SOURCE} in the ${scope} scope`,
+      })
+      expect(calls).toEqual([scope])
+    },
+  )
+
+  it.each(['project', 'global'] as const)(
+    'does not trust unmanaged same-path content in the %s scope',
+    async (scope) => {
+      const cwd = mkdtempSync(path.join(os.tmpdir(), `init-unmanaged-${scope}-`))
+      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,
+        list: async (selected) => ({
+          skills: [{ ...managedSkill(selected, cwd), source: null, sourceType: null, ref: null }],
+        }),
+      }
+
+      const readiness = await assessReadiness(
+        { ...makeDeps(io, client), cwd, nativeSkills },
+        { skillScope: scope },
+      )
+      expect(readiness.states.find((state) => state.id === 'skill')).toMatchObject({
+        status: 'optional-gap',
+        detail: `not installed from ${SKILLS_SOURCE} in ${scope} 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()
+    let addCalls = 0
+    const nativeSkills: NativeSkills = {
+      add: async () => {
+        addCalls += 1
+        return 0
+      },
+      list: async () => ({ skills: [] }),
+    }
+
+    expect(await initCommand({ ...makeDeps(io, {} as ApiClient), cwd, nativeSkills }, { skills: true })).toBe(
+      EXIT.usage,
+    )
+    expect(addCalls).toBe(0)
+    expect(io.errLines.join('\n')).toContain('--skills-scope project')
+  })
+
+  it('rejects an invalid unattended skill scope instead of guessing', async () => {
+    const io = new CapturedIo()
+    expect(
+      await initCommand(
+        { ...makeDeps(io, {} as ApiClient), cwd: mkdtempSync(path.join(os.tmpdir(), 'init-skill-invalid-')) },
+        { skills: true, skillsScope: 'machine' as SkillScope },
+      ),
+    ).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toContain('Choose `project` or `global`')
+  })
+
+  it.each(['project', 'global'] as const)(
+    'passes an unattended %s choice to the native installer and continues setup',
+    async (scope) => {
+      const cwd = mkdtempSync(path.join(os.tmpdir(), `init-skill-${scope}-`))
+      const io = new CapturedIo()
+      const calls: { submit: number } = { submit: 0 }
+      let installed = false
+      let receivedScope: SkillScope | undefined
+      const nativeSkills: NativeSkills = {
+        add: async (options) => {
+          receivedScope = options.scope
+          installed = true
+          return 0
+        },
+        list: async (selected) => ({
+          skills: installed && selected === scope ? [managedSkill(scope, cwd)] : [],
+        }),
+      }
+
+      const result = await initCommand(
+        setupReadyDeps(io, cwd, nativeSkills, calls),
+        { skills: true, skillsScope: scope, hooks: false },
+      )
+      expect(result).toBe(EXIT.ok)
+      expect(receivedScope).toBe(scope)
+      expect(calls.submit).toBe(1)
+      expect(io.outLines.join('\n')).toContain('All set.')
+    },
+  )
+
+  it('lets the native interactive flow choose scope and resumes after cancellation', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-skill-cancelled-'))
+    const io = new InteractiveIo()
+    const calls: { submit: number } = { submit: 0 }
+    let receivedScope: SkillScope | undefined = 'global'
+    const nativeSkills: NativeSkills = {
+      add: async (options) => {
+        receivedScope = options.scope
+        return 0
+      },
+      list: async () => ({ skills: [] }),
+    }
+
+    expect(await initCommand(setupReadyDeps(io, cwd, nativeSkills, calls), { skills: true, hooks: false })).toBe(
+      EXIT.ok,
+    )
+    expect(receivedScope).toBeUndefined()
+    expect(calls.submit).toBe(1)
+    expect(io.outLines.join('\n')).toContain('All set.')
+  })
+
+  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()
+    const calls: { submit: number } = { submit: 0 }
+    const nativeSkills: NativeSkills = {
+      add: async () => 1,
+      list: async () => ({ skills: [] }),
+    }
+
+    expect(await initCommand(setupReadyDeps(io, cwd, nativeSkills, calls), { skills: true, hooks: false })).toBe(
+      EXIT.failed,
+    )
+    expect(calls.submit).toBe(1)
+    expect(io.errLines.join('\n')).toContain('Skill installation failed')
+    expect(io.outLines.join('\n')).toContain('All set.')
+  })
+
   it('tells the user what only they can do when nothing is signed in', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-nocred-'))
     const io = new CapturedIo()
@@ -1116,7 +1462,10 @@ describe('init', () => {
     expect(io.outLines.join('\n')).toContain('notifai login')
   })
 
-  it('offers a present human the sign-in and respects a refusal', async () => {
+  it('announces sign-in for a present human without re-confirming', async () => {
+    // Running `init` is the consent; re-asking "Sign in now?" is noise.
+    // Ctrl-C is the escape hatch (announced). Here beginPairing fails so we
+    // still end on the credential Next line with a re-run hint.
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-human-'))
     const asked: string[] = []
     const io = new (class extends CapturedIo {
@@ -1126,16 +1475,24 @@ describe('init', () => {
         return false
       }
     })()
+    const client = {
+      health: async () => true,
+      beginPairing: async () => {
+        throw new NetworkError('offline for test')
+      },
+    } as unknown as ApiClient
     const deps: CommandDeps = {
-      ...makeDeps(io, {} as ApiClient),
+      ...makeDeps(io, client),
       cwd,
       store: { load: () => null, save: () => {}, clear: () => {}, describe: () => 'empty store' },
     }
 
-    expect(await initCommand(deps, {})).toBe(EXIT.ok)
-    expect(asked.some((q) => q.includes('Sign in'))).toBe(true)
-    // Refused, so it stays the next step rather than being treated as done.
-    expect(io.outLines.join('\n')).toContain('notifai login')
+    expect(await initCommand(deps, {})).toBe(EXIT.failed)
+    expect(asked.some((q) => q.includes('Sign in'))).toBe(false)
+    const out = io.outLines.join('\n')
+    expect(out).toContain('Opening your browser to approve this machine — Ctrl-C to stop.')
+    expect(out).toContain('Next: This machine')
+    expect(out).toContain('Then re-run `notifai init` and it will pick up from here.')
   })
 
   it('never prompts or opens a browser when an agent runs it unattended', async () => {
@@ -1167,6 +1524,12 @@ describe('init', () => {
       health: async () => true,
       capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
       listDevices: async () => ({ devices: [] }),
+      accessStatus: async () => ({
+        status: 'active',
+        reason: 'alpha_grant',
+        expires_at: null,
+        email: 'alpha@example.com',
+      }),
     } as unknown as ApiClient
     const deps = {
       ...makeDeps(io, client),
@@ -1177,11 +1540,57 @@ describe('init', () => {
     expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.failed)
     const out = io.outLines.join('\n')
     expect(out).toContain('Next: Your devices')
-    expect(out).toContain('no supported App Store/TestFlight URL')
-    expect(out).toContain('open it, sign in with the same account, and allow notifications')
+    expect(out).toContain('https://test.notifai.invalid/support')
+    expect(out).toContain('sign in with the same email as this account (alpha@example.com)')
+    expect(out).toContain('install Notifai on iPhone or Mac via https://test.notifai.invalid/support')
     expect(out.match(/^Next:/gm)).toHaveLength(1)
   })
 
+  it('offers hooks and skill before stopping at a phone-less device gap', async () => {
+    // P2.1: optionals that work without a phone must not be trapped behind the
+    // user-elsewhere device blocker.
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-optionals-first-'))
+    const asked: string[] = []
+    const io = new (class extends CapturedIo {
+      interactive = true
+      override async confirm(question: string) {
+        asked.push(question)
+        return false
+      }
+    })()
+    const client = {
+      health: async () => true,
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+      listDevices: async () => ({ devices: [] }),
+      accessStatus: async () => ({
+        status: 'active',
+        reason: 'alpha_grant',
+        expires_at: null,
+        email: 'alpha@example.com',
+      }),
+    } as unknown as ApiClient
+    const deps = {
+      ...makeDeps(io, client),
+      cwd,
+      env: {
+        XDG_CONFIG_HOME: path.join(cwd, 'config'),
+        XDG_STATE_HOME: path.join(cwd, 'state'),
+        CODEX_HOME: path.join(cwd, 'codex'),
+        CLAUDE_CONFIG_DIR: path.join(cwd, 'claude'),
+      },
+    }
+
+    expect(await initCommand(deps, {})).toBe(EXIT.ok)
+    expect(asked.some((q) => q.includes('hooks'))).toBe(true)
+    expect(asked.some((q) => q.includes('skill'))).toBe(true)
+    const out = io.outLines.join('\n')
+    expect(out).toContain('Next: Your devices')
+    // Device wait prompts only after optionals have been considered.
+    expect(asked.indexOf(asked.find((q) => q.includes('hooks'))!)).toBeLessThan(
+      asked.findIndex((q) => q.includes('Wait here') || q.includes('Open install')),
+    )
+  })
+
   it.each([
     ['denied', 'system settings'],
     ['not_determined', 'allow its notification prompt'],
@@ -1219,6 +1628,12 @@ describe('init', () => {
       health: async () => true,
       capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
       listDevices: async () => ({ devices: deviceReady ? [readyIphone] : [] }),
+      accessStatus: async () => ({
+        status: 'active',
+        reason: 'alpha_grant',
+        expires_at: null,
+        email: 'alpha@example.com',
+      }),
       submit: async (draft: SubmitNotificationRequestT) => {
         submitCalls += 1
         submittedDraft = draft
@@ -1243,10 +1658,17 @@ describe('init', () => {
     }
 
     expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.ok)
-    expect(io.prompts).toEqual(['Wait here while you finish that on your device?'])
+    expect(io.prompts).toEqual([
+      'Open install instructions in your browser?',
+      'Wait here while you finish that on your device?',
+    ])
+    expect(io.openedUrls).toEqual(['https://test.notifai.invalid/support'])
+    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 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')
@@ -1254,12 +1676,96 @@ describe('init', () => {
 
     io.outLines = []
     io.prompts = []
+    io.openedUrls = []
     expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.ok)
     expect(submitCalls).toBe(1)
     expect(io.prompts).toEqual([])
     expect(io.outLines.join('\n')).toContain('All set.')
   })
 
+  it('says the wait timer expired and can keep waiting for a late device', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-device-keep-waiting-'))
+    const io = new InteractiveIo()
+    // Open browser, wait yes, keep-waiting yes on first expiry.
+    io.confirmAnswers = [true, true, true]
+    let now = 0
+    // Match DEVICE_BRIDGE_TIMEOUT_MS (10 minutes): device appears only after
+    // the first budget has fully elapsed and keep-waiting has restarted.
+    const firstBudgetMs = 10 * 60 * 1000
+    const client = {
+      health: async () => true,
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+      listDevices: async () => ({
+        devices: now >= firstBudgetMs ? [readyIphone] : [],
+      }),
+      accessStatus: async () => ({
+        status: 'active',
+        reason: 'alpha_grant',
+        expires_at: null,
+        email: 'late@example.com',
+      }),
+      submit: async () => setupReceipt(),
+      evidence: async (requestId: string) =>
+        setupEvidence(requestId, {
+          state: 'observed',
+          observed_at: '2026-08-05T18:00:02.000Z',
+          latency_ms: 1_000,
+        }),
+    } as unknown as ApiClient
+    const deps: CommandDeps = {
+      ...makeDeps(io, client),
+      cwd,
+      env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
+      now: () => now,
+      sleep: async (milliseconds) => {
+        now += milliseconds
+      },
+    }
+
+    expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.ok)
+    expect(io.errLines.join('\n')).toContain('wait timer expired')
+    expect(io.errLines.join('\n')).toMatch(/setup is not finished, only this wait/)
+    expect(io.prompts.some((q) => q.includes('Keep waiting'))).toBe(true)
+    expect(io.spinnerEvents).toContain('stop:iPhone is ready to receive')
+    expect(io.outLines.join('\n')).toContain('All set.')
+  })
+
+  it('never hangs an agent on the device wait or keep-waiting prompt', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-device-agent-'))
+    const io = new (class extends CapturedIo {
+      override async confirm(): Promise<boolean> {
+        throw new Error('an unattended init reached a device-wait prompt')
+      }
+
+      override openUrl(): void {
+        throw new Error('an unattended init opened a browser')
+      }
+    })()
+    const client = {
+      health: async () => true,
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+      listDevices: async () => ({ devices: [] }),
+      accessStatus: async () => ({
+        status: 'active',
+        reason: 'alpha_grant',
+        expires_at: null,
+        email: 'agent@example.com',
+      }),
+    } as unknown as ApiClient
+    const deps = {
+      ...makeDeps(io, client),
+      cwd,
+      env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
+    }
+
+    expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.failed)
+    const out = io.outLines.join('\n')
+    expect(out).toContain('Next: Your devices')
+    expect(out).toContain('https://test.notifai.invalid/support')
+    expect(out).toContain('sign in with the same email as this account (agent@example.com)')
+    expect(io.openedUrls).toEqual([])
+  })
+
   it('persists a partial proof and checks the same request instead of sending again', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-proof-partial-'))
     const io = new CapturedIo()
@@ -1303,7 +1809,8 @@ describe('init', () => {
     expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.failed)
     expect(submitCalls).toBe(1)
     expect(io.outLines.join('\n')).toContain('Next: Delivery proof')
-    expect(io.errLines.join('\n')).toContain('not proof of non-receipt')
+    expect(io.outLines.join('\n')).toContain('Provider accepted the notification')
+    expect(io.outLines.join('\n')).toContain('Proof may still arrive')
 
     io.outLines = []
     io.errLines = []
@@ -1317,7 +1824,9 @@ 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 observed from iPhone')
+    expect(io.outLines.join('\n')).toContain(
+      "Companion Receipt (the app's delivery confirmation) observed from iPhone",
+    )
   })
 
   it('reports a proof-state write failure instead of crashing or sending twice', async () => {
@@ -1345,7 +1854,7 @@ describe('init', () => {
     expect(io.outLines.join('\n')).toContain('Next: Delivery proof')
   })
 
-  it('does not claim proof for a macOS-only setup whose receipt bridge is unavailable', async () => {
+  it('treats macOS-only delivery proof as an honest non-blocking caveat', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-macos-proof-'))
     const io = new CapturedIo()
     let submitCalls = 0
@@ -1366,10 +1875,66 @@ describe('init', () => {
       env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
     }
 
-    expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.failed)
+    expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.ok)
     expect(submitCalls).toBe(0)
-    expect(io.outLines.join('\n')).toContain('Next: Delivery proof')
-    expect(io.outLines.join('\n')).toContain('no supported macOS receipt bridge')
+    const out = io.outLines.join('\n')
+    expect(out).toContain('All set.')
+    expect(out).toContain('receipt proof needs an iPhone in this release')
+    expect(out).not.toContain('Next: Delivery proof')
+    expect(out).not.toMatch(/Companion Receipt observed/i)
+
+    // doctor must render the same non-blocking state (not FAIL / not a Next:).
+    const doctorIo = new CapturedIo()
+    expect(
+      await doctorCommand(
+        {
+          ...makeDeps(doctorIo, client),
+          cwd,
+          env: { XDG_CONFIG_HOME: path.join(cwd, 'config'), XDG_STATE_HOME: path.join(cwd, 'state') },
+        },
+        {},
+      ),
+    ).toBe(EXIT.ok)
+    const doctorOut = doctorIo.outLines.join('\n')
+    expect(doctorOut).toMatch(/--\s+Delivery proof:/)
+    expect(doctorOut).toContain('receipt proof needs an iPhone')
+    expect(doctorOut).not.toMatch(/FAIL\s+Delivery proof:/)
+  })
+
+  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 () => {
@@ -1486,7 +2051,7 @@ describe('an outage is not an answer', () => {
       json: true,
     })
 
-    const payload = JSON.parse(io.outLines[0] ?? '{}') as { degraded: boolean }
+    const payload = JSON.parse(io.outLines[1] ?? '{}') as { degraded: boolean }
     expect(payload.degraded).toBe(true)
   })
 
@@ -1512,6 +2077,276 @@ describe('an outage is not an answer', () => {
 })
 
 describe('asking before the hooks have ever run', () => {
+  const execPath = '/usr/local/bin/node'
+  const scriptPath = '/opt/notifai/dist/main.js'
+
+  it('names the active Codex harness instead of unrelated installed adapters', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-codex-missing-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CODEX_HOME: path.join(cwd, 'codex-home'),
+      CODEX_THREAD_ID: 'codex-current-thread',
+      CLAUDE_CONFIG_DIR: path.join(cwd, 'claude-home'),
+      OPENCODE_CONFIG_DIR: path.join(cwd, 'opencode-home'),
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env }
+
+    expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(EXIT.ok)
+    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(/active Codex session/i)
+    expect(said).toContain('notifai hooks install --harness codex')
+    expect(said).not.toMatch(/Claude Code: send one new prompt|OpenCode: restart/)
+  })
+
+  it('refuses a recent pointer owned by another Codex thread', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-codex-mismatch-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CODEX_HOME: path.join(cwd, 'codex-home'),
+      CODEX_THREAD_ID: 'codex-current-thread',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    writeSessionState('codex-other-thread', env, { 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(/belongs to another Codex session/i)
+    expect(io.outLines).not.toContain(
+      'Question registered. Ask it in the conversation as usual and end your turn.',
+    )
+  })
+
+  it('registers only when the active Codex thread owns the project pointer', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-codex-matching-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CODEX_HOME: path.join(cwd, 'codex-home'),
+      CODEX_THREAD_ID: 'codex-current-thread',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    writeSessionState('codex-current-thread', env, { last_prompt_at: 42 })
+    writeProjectSession(cwd, env, 'codex-current-thread', 42, 'codex')
+    io.outLines = []
+
+    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.ok)
+    expect(io.outLines).toContain(
+      'Question registered. Ask it in the conversation as usual and end your turn.',
+    )
+  })
+
+  it('gives doctor the same active-Codex diagnosis as ask', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-codex-doctor-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CODEX_HOME: path.join(cwd, 'codex-home'),
+      CODEX_THREAD_ID: 'codex-current-thread',
+      CLAUDE_CONFIG_DIR: path.join(cwd, 'claude-home'),
+    }
+    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,
+      list: async (scope) => ({
+        skills:
+          scope === 'global'
+            ? [
+                {
+                  name: 'notifai',
+                  scope,
+                  path: path.join(cwd, 'global-skills', 'notifai'),
+                  source: 'Raidiant-io/notifai',
+                  sourceType: 'github',
+                  sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
+                  ref: 'v0.2.0',
+                },
+              ]
+            : [],
+      }),
+    }
+    const deps = { ...makeDeps(io, client), cwd, env, nativeSkills }
+
+    expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(EXIT.ok)
+    io.outLines = []
+
+    expect(await doctorCommand(deps, {})).toBe(EXIT.failed)
+    const said = io.outLines.join(' ')
+    expect(said).toContain(`installed from ${SKILLS_SOURCE} in the global scope`)
+    expect(said).toMatch(/active Codex/i)
+    expect(said).toContain('notifai hooks install --harness codex')
+  })
+
+  it('refuses a Claude Code pointer owned by another live session', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-claude-mismatch-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CLAUDE_CONFIG_DIR: path.join(cwd, 'claude-home'),
+      CLAUDECODE: '1',
+      CLAUDE_CODE_SESSION_ID: 'claude-current',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+    expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
+      EXIT.ok,
+    )
+    writeSessionState('claude-other', env, { 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(/another Claude Code session/i)
+  })
+
+  it('accepts a Claude Code subprocess when its documented session id owns the pointer', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-claude-child-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CLAUDE_CONFIG_DIR: path.join(cwd, 'claude-home'),
+      CLAUDECODE: '1',
+      CLAUDE_CODE_CHILD_SESSION: '1',
+      CLAUDE_CODE_SESSION_ID: 'claude-parent-loop',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+    expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
+      EXIT.ok,
+    )
+    writeSessionState('claude-parent-loop', env, { last_prompt_at: 42 })
+    writeProjectSession(cwd, env, 'claude-parent-loop', 42, 'claude-code')
+    io.outLines = []
+
+    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.ok)
+    expect(readSessionState('claude-parent-loop', env).pending?.question).toBe('Ship it?')
+  })
+
+  it('uses the OpenCode adapter marker instead of its config-directory variable', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-opencode-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      OPENCODE_CONFIG_DIR: path.join(cwd, 'opencode-home'),
+      NOTIFAI_ACTIVE_HARNESS: 'opencode',
+      NOTIFAI_ACTIVE_SESSION_ID: 'opencode-current',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+    expect(hooksInstallCommand(deps, { harness: 'opencode', execPath, scriptPath })).toBe(EXIT.ok)
+    writeSessionState('opencode-other', env, { 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(/another OpenCode session/i)
+  })
+
+  it('recognizes Cursor only from its active-agent marker', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-cursor-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CURSOR_AGENT: '1',
+    }
+    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 })
+    writeProjectSession(cwd, env, 'cursor-live', 42, 'cursor')
+    io.outLines = []
+
+    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.ok)
+    expect(readSessionState('cursor-live', env).pending?.question).toBe('Ship it?')
+  })
+
+  it('fails doctor when another harness looks healthy but the active Claude Code session does not', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-claude-doctor-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CODEX_HOME: path.join(cwd, 'codex-home'),
+      CLAUDE_CONFIG_DIR: path.join(cwd, 'claude-home'),
+      CLAUDECODE: '1',
+      CLAUDE_CODE_SESSION_ID: 'claude-current',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+    expect(hooksInstallCommand(deps, { harness: 'codex', execPath, scriptPath })).toBe(EXIT.ok)
+    writeSessionState('codex-live', env, { last_prompt_at: 42 })
+    writeProjectSession(cwd, env, 'codex-live', 42, 'codex')
+    io.outLines = []
+
+    expect(await doctorCommand(deps, {})).toBe(EXIT.failed)
+    expect(io.outLines.join('\n')).toMatch(/FAIL\s+Question routing:.*active Claude Code/is)
+  })
+
+  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\nrequire_idle = false\naway_after_seconds = 45\nask_grace_seconds = 90\nhook_reply_timeout_seconds = 120\n',
+    )
+    const io = new CapturedIo()
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: {} }
+
+    await doctorCommand(deps, {})
+
+    const said = io.outLines.join('\n')
+    expect(said).toContain('Question routing settings:')
+    expect(said).toContain('ask_notifications=false (project-local:')
+    expect(said).toContain('require_idle=false (project-local:')
+    expect(said).toContain('away_after_seconds=45 (project-local:')
+    expect(said).toContain('ask_grace_seconds=90 (project-local:')
+    expect(said).toContain('hook_reply_timeout_seconds=120 (project-local:')
+  })
+
+  it('fails doctor when runtime waits outgrow an installed Stop timeout', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-doctor-timeout-drift-'))
+    const io = new CapturedIo()
+    const env = { XDG_STATE_HOME: path.join(cwd, 'state'), CLAUDE_CONFIG_DIR: path.join(cwd, 'claude') }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env }
+    expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
+      EXIT.ok,
+    )
+    mkdirSync(path.join(cwd, '.notifai'), { recursive: true })
+    writeFileSync(path.join(cwd, '.notifai', 'config.local.toml'), 'ask_grace_seconds = 400\n')
+    io.outLines = []
+
+    expect(await doctorCommand(deps, {})).toBe(EXIT.failed)
+    expect(io.outLines.join('\n')).toMatch(/FAIL\s+hooks \(timeout\)/)
+    expect(io.outLines.join('\n')).toContain('notifai hooks install --harness claude-code')
+  })
+
+  it('documents the failing exit contract in doctor JSON', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-doctor-exit-json-'))
+    const io = new CapturedIo()
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: {} }
+
+    expect(await doctorCommand(deps, { json: true })).toBe(EXIT.failed)
+    const payload = JSON.parse(io.outLines[0] ?? '{}') as { ok?: boolean; exit_code?: number }
+    expect(payload).toMatchObject({ ok: false, exit_code: EXIT.failed })
+  })
+
   it('tells Claude Code to send a prompt without falsely requiring a restart', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-firstrun-'))
     mkdirSync(path.join(cwd, '.claude'), { recursive: true })
@@ -1533,6 +2368,43 @@ describe('asking before the hooks have ever run', () => {
     expect(said).not.toMatch(/Run `notifai hooks install` and send one prompt/)
   })
 
+  it('gives Cursor its prompt-and-doctor activation path', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-cursor-first-run-'))
+    const io = new CapturedIo()
+    const deps = {
+      ...makeDeps(io, {} as ApiClient),
+      cwd,
+      env: { XDG_STATE_HOME: path.join(cwd, 'state') },
+    }
+
+    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`/)
+  })
+
+  it('keeps OpenCode activation separate from answer continuation', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-opencode-first-run-'))
+    const io = new CapturedIo()
+    const deps = {
+      ...makeDeps(io, {} as ApiClient),
+      cwd,
+      env: {
+        XDG_STATE_HOME: path.join(cwd, 'state'),
+        OPENCODE_CONFIG_DIR: path.join(cwd, 'opencode-home'),
+      },
+    }
+
+    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('device answer is delivered on the next prompt')
+  })
+
   it('says to install when nothing is installed at all', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-noinstall-'))
     const io = new CapturedIo()
@@ -1572,7 +2444,7 @@ describe('a server behind this CLI', () => {
     expect(said).not.toMatch(/older than this CLI/)
   })
 
-  it('doctor says plainly that the server needs deploying', async () => {
+  it('doctor uses alpha-user wording when the server is behind the CLI', async () => {
     const io = new CapturedIo()
     const client = {
       health: async () => true,
@@ -1593,7 +2465,8 @@ describe('a server behind this CLI', () => {
     const said = io.outLines.concat(io.errLines).join(' ')
     // The label is the user's word for it; the detail is what must survive.
     expect(said).toMatch(/Protocol version/)
-    expect(said).toMatch(/needs deploying/)
+    expect(said).toMatch(/service is being updated/)
+    expect(said).not.toMatch(/needs deploying/)
   })
 
   it('doctor is quiet when both sides agree', async () => {
@@ -1617,7 +2490,97 @@ describe('a server behind this CLI', () => {
   })
 })
 
-/** First-reply-wins is the right default, silently is the wrong way. */
+describe('question sets', () => {
+  it('maps --reply-multi into the single question', async () => {
+    const io = new CapturedIo()
+    let submitted: SubmitNotificationRequestT | undefined
+    const client = {
+      submit: async (body: SubmitNotificationRequestT) => {
+        submitted = body
+        return receipt
+      },
+      replies: async () => replyResponse([reply]),
+    } as unknown as ApiClient
+
+    expect(
+      await sendCommand(makeDeps(io, client), {
+        title: 'Question',
+        body: 'Which fronts?',
+        reply: true,
+        replyTimeout: 30,
+        replyChoice: ['CLI', 'Server', 'Apps'],
+        replyMulti: true,
+      }),
+    ).toBe(EXIT.ok)
+    expect(submitted?.draft.reply?.questions?.[0]).toMatchObject({
+      text: 'Which fronts?',
+      multi: true,
+    })
+    expect(submitted?.draft.reply?.questions?.[0]?.choices).toHaveLength(3)
+  })
+
+  it('rejects a question body too long for the answering surface', async () => {
+    const io = new CapturedIo()
+    let submitCalls = 0
+    const client = {
+      submit: async () => {
+        submitCalls += 1
+        return receipt
+      },
+    } as unknown as ApiClient
+
+    expect(
+      await sendCommand(makeDeps(io, client), {
+        title: 'Question',
+        body: 'x'.repeat(501),
+        reply: true,
+        replyTimeout: 30,
+      }),
+    ).toBe(EXIT.usage)
+    expect(submitCalls).toBe(0)
+    expect(io.errLines.join(' ')).toContain('--detail')
+  })
+
+  it('generates unique question ids when texts collide', () => {
+    const built = buildQuestions(
+      {
+        form: JSON.stringify({
+          questions: [{ text: 'Ready?' }, { text: 'Ready?' }],
+        }),
+      },
+      undefined,
+    )
+    expect(built).toMatchObject({ ok: true })
+    if (built.ok) {
+      expect(built.questions.map((question) => question.id)).toEqual(['ready', 'q2'])
+    }
+  })
+
+  it('rejects forms outside the documented shape', () => {
+    expect(buildQuestions({ form: 'not json' }, undefined)).toMatchObject({ ok: false })
+    expect(
+      buildQuestions({ form: JSON.stringify({ questions: [] }) }, undefined),
+    ).toMatchObject({ ok: false })
+    expect(
+      buildQuestions(
+        { form: JSON.stringify({ questions: Array.from({ length: 5 }, (_, i) => ({ text: `Q${i}?` })) }) },
+        undefined,
+      ),
+    ).toMatchObject({ ok: false, error: expect.stringContaining('1-4') })
+    expect(
+      buildQuestions(
+        { form: JSON.stringify({ questions: [{ text: 'Pick?', multi: true }] }) },
+        undefined,
+      ),
+    ).toMatchObject({ ok: false, error: expect.stringContaining('--choice') })
+    // --form replaces the flag surface; mixing them is a usage error.
+    expect(
+      buildQuestions({ form: JSON.stringify({ questions: [{ text: 'Q?' }] }) }, 'Also a question?'),
+    ).toMatchObject({ ok: false })
+  })
+})
+
+/** Latest-reply-wins, and never silently: a correction is named as one. */
 describe('a second device that disagrees', () => {
   function view(overrides: Partial<ReplyView>): ReplyView {
     return {
@@ -1627,27 +2590,28 @@ describe('a second device that disagrees', () => {
       device_id: 'dev',
       device_name: 'iPhone',
       text: 'Yes',
-      choice_id: null,
+      answers: [],
+      source: null,
       created_at: new Date().toISOString(),
       ...overrides,
     }
   }
 
-  it('says which answer counted and which was discarded', () => {
+  it('says the latest answer counted and which were superseded', () => {
     const said = contradictingAnswer([
       view({ seq: 1, device_name: 'iPhone', text: 'Yes' }),
       view({ seq: 2, device_name: 'FurankuMac', text: 'No' }),
     ])
-    expect(said).toContain('"Yes" from iPhone')
-    expect(said).toContain('FurankuMac')
-    expect(said).toMatch(/arrived first/)
+    expect(said).toContain('"No" from FurankuMac')
+    expect(said).toContain('iPhone')
+    expect(said).toMatch(/corrects an earlier one/)
   })
 
   it('is silent when the second answer agrees', () => {
     expect(
       contradictingAnswer([
-        view({ seq: 1, device_name: 'iPhone', text: 'Ship it', choice_id: 'ship' }),
-        view({ seq: 2, device_name: 'FurankuMac', text: 'Ship it', choice_id: 'ship' }),
+        view({ seq: 1, device_name: 'iPhone', text: 'Ship it', answers: [{ question_id: 'q1', choice_ids: ['ship'], text: null }] }),
+        view({ seq: 2, device_name: 'FurankuMac', text: 'Ship it', answers: [{ question_id: 'q1', choice_ids: ['ship'], text: null }] }),
       ]),
     ).toBeNull()
   })