@raidiant/notifai 8.0.0 → 9.1.0

package/src/commands-send.ts

@@ -6,17 +6,18 @@ import {
   type ReplyView,
   type SubmissionReceipt,
 } from '@raidiant/notifai-protocol'
-import { randomBytes } from 'node:crypto'
 import { ApiCallError, NetworkError } from './client.js'
 import type { FlagOverrides, loadConfig } from './config.js'
-import { MIN_REPLY_WINDOW_SECONDS, readProjectSession, readSessionState } from './hooks.js'
+import { MIN_REPLY_WINDOW_SECONDS, readSessionState } from './hooks.js'
 import {
   buildDraft,
   formatReceipt,
   receiptExitCode,
+  rejectAccidentalEscapedNewlines,
   validateMediaInputs,
   type SendFlags,
 } from './send.js'
+import { recordObservedDeliveryProof, setupProofProject } from './commands-setup-proof.js'
 import {
   EXIT,
   authedClient,
@@ -26,6 +27,13 @@ import {
   type CommandDeps,
 } from './commands-core.js'
 import { activeHarnessSession } from './commands-harness-context.js'
+import { resolveCommandSession } from './command-session.js'
+import {
+  beginSendAttempt,
+  semanticMediaIds,
+  sendDraftFingerprint,
+  settleSendAttempt,
+} from './send-attempts.js'
 import {
   acknowledgementCommand,
   printAcknowledgementStatus,
@@ -47,9 +55,14 @@ export async function sendCommand(
     noWait?: boolean
     replyTimeout?: number
     idempotencyKey?: string
+    retry?: boolean
     baseUrl?: string
   },
 ): Promise<number> {
+  if (flags.retry === true && flags.idempotencyKey !== undefined) {
+    deps.io.err('Pass --retry or --idempotency-key, not both.')
+    return EXIT.usage
+  }
   const hasChoice = Array.isArray(flags.choice)
     ? flags.choice.length > 0
     : flags.choice !== undefined
@@ -63,7 +76,7 @@ export async function sendCommand(
   if (!flags.reply && flags.kind === undefined) {
     deps.io.err(
       '--kind is required: say what this notification is. ' +
-        'update (news) · done (finished) · failed (terminal failure) · blocked (cannot proceed). ' +
+        'update (news) · done (finished) · failed (terminal failure) · blocked (cannot proceed; no User reply would resume it). ' +
         '--reply makes it a question without --kind.',
     )
     return EXIT.usage
@@ -111,6 +124,11 @@ export async function sendCommand(
     )
     return EXIT.usage
   }
+  const escapedBody = rejectAccidentalEscapedNewlines(flags.body, flags.literalBackslashN)
+  if (escapedBody !== null) {
+    deps.io.err(escapedBody)
+    return EXIT.usage
+  }
   const mediaInputError = validateMediaInputs(flags.image, flags.imageAlt)
   if (mediaInputError !== null) {
     deps.io.err(mediaInputError)
@@ -132,14 +150,44 @@ export async function sendCommand(
   }
   const authed = authedClient(deps, config)
   if (!authed) return EXIT.auth
+  const credential = deps.store.load()!
+  let semanticImages: string[]
+  try {
+    semanticImages = semanticMediaIds(flags.image ?? [], deps.cwd)
+  } catch (err) {
+    deps.io.err(`Could not fingerprint an image for safe retry: ${String(err)}`)
+    return EXIT.usage
+  }
+  const semanticBuild = buildDraft(
+    config,
+    { ...flags, ...(semanticImages.length > 0 ? { image: semanticImages } : {}) },
+    source.invocation,
+  )
+  if (!semanticBuild.ok) {
+    deps.io.err(semanticBuild.error)
+    return EXIT.usage
+  }
+  const attempt = beginSendAttempt({
+    env: deps.env,
+    credential,
+    fingerprint: sendDraftFingerprint(semanticBuild.draft, credential),
+    retry: flags.retry === true,
+    ...(flags.idempotencyKey === undefined ? {} : { idempotencyKey: flags.idempotencyKey }),
+    now: (deps.now ?? Date.now)(),
+  })
+  if (!attempt.ok) {
+    deps.io.err(`${attempt.code}: ${attempt.message}`)
+    return EXIT.usage
+  }
   const mediaIds: string[] = []
   for (const image of flags.image ?? []) {
     if (image.startsWith('med_')) {
       mediaIds.push(image)
       continue
     }
-    const uploaded = await uploadImage(deps, authed.client, image)
+    const uploaded = await uploadImage(deps, authed.client, image, config.media_origins.value)
     if (!uploaded.ok) {
+      settleSendAttempt(deps.env, attempt.attemptId)
       if (uploaded.error !== null) deps.io.err(uploaded.error)
       return uploaded.exit
     }
@@ -148,16 +196,19 @@ export async function sendCommand(
   flags = { ...flags, image: mediaIds }
   const build = buildDraft(config, flags, source.invocation)
   if (!build.ok) {
+    settleSendAttempt(deps.env, attempt.attemptId)
     deps.io.err(build.error)
     return EXIT.usage
   }
   const capabilities = CAPABILITIES_V1.describe(build.platform)
   if (!capabilities) {
+    settleSendAttempt(deps.env, attempt.attemptId)
     deps.io.err(`No capability contract is available for ${build.platform}.`)
     return EXIT.usage
   }
   const validation = validateDraft(build.draft, capabilities)
   if (!validation.ok) {
+    settleSendAttempt(deps.env, attempt.attemptId)
     for (const issue of validation.errors) deps.io.err(`${issue.path}: ${issue.message}`)
     return EXIT.usage
   }
@@ -174,7 +225,15 @@ export async function sendCommand(
     )
   }
   const waitSeconds = flags.noWait ? 0 : config.wait_seconds.value
-  const idempotencyKey = flags.idempotencyKey ?? `cli-${randomBytes(12).toString('base64url')}`
+  const idempotencyKey = attempt.idempotencyKey
+  // Persist the retry identity before entering the ambiguous network boundary.
+  // If the process is killed after the server accepts but before a response,
+  // this is the only durable way to reconstruct the same Agent Event key.
+  log(deps).info('send.attempt', {
+    attempt_id: attempt.attemptId,
+    idempotency_key: idempotencyKey,
+    replay: attempt.replay,
+  })
   let receipt: SubmissionReceipt
   try {
     receipt = await authed.client.submit(
@@ -182,8 +241,27 @@ export async function sendCommand(
       waitSeconds,
     )
   } catch (err) {
-    return reportError(deps, err)
+    const exit = reportError(deps, err)
+    if (exit === EXIT.network) {
+      deps.io.err(
+        'The server may have accepted this Notification Request before the connection failed. ' +
+          'Re-run the exact semantic send with `--retry`; the CLI will reuse its opaque attempt identity.',
+      )
+    }
+    if (err instanceof ApiCallError && err.code === 'no_active_devices') {
+      deps.io.err(
+        'After setup succeeds, repeat this exact original Notification Request with `--retry`; ' +
+          'the setup verification request does not replace this Agent Event.',
+      )
+    }
+    if (!(exit === EXIT.network || (err instanceof ApiCallError && err.code === 'no_active_devices'))) {
+      settleSendAttempt(deps.env, attempt.attemptId)
+    } else {
+      deps.io.err(`Opaque retry attempt: ${attempt.attemptId}. Re-run the exact semantic send with \`--retry\`; do not retry automatically.`)
+    }
+    return exit
   }
+  settleSendAttempt(deps.env, attempt.attemptId)
   const receiptExit = receiptExitCode(receipt)
   // The single most useful line in the log: it ties the local invocation to
   // the server-side request id, which is what every later question about this
@@ -191,7 +269,7 @@ export async function sendCommand(
   log(deps).info('send.submitted', {
     request_id: receipt.request_id,
     kind: flags.reply ? 'question' : (flags.kind ?? 'update'),
-    title: flags.title,
+    title_chars: flags.title.length,
     overall: receipt.overall,
     replayed: receipt.replayed,
     agent_acknowledgement_required: receipt.agent_acknowledgement_required,
@@ -354,28 +432,64 @@ export async function repliesCommand(
     return EXIT.usage
   }
   let requestIds = requestedId === undefined ? [] : [requestedId]
+  let lifecycleSessionId: string | undefined
   if (flags.pending === true) {
-    const sessionId = readProjectSession(deps.cwd, deps.env, (deps.now ?? Date.now)())
-    if (sessionId === null) {
+    const session = resolveCommandSession(deps)
+    if (session === null) {
       deps.io.err('No active session pointer is available in this directory.')
       return EXIT.noReply
     }
+    const sessionId = session.sessionId
+    lifecycleSessionId = sessionId
     // Every delivered question in the session's queue, in registration order —
     // an agent may have several outstanding at once.
     const state = readSessionState(sessionId, deps.env)
-    requestIds = (Array.isArray(state.pending) ? state.pending : [])
+    const pending = Array.isArray(state.pending) ? state.pending : []
+    requestIds = pending
       .map((entry) => entry.request_id)
       .filter((id): id is string => id !== undefined)
+    const unsent = pending.filter((entry) => entry.request_id === undefined)
     if (requestIds.length === 0) {
       // `--json` is a promise about stdout, and an empty result is still a
       // result: a caller that asked for machine-readable output must not have
       // to parse an English sentence to learn there was nothing pending.
       if (flags.json === true) {
-        deps.io.out(JSON.stringify({ session_id: sessionId, pending: [], replies: [] }, null, 2))
+        deps.io.out(
+          JSON.stringify(
+            {
+              session_id: sessionId,
+              pending: unsent.map((entry) => ({
+                question: entry.question,
+                ...(entry.question_id === undefined ? {} : { question_id: entry.question_id }),
+              })),
+              replies: [],
+            },
+            null,
+            2,
+          ),
+        )
+      } else if (unsent.length > 0) {
+        for (const entry of unsent) {
+          deps.io.out(
+            entry.question_id === undefined
+              ? `unpushed question: ${entry.question}`
+              : `unpushed question ${entry.question_id}: ${entry.question}`,
+          )
+        }
+        deps.io.out('Retire one with `notifai close <question_id>` so a later Stop will not send it.')
       } else {
         deps.io.err(`Session ${sessionId} has no pushed question pending.`)
       }
-      return EXIT.noReply
+      return unsent.length > 0 ? EXIT.ok : EXIT.noReply
+    }
+    if (unsent.length > 0 && flags.json !== true) {
+      for (const entry of unsent) {
+        deps.io.out(
+          entry.question_id === undefined
+            ? `unpushed question: ${entry.question}`
+            : `unpushed question ${entry.question_id}: ${entry.question}`,
+        )
+      }
     }
   }
   if (requestIds.length === 0) {
@@ -383,7 +497,11 @@ export async function repliesCommand(
     return EXIT.usage
   }
 
-  const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env })
+  const config = loadLoggedConfig(deps, {
+    cwd: deps.cwd,
+    env: deps.env,
+    ...(lifecycleSessionId === undefined ? {} : { sessionId: lifecycleSessionId }),
+  })
   const authed = authedClient(deps, config)
   if (!authed) return EXIT.auth
   try {
@@ -527,8 +645,8 @@ function recordReplies(deps: CommandDeps, requestId: string, replies: readonly R
       request_id: requestId,
       sequence: reply.seq,
       device: reply.device_name,
-      text: reply.text,
-      answers: reply.answers,
+      text_chars: reply.text.length,
+      answers_count: reply.answers?.length ?? 0,
       source: reply.source,
     })
   }
@@ -587,11 +705,12 @@ export async function statusCommand(
   if (!authed) return EXIT.auth
   try {
     const snapshot = await authed.client.evidence(requestId)
+    recordObservedDeliveryProof(deps, snapshot, setupProofProject(deps, config.project.value))
     if (flags.json) {
       deps.io.out(JSON.stringify(snapshot, null, 2))
       return EXIT.ok
     }
-    deps.io.out(`request ${snapshot.request_id} (${snapshot.event ?? 'no event'}) — ${snapshot.overall}`)
+    deps.io.out(`request ${snapshot.request_id} — ${snapshot.overall}`)
     let anyReplyReceived = false
     for (const d of snapshot.deliveries) {
       deps.io.out(`  ${d.device_name}:`)

package/src/commands-setup-proof.test.ts

@@ -0,0 +1,72 @@
+import { mkdtempSync, rmSync } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+import type { CommandDeps } from './commands-core.js'
+import type { MachineCredential } from './credentials.js'
+import { readSetupProof, setupProofApplies, writeSetupProof } from './commands-setup-proof.js'
+
+const roots: string[] = []
+afterEach(() => {
+  while (roots.length > 0) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+
+function deps(root: string, cwd: string, credential: MachineCredential): CommandDeps {
+  return {
+    cwd,
+    env: { XDG_STATE_HOME: path.join(root, 'state'), XDG_CONFIG_HOME: path.join(root, 'config') },
+    io: { out: () => {}, err: () => {}, confirm: async () => false, openUrl: () => {} },
+    store: {
+      load: () => credential,
+      save: () => {},
+      clear: () => {},
+      describe: () => 'test',
+    },
+  }
+}
+
+describe('stable setup delivery proof identity', () => {
+  it('is shared by linked checkouts of one Project and separated by Project', () => {
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-proof-identity-'))
+    roots.push(root)
+    const credential = {
+      machineId: 'mac_one',
+      machineName: 'One',
+      baseUrl: 'https://app.notifai.test',
+      secret: 'approval-one',
+    }
+    const first = deps(root, path.join(root, 'worktree-a'), credential)
+    const second = deps(root, path.join(root, 'worktree-b'), credential)
+    const proof = {
+      request_id: 'req_proof',
+      device_id: 'dev_one',
+      project: 'shared-project',
+      started_at: '2026-08-26T00:00:00.000Z',
+    }
+    expect(writeSetupProof(first, proof)).toBe(true)
+    expect(readSetupProof(second, 'shared-project')).toEqual(proof)
+    expect(readSetupProof(second, 'different-project')).toBeNull()
+  })
+
+  it('invalidates on service, machine approval, machine, or device change', () => {
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-proof-invalidation-'))
+    roots.push(root)
+    const credential = {
+      machineId: 'mac_one',
+      machineName: 'One',
+      baseUrl: 'https://app.notifai.test',
+      secret: 'approval-one',
+    }
+    const original = deps(root, root, credential)
+    expect(writeSetupProof(original, {
+      request_id: 'req_proof',
+      device_id: 'dev_one',
+      project: 'project',
+      started_at: '2026-08-26T00:00:00.000Z',
+    })).toBe(true)
+    expect(readSetupProof(deps(root, root, { ...credential, baseUrl: 'https://other.test' }), 'project')).toBeNull()
+    expect(readSetupProof(deps(root, root, { ...credential, machineId: 'mac_two' }), 'project')).toBeNull()
+    expect(readSetupProof(deps(root, root, { ...credential, secret: 'approval-two' }), 'project')).toBeNull()
+    expect(setupProofApplies(readSetupProof(original, 'project'), 'project', ['dev_two'])).toBe(false)
+  })
+})

package/src/commands-setup-proof.ts

@@ -4,34 +4,41 @@ import {
   existsSync,
   mkdirSync,
   readFileSync,
-  realpathSync,
   writeFileSync,
 } from 'node:fs'
 import path from 'node:path'
 import { stateDir } from './config.js'
 import type { CommandDeps } from './commands-core.js'
+import { inferInvocationContext } from './invocation-context.js'
 
-interface SetupProofRecord {
+export interface SetupProofRecord {
   request_id: string
   device_id: string
   project: string | null
   started_at: string
 }
 
-function setupProofPath(deps: CommandDeps): string {
-  let projectDir = path.resolve(deps.cwd)
-  try {
-    projectDir = realpathSync(projectDir)
-  } catch {
-    // A deleted or not-yet-created cwd cannot collide with a real directory:
-    // the resolved absolute path is still a stable local identity for it.
-  }
-  const digest = createHash('sha256').update(projectDir).digest('hex').slice(0, 32)
+export function setupProofProject(deps: CommandDeps, configured: string | null): string | null {
+  return configured ?? inferInvocationContext(deps.cwd).project
+}
+
+function setupProofPath(deps: CommandDeps, project: string | null): string | null {
+  const credential = deps.store.load()
+  if (credential === null) return null
+  const approval = createHash('sha256')
+    .update('notifai-setup-proof-approval-v1\0')
+    .update(credential.secret)
+    .digest('base64url')
+  const digest = createHash('sha256')
+    .update(JSON.stringify({ project, machine_id: credential.machineId, service: credential.baseUrl, approval }))
+    .digest('hex')
+    .slice(0, 32)
   return path.join(stateDir(deps.env), 'setup-proofs', `${digest}.json`)
 }
 
-export function readSetupProof(deps: CommandDeps): SetupProofRecord | null {
-  const file = setupProofPath(deps)
+export function readSetupProof(deps: CommandDeps, project: string | null): SetupProofRecord | null {
+  const file = setupProofPath(deps, project)
+  if (file === null) return null
   if (!existsSync(file)) return null
   try {
     const parsed = JSON.parse(readFileSync(file, 'utf8')) as Partial<SetupProofRecord>
@@ -48,7 +55,11 @@ export function readSetupProof(deps: CommandDeps): SetupProofRecord | null {
 }
 
 export function writeSetupProof(deps: CommandDeps, proof: SetupProofRecord): boolean {
-  const file = setupProofPath(deps)
+  const file = setupProofPath(deps, proof.project)
+  if (file === null) {
+    deps.io.err('Could not save setup proof without an Approved Machine credential.')
+    return false
+  }
   try {
     mkdirSync(path.dirname(file), { recursive: true })
     writeFileSync(file, `${JSON.stringify(proof, null, 2)}\n`, { mode: 0o600 })
@@ -66,6 +77,48 @@ export function observedCompanionReceipt(
   deviceId: string,
 ): { delivery: EvidenceSnapshot['deliveries'][number]; observedAt: string } | null {
   const delivery = snapshot.deliveries.find((candidate) => candidate.device_id === deviceId)
-  const receipt = delivery?.events.find((event) => event.stage === 'companion_received')
-  return delivery && receipt ? { delivery, observedAt: receipt.occurred_at } : null
+  if (!delivery) return null
+  if (delivery.companion_receipt.state === 'observed' && delivery.companion_receipt.observed_at) {
+    return { delivery, observedAt: delivery.companion_receipt.observed_at }
+  }
+  const receipt = delivery.events.find((event) => event.stage === 'companion_received')
+  return receipt ? { delivery, observedAt: receipt.occurred_at } : null
+}
+
+/** Replace an unknown setup proof after this age; recent in-flight proofs stay. */
+export const SETUP_PROOF_STALE_MS = 24 * 60 * 60 * 1000
+
+export function setupProofIsStale(proof: SetupProofRecord, now: number): boolean {
+  const started = Date.parse(proof.started_at)
+  return Number.isFinite(started) && now - started > SETUP_PROOF_STALE_MS
+}
+
+export function setupProofApplies(
+  proof: SetupProofRecord | null,
+  project: string | null,
+  deviceIds: readonly string[],
+): proof is SetupProofRecord {
+  return proof !== null && proof.project === project && deviceIds.includes(proof.device_id)
+}
+
+/**
+ * Persist ordinary send/status Companion Receipts as the project's delivery
+ * proof so doctor does not demand a second verification request.
+ */
+export function recordObservedDeliveryProof(
+  deps: CommandDeps,
+  snapshot: EvidenceSnapshot,
+  project: string | null,
+): boolean {
+  for (const delivery of snapshot.deliveries) {
+    const observed = observedCompanionReceipt(snapshot, delivery.device_id)
+    if (observed === null) continue
+    return writeSetupProof(deps, {
+      request_id: snapshot.request_id,
+      device_id: delivery.device_id,
+      project,
+      started_at: observed.observedAt,
+    })
+  }
+  return false
 }

package/src/commands-skill.ts

@@ -1,4 +1,4 @@
-import type { NativeSkill, SkillScope } from './native-skills.js'
+import { SKILLS_INSTALLER_SPEC, type NativeSkill, type SkillScope } from './native-skills.js'
 import { type ReadinessState } from './readiness.js'
 import { skillsSource } from './release.js'
 import type { CommandDeps } from './commands-core.js'
@@ -18,6 +18,8 @@ export const SKILLS_SOURCE: string | null = skillsSource()
  */
 const SKILLS_SOURCE_LABEL = SKILLS_SOURCE ?? 'the public release tag matching this CLI'
 
+const SKILL_SCOPES: readonly SkillScope[] = ['project', 'global']
+
 function skillSourceParts(): { source: string; ref: string } | null {
   if (SKILLS_SOURCE === null) return null
   const match = /^([^#]+)#(.+)$/.exec(SKILLS_SOURCE)
@@ -35,13 +37,23 @@ function expectedSkill(skill: NativeSkill): boolean {
   )
 }
 
-export async function skillReadiness(
-  deps: CommandDeps,
-  selectedScope?: SkillScope,
-): Promise<ReadinessState> {
-  const scopes: SkillScope[] = selectedScope === undefined ? ['project', 'global'] : [selectedScope]
+function skillPin(skill: NativeSkill): string {
+  return skill.ref ?? 'unknown pin'
+}
+
+export interface ScopedNotifaiSkills {
+  installed: NativeSkill[]
+  errors: string[]
+}
+
+/**
+ * Installer-managed notifai skills in both scopes. Duplicate detection has to
+ * see the pair; a selected-scope filter would hide the copy the harness still
+ * lists.
+ */
+export async function listScopedNotifaiSkills(deps: CommandDeps): Promise<ScopedNotifaiSkills> {
   const results = await Promise.all(
-    scopes.map(async (scope) => {
+    SKILL_SCOPES.map(async (scope) => {
       if (deps.nativeSkills === undefined) return { scope, skills: [] as NativeSkill[] }
       try {
         return { scope, ...(await deps.nativeSkills.list(scope, deps.cwd, deps.env)) }
@@ -50,19 +62,70 @@ export async function skillReadiness(
       }
     }),
   )
-  const installed = results.flatMap(({ skills }) => skills).find(expectedSkill)
-  if (installed !== undefined) {
+  return {
+    installed: results.flatMap(({ skills }) => skills.filter((skill) => skill.name === 'notifai')),
+    errors: results
+      .filter((result) => result.error !== undefined)
+      .map((result) => `${result.scope}: ${result.error}`),
+  }
+}
+
+function duplicateSkillState(installed: NativeSkill[], selectedScope?: SkillScope): ReadinessState {
+  const project = installed.find((skill) => skill.scope === 'project')
+  const global = installed.find((skill) => skill.scope === 'global')
+  const projectPin = project === undefined ? 'not installed' : skillPin(project)
+  const globalPin = global === undefined ? 'not installed' : skillPin(global)
+  return {
+    id: 'skill',
+    title: 'Agent guidance skill',
+    status: 'gap',
+    detail:
+      `project (${projectPin}) and global (${globalPin}) are both installed, so the harness lists both. ` +
+      'Keep either project or global and uninstall the other.',
+    technical: {
+      project:
+        project === undefined
+          ? null
+          : { ref: project.ref, path: project.path, current: expectedSkill(project) },
+      global:
+        global === undefined
+          ? null
+          : { ref: global.ref, path: global.path, current: expectedSkill(global) },
+      resolution: 'both-listed',
+    },
+    remedy:
+      selectedScope === undefined
+        ? {
+            by: 'user-here',
+            summary:
+              'keep either the project or the machine-global skill and uninstall the other; add --global to remove the machine-global copy',
+            command: `npx -y ${SKILLS_INSTALLER_SPEC} remove notifai`,
+          }
+        : {
+            by: 'cli',
+            summary: `keep the ${selectedScope} skill and uninstall the other`,
+            command: `notifai init --skills --setup-scope ${selectedScope}`,
+          },
+  }
+}
+
+export async function skillReadiness(
+  deps: CommandDeps,
+  selectedScope?: SkillScope,
+): Promise<ReadinessState> {
+  const { installed, errors } = await listScopedNotifaiSkills(deps)
+  if (installed.length > 1) return duplicateSkillState(installed, selectedScope)
+
+  const current = installed.find(expectedSkill)
+  if (current !== undefined) {
     return {
       id: 'skill',
       title: 'Agent guidance skill',
       status: 'ready',
-      detail: `installed from ${SKILLS_SOURCE_LABEL} in the ${installed.scope} scope`,
+      detail: `installed from ${SKILLS_SOURCE_LABEL} in the ${current.scope} scope`,
     }
   }
 
-  const errors = results
-    .filter((result) => result.error !== undefined)
-    .map((result) => `${result.scope}: ${result.error}`)
   const scopeText = selectedScope === undefined ? 'project or machine-global scope' : `${selectedScope} scope`
   return {
     id: 'skill',
@@ -77,8 +140,8 @@ export async function skillReadiness(
       summary: 'install the skill agents follow when deciding to notify',
       command:
         selectedScope === undefined
-          ? 'notifai init --skills'
-          : `notifai init --skills --skills-scope ${selectedScope}`,
+          ? 'notifai init --skills --setup-scope project'
+          : `notifai init --skills --setup-scope ${selectedScope}`,
     },
   }
 }