@raidiant/notifai 10.1.0 → 10.1.1

package/src/commands-init.ts

@@ -14,7 +14,9 @@ import { personalProjectConfigPath, type CliConfig } from './config.js'
 import { projectSlugFrom as inferredProjectSlugFrom } from './invocation-context.js'
 import { SKILLS_INSTALLER_SPEC, type SkillScope } from './native-skills.js'
 import {
-  firstBlocker,
+  firstRequiredBlocker,
+  isOptionalAutomation,
+  isOptionalSetup,
   questionRoutingReady,
   readinessJson,
   type Readiness,
@@ -26,13 +28,18 @@ import { loginCommand } from './commands-auth.js'
 import {
   EXIT,
   SETUP_COMMAND,
-  UPDATE_CLI_COMMAND,
   authedClient,
   loadLoggedConfig,
   reportError,
+  updateCliCommand,
   type CommandDeps,
 } from './commands-core.js'
-import { readyCompanionDevices, supportPageUrl } from './commands-devices.js'
+import { readyCompanionDevices } from './commands-devices.js'
+import {
+  companionPlatformLabel,
+  setupCompanionUrl,
+  type CompanionPlatform,
+} from './setup-destinations.js'
 import { assessReadiness, remedyLine } from './commands-doctor.js'
 import { hooksInstallCommand, pickHarnessesToInstall } from './commands-hooks.js'
 import {
@@ -45,6 +52,8 @@ import {
 } from './commands-setup-proof.js'
 import { listScopedNotifaiSkills, SKILLS_SOURCE } from './commands-skill.js'
 import { enableProject, projectBinding } from './project-enablement.js'
+import { inspectCliInstallations } from './cli-bin.js'
+import { installHookAdapter } from './hook-adapter.js'
 
 // ---------------------------------------------------------------------------
 // init
@@ -125,7 +134,10 @@ async function closeGap(
   flags: InitFlags,
 ): Promise<GapCloseResult> {
   if (state.id === 'project') {
-    if (flags.setupScope === undefined) return 'failed'
+    // Naming this checkout is local bookkeeping, not skill or hook placement,
+    // so it does not wait on the scope question. Without an explicit answer the
+    // name lands in the checkout it describes, which is the answer a User who
+    // never sees the question would have given.
     const slug = projectSlugFrom(flags.projectId ?? path.basename(deps.cwd))
     const configPath =
       flags.setupScope === 'global'
@@ -160,6 +172,25 @@ async function closeGap(
     return ok ? 'closed' : 'failed'
   }
 
+  if (state.id === 'hooks-adapter') {
+    const effective = inspectCliInstallations(
+      deps.env,
+      deps.hookPlatform ?? process.platform,
+    ).effective
+    if (effective === null || effective.artifact_path === null) return 'failed'
+    try {
+      installHookAdapter(
+        { execPath: process.execPath, scriptPath: effective.artifact_path },
+        deps.hookAdapterHome,
+        deps.hookPlatform ?? process.platform,
+      )
+      return 'closed'
+    } catch (err) {
+      deps.io.err(`Could not retarget Question Routing: ${String(err)}`)
+      return 'failed'
+    }
+  }
+
   if (state.id === 'skill') {
     if (deps.nativeSkills === undefined) {
       deps.io.err('Skill installation failed — the native `npx skills` flow is unavailable.')
@@ -232,12 +263,44 @@ function deviceBridgeMessage(devices: readonly RoutableDevice[]): string {
   return 'Waiting for a Companion device to become ready…'
 }
 
+/** How many Companion Apps this Account has registered, on any platform. */
+async function registeredCompanions(client: ApiClient): Promise<number> {
+  try {
+    const response = await client.listDevices()
+    return response.devices.filter(
+      (device) => device.platform === 'ios' || device.platform === 'android',
+    ).length
+  } catch {
+    // Unreachable here means unreachable for the wait that follows; ask, so a
+    // User with nothing installed still gets the platform-specific steps.
+    return 0
+  }
+}
+
+/**
+ * Which phone the notifications should arrive on.
+ *
+ * Asked in the User's words, here, so the destination this terminal opens is
+ * already about their phone rather than an index they have to choose from
+ * again on the other screen. A run with no human gets nothing — it opens no
+ * browser and answers no question — so there is no prompt to hang on.
+ */
+async function askCompanionPlatform(deps: CommandDeps): Promise<CompanionPlatform | null> {
+  if (deps.io.interactive !== true || deps.io.select === undefined) return null
+  const selected = await deps.io.select('Where do you want to receive notifications?', [
+    { value: 'iphone', label: 'iPhone' },
+    { value: 'android', label: 'Android' },
+  ])
+  return selected === 'iphone' || selected === 'android' ? selected : null
+}
+
 /**
  * Observe the supported Device Installation path while the user finishes the
- * app-side work. The live bridge is the dashboard `/support` page (controlled
- * Companion installation steps). Interactive runs offer to open it so the user
- * never types the URL; non-interactive/agent paths only print plain text and
- * never wait on a prompt.
+ * app-side work. The bridge is one focused setup destination for the platform
+ * they just named — not the omnibus help page, whose own next step is to go
+ * somewhere else. Interactive runs offer to open it so the user never types
+ * the URL; non-interactive/agent paths only print plain text and never wait on
+ * a prompt.
  *
  * The wait budget is stated up front. On expiry we say the *timer* expired —
  * not the setup — and offer another budget when a human is present. Agents
@@ -256,26 +319,36 @@ async function waitForReadyDevice(deps: CommandDeps, state: ReadinessState): Pro
   }
 
   const budgetLabel = formatWaitBudget(DEVICE_BRIDGE_TIMEOUT_MS)
-  const supportUrl = supportPageUrl(authed.baseUrl)
+  // A phone that is registered but silent needs its permission allowed, not
+  // install steps — and asking which phone would be asking about one they are
+  // already holding. Only a User with nothing registered has a platform still
+  // to name, and that is read from the account rather than from the wording of
+  // the state that got us here.
+  const platform = (await registeredCompanions(authed.client)) === 0
+    ? await askCompanionPlatform(deps)
+    : null
+  const setupUrl = setupCompanionUrl(authed.baseUrl, platform ?? undefined)
+  const stepsLabel =
+    platform === null ? 'Setup steps (no typing)' : `${companionPlatformLabel(platform)} steps (no typing)`
   await deps.io.note?.(
     [
       state.detail,
       remedy.summary,
-      `Install steps (no typing): ${supportUrl}`,
-      `I will wait up to ${budgetLabel} for a Companion device to become ready.`,
+      `${stepsLabel}: ${setupUrl}`,
+      `I will wait up to ${budgetLabel} for a Companion App to become ready.`,
     ].join('\n'),
-    'Finish setup on your Companion device',
+    'Finish setup on your phone',
   )
 
-  // Open the real support page so the user never has to type the URL. Decline
-  // is fine — the URL remains in the note and in the Next: line if they leave.
-  if (await deps.io.confirm('Open install instructions in your browser?', true)) {
-    deps.io.openUrl(supportUrl)
+  // Open the destination so the user never has to type the URL. Decline is
+  // fine — the URL remains in the note and in the Next: line if they leave.
+  if (await deps.io.confirm('Open those steps in your browser?', true)) {
+    deps.io.openUrl(setupUrl)
   }
 
-  if (!(await deps.io.confirm('Wait here while you finish that on your device?', true))) {
+  if (!(await deps.io.confirm('Wait here while you finish that on your phone?', true))) {
     deps.io.out(
-      `OK — finish device setup when you can (install steps: ${supportUrl}), then re-run \`notifai init\`.`,
+      `OK — finish that when you can (steps: ${setupUrl}), then re-run \`notifai init\`.`,
     )
     return 'pending'
   }
@@ -324,7 +397,7 @@ async function waitForReadyDevice(deps: CommandDeps, state: ReadinessState): Pro
     )
     deps.io.err(deviceBridgeMessage(lastDevices).replace(/…$/, '.'))
     deps.io.err(
-      `Re-run \`notifai init\` later and it will pick up from here (install steps: ${supportUrl}).`,
+      `Re-run \`notifai init\` later and it will pick up from here (steps: ${setupUrl}).`,
     )
 
     const keepWaiting = await deps.io.confirm(
@@ -337,29 +410,47 @@ async function waitForReadyDevice(deps: CommandDeps, state: ReadinessState): Pro
       )
       return 'pending'
     }
-    spinner?.message(`Waiting another ${budgetLabel} for a Companion device…`)
+    spinner?.message(`Waiting another ${budgetLabel} for a Companion App…`)
     deadline = now() + DEVICE_BRIDGE_TIMEOUT_MS
   }
 }
 
+/**
+ * The first notification a User ever receives from Notifai.
+ *
+ * It is the payoff of the whole setup, and it used to be written as an
+ * internal receipt: "This real notification completed setup verification" — a
+ * sentence about the check rather than about them — delivered silently, at
+ * `passive`, with the sound turned off. So the one arrival that proves their
+ * agents can reach them landed in Notification Center with no banner and no
+ * sound, where a first-time User has no reason to look and every reason to
+ * conclude that nothing came.
+ *
+ * It now says what is true for them and arrives the way their notifications
+ * will. `done` is the honest kind — a body of work finished successfully — and
+ * it is also what lets the server pick the sound through its own kind, Project
+ * and Account layers instead of this command stamping one and skipping them.
+ */
 function setupProofDraft(
   config: CliConfig,
   device: RoutableDevice,
 ): ReturnType<typeof buildDraft> {
   const project = config.project.value
   return buildDraft(config, {
-    title: 'Notifai is ready',
+    title: 'Your agents can reach you',
     body:
       project === null
-        ? 'This real notification completed setup verification.'
-        : `This real notification completed setup verification for ${project}.`,
-    kind: 'update',
+        ? 'Notifai setup is finished. Notifications from your agents will arrive like this one.'
+        : `Notifai setup is finished for ${project}. Notifications from your agents will arrive like this one.`,
+    kind: 'done',
     platform: device.platform,
     device: [device.device_id],
-    sound: 'none',
+    // Noticeable, not intrusive: a normal banner and sound. Deliberately not
+    // `time_sensitive` — a setup confirmation has no business breaking a Focus.
+    //
     // Android has no caller-selected interruption level. Explicit null keeps an
     // Apple preference in config from leaking into this Android-only proof.
-    level: device.platform === 'ios' ? 'passive' : null,
+    level: device.platform === 'ios' ? 'active' : null,
     collapseKey: 'notifai-setup-verification',
   })
 }
@@ -544,7 +635,7 @@ async function runSetupProof(deps: CommandDeps): Promise<GapCloseResult> {
 
 /** Closing a local gap cannot have changed the service, the keychain, or devices. */
 function refreshAfterClose(id: string): readonly ReadinessRefresh[] | undefined {
-  return id === 'project' || id === 'project-enablement' || id === 'hooks' || id === 'skill' || id === 'question-routing-settings'
+  return id === 'project' || id === 'project-enablement' || id === 'hooks' || id.startsWith('hooks-') || id === 'skill' || id === 'question-routing-settings'
     ? ['local']
     : undefined
 }
@@ -559,7 +650,11 @@ function wantsOptional(deps: CommandDeps, state: ReadinessState, flags: InitFlag
   // asked about, for a human and an agent alike.
   if (state.id === 'project') return Promise.resolve(true)
   if (state.id === 'project-enablement') return Promise.resolve(true)
-  const explicit = state.id === 'hooks' ? flags.hooks : state.id === 'skill' ? flags.skills : undefined
+  // Every other hook sub-state is a report line about routing, not an errand
+  // with a yes/no question of its own; offering the hooks question for one of
+  // them would ask about something the answer does not change.
+  if (state.id !== 'hooks' && state.id !== 'skill') return Promise.resolve(false)
+  const explicit = state.id === 'hooks' ? flags.hooks : flags.skills
   if (explicit !== undefined) return Promise.resolve(explicit)
   // An agent is never asked, and never assumed into a change it did not
   // request: silence means no, and the summary says what was skipped.
@@ -571,30 +666,21 @@ function wantsOptional(deps: CommandDeps, state: ReadinessState, flags: InitFlag
   return deps.io.confirm(question, true)
 }
 
-/**
- * Setup as one step at a time.
- *
- * The old version ran five steps in a fixed order and ended with a list of
- * everything still outstanding. That is a report, and a report is the wrong
- * output here: someone handed five things to do does none of them, and the
- * order was the script's rather than the dependency graph's — it offered to
- * install hooks after a sign-in that had just failed.
- *
- * So this closes what it can, then surfaces exactly one thing, the first that
- * stands in the way. Re-running advances by one. Idempotence stops being a
- * property to preserve and becomes the mechanism: every decision is derived
- * from observed state, so a partial run, a second project, a fresh worktree
- * and a revoked credential are the same code path arriving at different
- * states rather than four branches to enumerate.
- */
+/** The two states whose remedy actually places files the scope question is about. */
+function needsInstallScope(state: ReadinessState): boolean {
+  return state.id === 'hooks' || state.id === 'skill'
+}
+
 function isSetupScope(value: string | undefined): value is SetupScope {
   return value === 'project' || value === 'global'
 }
 
-async function resolveSetupScope(
-  deps: CommandDeps,
-  flags: InitFlags,
-): Promise<SetupScope | undefined | 'usage'> {
+/**
+ * Scope flags are checked before anything runs, because a contradiction is a
+ * usage error and reporting it after half a setup is worse than reporting it
+ * now. Answering the question is a separate step (`scopeForLocalInstall`).
+ */
+function checkSetupScopeFlags(deps: CommandDeps, flags: InitFlags): SetupScope | undefined | 'usage' {
   if (flags.setupScope !== undefined && !isSetupScope(flags.setupScope)) {
     deps.io.err('Invalid setup scope. Choose `project` or `global`.')
     return 'usage'
@@ -615,9 +701,42 @@ async function resolveSetupScope(
     deps.io.err('`--skills-scope` requires `--skills`. Use `--setup-scope` to choose project or machine for the whole setup.')
     return 'usage'
   }
+  const fromFlags = flags.setupScope ?? flags.skillsScope
+  // Asking for an install nobody can be asked about is a usage error, and it
+  // is knowable from the flags alone — so it is reported before a setup runs
+  // half way rather than after.
+  if (
+    fromFlags === undefined &&
+    deps.io.interactive !== true &&
+    (flags.skills === true || flags.hooks === true)
+  ) {
+    deps.io.err(
+      'Unattended setup changes require an explicit scope: pass `--setup-scope project` or `--setup-scope global`.',
+    )
+    return 'usage'
+  }
+  return fromFlags
+}
+
+/**
+ * Where a skill or hook install should land, asked at the moment one is about
+ * to happen and not before.
+ *
+ * It used to be the first thing the product ever said, in front of the
+ * assessment, sign-in and every other gate — a question about skill, hook and
+ * shared-config placement put to someone who had met none of those words and
+ * might never reach the step it decides. Worse, project identity and Project
+ * Enablement were gated on the answer, so an unattended run that could not
+ * produce one advanced nothing at all.
+ *
+ * Now nothing depends on it except the two installs it actually describes.
+ */
+async function scopeForLocalInstall(
+  deps: CommandDeps,
+  flags: InitFlags,
+): Promise<SetupScope | 'declined'> {
   const fromFlags = flags.setupScope ?? flags.skillsScope
   if (fromFlags !== undefined) return fromFlags
-  if (flags.skills === false && flags.hooks === false) return undefined
   if (deps.io.interactive === true && deps.io.select) {
     const selected = await deps.io.select(
       'Should this Notifai setup apply to this project only, or to every project on this machine?',
@@ -636,17 +755,30 @@ async function resolveSetupScope(
     )
     if (selected === 'project' || selected === 'global') return selected
     deps.io.err('No setup scope selected. Pass `--setup-scope project` or `--setup-scope global`.')
-    return 'usage'
-  }
-  if (flags.skills === true || flags.hooks === true) {
-    deps.io.err(
-      'Unattended setup changes require an explicit scope: pass `--setup-scope project` or `--setup-scope global`.',
-    )
-    return 'usage'
+    return 'declined'
   }
-  return undefined
+  deps.io.err(
+    'Unattended setup changes require an explicit scope: pass `--setup-scope project` or `--setup-scope global`.',
+  )
+  return 'declined'
 }
 
+/**
+ * Setup as one step at a time.
+ *
+ * The old version ran five steps in a fixed order and ended with a list of
+ * everything still outstanding. That is a report, and a report is the wrong
+ * output here: someone handed five things to do does none of them, and the
+ * order was the script's rather than the dependency graph's — it offered to
+ * install hooks after a sign-in that had just failed.
+ *
+ * So this closes what it can, then surfaces exactly one thing, the first that
+ * stands in the way. Re-running advances by one. Idempotence stops being a
+ * property to preserve and becomes the mechanism: every decision is derived
+ * from observed state, so a partial run, a second project, a fresh worktree
+ * and a revoked credential are the same code path arriving at different
+ * states rather than four branches to enumerate.
+ */
 export async function initCommand(deps: CommandDeps, flags: InitFlags): Promise<number> {
   const workingDeps: CommandDeps = flags.json === true
     ? {
@@ -660,11 +792,13 @@ export async function initCommand(deps: CommandDeps, flags: InitFlags): Promise<
         },
       }
     : deps
-  const setupScope = await resolveSetupScope(workingDeps, flags)
-  if (setupScope === 'usage') return EXIT.usage
-  const resolved: InitFlags = {
+  const scopeFromFlags = checkSetupScopeFlags(workingDeps, flags)
+  if (scopeFromFlags === 'usage') return EXIT.usage
+  let resolved: InitFlags = {
     ...flags,
-    ...(setupScope === undefined ? {} : { setupScope, skillsScope: flags.skillsScope ?? setupScope }),
+    ...(scopeFromFlags === undefined
+      ? {}
+      : { setupScope: scopeFromFlags, skillsScope: flags.skillsScope ?? scopeFromFlags }),
   }
   await workingDeps.io.intro?.('Notifai setup')
 
@@ -677,6 +811,11 @@ export async function initCommand(deps: CommandDeps, flags: InitFlags): Promise<
       ...(refresh === undefined ? {} : { previous: readiness, refresh }),
     })
   let failed = false
+  // What actually stopped a sign-in, when something did. Without it the close
+  // renders the state as it was before the attempt — "not paired … run
+  // `notifai init`" — which contradicts the correct line printed moments
+  // earlier and sends the reader back into the command that just failed.
+  let loginBlocker: ReadinessState | null = null
   const attempted = new Set<string>()
 
   // Re-assess after every successful action. This is how a browser approval or
@@ -688,23 +827,35 @@ export async function initCommand(deps: CommandDeps, flags: InitFlags): Promise<
 
     for (const state of readiness.states) {
       if (state.status === 'ready') continue
+      // Question Routing is optional automation, so it is reported and never
+      // waited on. `doctor` still fails on a broken route; `init` walks past
+      // it, because a hook diagnostic standing in front of the delivery proof
+      // means a setup that can already send never proves that it can.
+      const optional = isOptionalSetup(state.id)
+      const halt = () => {
+        if (!optional) stop = true
+        return !optional
+      }
       if (state.status === 'unknown') {
-        stop = true
-        break
+        if (halt()) break
+        continue
       }
 
       const remedy = state.remedy
       if (remedy === undefined || attempted.has(state.id)) {
-        if (state.status === 'gap') stop = true
-        if (stop) break
+        if (state.status === 'gap' && halt()) break
         continue
       }
 
       if (state.status === 'optional-gap') {
         if (remedy.by !== 'cli' || !(await wantsOptional(workingDeps, state, resolved))) continue
-        if (resolved.setupScope === undefined && state.id === 'project') {
-          stop = true
-          break
+        if (needsInstallScope(state)) {
+          const scope = await scopeForLocalInstall(workingDeps, resolved)
+          if (scope === 'declined') {
+            attempted.add(state.id)
+            continue
+          }
+          resolved = { ...resolved, setupScope: scope, skillsScope: resolved.skillsScope ?? scope }
         }
         attempted.add(state.id)
         const result = await closeGap(workingDeps, state, resolved)
@@ -715,8 +866,8 @@ export async function initCommand(deps: CommandDeps, flags: InitFlags): Promise<
           break
         }
         if (result !== 'closed') {
-          stop = true
-          break
+          if (halt()) break
+          continue
         }
         readiness = await reassess(refreshAfterClose(state.id))
         advanced = true
@@ -724,16 +875,21 @@ export async function initCommand(deps: CommandDeps, flags: InitFlags): Promise<
       }
 
       if (remedy.by === 'cli') {
-        if (resolved.setupScope === undefined && state.id === 'project') {
-          stop = true
-          break
+        if (needsInstallScope(state)) {
+          const scope = await scopeForLocalInstall(workingDeps, resolved)
+          if (scope === 'declined') {
+            attempted.add(state.id)
+            if (halt()) break
+            continue
+          }
+          resolved = { ...resolved, setupScope: scope, skillsScope: resolved.skillsScope ?? scope }
         }
         attempted.add(state.id)
         const result = await closeGap(workingDeps, state, resolved)
         if (result === 'failed') failed = true
         if (result !== 'closed') {
-          stop = true
-          break
+          if (halt()) break
+          continue
         }
         readiness = await reassess(refreshAfterClose(state.id))
         advanced = true
@@ -749,7 +905,7 @@ export async function initCommand(deps: CommandDeps, flags: InitFlags): Promise<
       ) {
         attempted.add(state.id)
         workingDeps.io.out('Opening your browser to approve this machine — Ctrl-C to stop.')
-        if ((await loginCommand(workingDeps, {})) !== EXIT.ok) {
+        if ((await loginCommand(workingDeps, {}, (blocker) => (loginBlocker = blocker))) !== EXIT.ok) {
           failed = true
           stop = true
           break
@@ -777,33 +933,45 @@ export async function initCommand(deps: CommandDeps, flags: InitFlags): Promise<
       }
 
       // A human-only remedy is the first blocker for an unattended agent.
-      stop = true
-      break
+      if (halt()) break
+      continue
     }
 
     if (stop || !advanced) break
   }
 
+  const blocker = loginBlocker ?? firstRequiredBlocker(readiness)
   if (flags.json === true) deps.io.out(JSON.stringify(readinessJson(readiness), null, 2))
-  else await printInitClose(deps, readiness, resolved)
-  const blocker = firstBlocker(readiness)
+  else await printInitClose(deps, readiness, resolved, loginBlocker)
   if (blocker === null) return failed ? EXIT.failed : EXIT.ok
   return failed || workingDeps.io.interactive !== true ? EXIT.failed : EXIT.ok
 }
 
-function isHookSubstate(id: string): boolean {
-  return id === 'hooks' || id.startsWith('hooks-') || id === 'question-routing-settings'
-}
-
 function leftoverOptionals(readiness: Readiness, flags: InitFlags): ReadinessState[] {
   return readiness.states.filter((state) => {
     if (state.status !== 'optional-gap') return false
-    if (isHookSubstate(state.id)) return false
+    if (isOptionalAutomation(state.id)) return false
+    // Not an install anyone declined, so "Optional, not set up" would misread
+    // it; it gets its own line below.
+    if (state.id === 'cli-bin') return false
     if (state.id === 'skill' && flags.skills === false) return false
     return true
   })
 }
 
+/**
+ * A `notifai` the reader cannot type.
+ *
+ * Said on the way out of every run, successful or not, because every next step
+ * this command prints — here, in the skill, in the README — names a command
+ * that will not be found until it is fixed.
+ */
+function printMissingCliBin(deps: CommandDeps, readiness: Readiness): void {
+  const state = readiness.states.find((candidate) => candidate.id === 'cli-bin')
+  if (state?.status !== 'optional-gap') return
+  deps.io.out(`Heads up: ${state.detail}. ${remedyLine(state)}`)
+}
+
 function printOptionalLeftovers(deps: CommandDeps, leftovers: readonly ReadinessState[]): void {
   for (const state of leftovers) {
     deps.io.out(`Optional, not set up — ${remedyLine(state)}`)
@@ -814,8 +982,9 @@ async function printInitClose(
   deps: CommandDeps,
   readiness: Readiness,
   flags: InitFlags,
+  stoppedBy: ReadinessState | null = null,
 ): Promise<void> {
-  const blocker = firstBlocker(readiness)
+  const blocker = stoppedBy ?? firstRequiredBlocker(readiness)
   const canSend = readiness.states.find((state) => state.id === 'devices')?.status === 'ready'
   const questions = questionRoutingReady(readiness)
   const leftovers = leftoverOptionals(readiness, flags).filter(
@@ -824,10 +993,16 @@ async function printInitClose(
 
   if (blocker?.id === 'contract') {
     deps.io.out(blocker.detail)
-    deps.io.out(UPDATE_CLI_COMMAND)
+    deps.io.out(
+      blocker.remedy?.by !== 'user-elsewhere' && blocker.remedy?.command !== undefined
+        ? blocker.remedy.command
+        : updateCliCommand(deps),
+    )
     return
   }
 
+  printMissingCliBin(deps, readiness)
+
   if (deps.io.interactive === true) {
     if (blocker === null) {
       const lines = [
@@ -846,7 +1021,9 @@ async function printInitClose(
       await deps.io.outro?.('All set ✨')
       return
     }
-    await deps.io.note?.(`${blocker.title} — ${blocker.detail}\n${remedyLine(blocker)}`, 'Next')
+    // No framed copy of what the next three lines already say. The "Ready"
+    // note above adds something the close does not; this one only made a
+    // stopped visit state its one step twice, box then text.
     deps.io.out(`Next: ${blocker.title} — ${blocker.detail}`)
     deps.io.out(`  ${remedyLine(blocker)}`)
     if (shouldRestateInit(blocker)) {