@raidiant/notifai 10.1.0 → 10.1.2

package/dist/commands-init.js

@@ -7,17 +7,20 @@ import { ensurePrivateDirectory } from './atomic-file.js';
 import { ApiCallError, NetworkError } from './client.js';
 import { personalProjectConfigPath } from './config.js';
 import { projectSlugFrom as inferredProjectSlugFrom } from './invocation-context.js';
-import { SKILLS_INSTALLER_SPEC } from './native-skills.js';
-import { firstBlocker, questionRoutingReady, readinessJson, } from './readiness.js';
+import {} from './native-skills.js';
+import { firstRequiredBlocker, isOptionalAutomation, isOptionalSetup, questionRoutingReady, readinessJson, } from './readiness.js';
 import { buildDraft, formatReceipt } from './send.js';
 import { loginCommand } from './commands-auth.js';
-import { EXIT, SETUP_COMMAND, UPDATE_CLI_COMMAND, authedClient, loadLoggedConfig, reportError, } from './commands-core.js';
-import { readyCompanionDevices, supportPageUrl } from './commands-devices.js';
+import { EXIT, SETUP_COMMAND, authedClient, loadLoggedConfig, reportError, updateCliCommand, } from './commands-core.js';
+import { readyCompanionDevices } from './commands-devices.js';
+import { companionPlatformLabel, setupCompanionUrl, } from './setup-destinations.js';
 import { assessReadiness, remedyLine } from './commands-doctor.js';
 import { hooksInstallCommand, pickHarnessesToInstall } from './commands-hooks.js';
 import { observedCompanionReceipt, readSetupProof, setupProofProject, setupProofApplies, setupProofIsStale, writeSetupProof, } 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
 // ---------------------------------------------------------------------------
@@ -36,8 +39,10 @@ function formatWaitBudget(milliseconds) {
 }
 async function closeGap(deps, state, flags) {
     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'
             ? personalProjectConfigPath(deps.cwd, deps.env)
@@ -73,13 +78,27 @@ async function closeGap(deps, state, flags) {
         }
         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.');
             return 'failed';
         }
-        // Refuse rather than reach for a mutable ref: installing the skill from a
-        // moving branch is the one outcome the pin exists to prevent.
+        // Refuse rather than guess a release identity. The production adapter uses
+        // this only as a human label; it verifies and stages npm's bundled skill at
+        // a project-relative local path before it invokes the installer.
         if (SKILLS_SOURCE === null) {
             deps.io.err('Skill installation failed — this build cannot determine its own version, so there is no release tag to install from.');
             return 'failed';
@@ -104,16 +123,18 @@ async function closeGap(deps, state, flags) {
             }
         }
         deps.io.out(`Starting the native npx skills setup for the notifai agent skill (${installScope} scope)...`);
-        const code = await deps.nativeSkills.add({
+        const operation = await deps.nativeSkills.add({
             source: SKILLS_SOURCE,
             skill: 'notifai',
             cwd: deps.cwd,
             env: deps.env,
             scope: installScope,
         });
+        const code = typeof operation === 'number' ? operation : operation.code;
         if (code !== 0) {
-            deps.io.err('Skill installation failed — run it manually with:');
-            deps.io.err(`  npx -y ${SKILLS_INSTALLER_SPEC} add ${SKILLS_SOURCE} --skill notifai${installScope === 'global' ? ' --global' : ''} --yes`);
+            deps.io.err(typeof operation === 'number'
+                ? 'Skill installation failed — rerun `notifai init --skills` after checking the network connection.'
+                : `Skill installation refused — ${operation.error}.`);
         }
         return code === 0 ? 'closed' : 'failed';
     }
@@ -133,12 +154,42 @@ function deviceBridgeMessage(devices) {
         return `Waiting for ${undecided.display_name} to allow the notification prompt…`;
     return 'Waiting for a Companion device to become ready…';
 }
+/** How many Companion Apps this Account has registered, on any platform. */
+async function registeredCompanions(client) {
+    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) {
+    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
@@ -156,20 +207,29 @@ async function waitForReadyDevice(deps, state) {
         return 'failed';
     }
     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.`,
-    ].join('\n'), 'Finish setup on your Companion device');
-    // 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);
-    }
-    if (!(await deps.io.confirm('Wait here while you finish that on your device?', true))) {
-        deps.io.out(`OK — finish device setup when you can (install steps: ${supportUrl}), then re-run \`notifai init\`.`);
+        `${stepsLabel}: ${setupUrl}`,
+        `I will wait up to ${budgetLabel} for a Companion App to become ready.`,
+    ].join('\n'), 'Finish setup on your phone');
+    // 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 phone?', true))) {
+        deps.io.out(`OK — finish that when you can (steps: ${setupUrl}), then re-run \`notifai init\`.`);
         return 'pending';
     }
     const now = deps.now ?? Date.now;
@@ -207,30 +267,48 @@ async function waitForReadyDevice(deps, state) {
         spinner?.error(`The ${budgetLabel} wait timer expired`);
         deps.io.err(`The ${budgetLabel} wait timer expired — setup is not finished, only this wait.`);
         deps.io.err(deviceBridgeMessage(lastDevices).replace(/…$/, '.'));
-        deps.io.err(`Re-run \`notifai init\` later and it will pick up from here (install steps: ${supportUrl}).`);
+        deps.io.err(`Re-run \`notifai init\` later and it will pick up from here (steps: ${setupUrl}).`);
         const keepWaiting = await deps.io.confirm(`Keep waiting for another ${budgetLabel}?`, false);
         if (!keepWaiting) {
             deps.io.out('Stopping the wait. Companion setup can continue; re-run `notifai init` when ready.');
             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, device) {
     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',
     });
 }
@@ -395,7 +473,7 @@ async function runSetupProof(deps) {
 }
 /** Closing a local gap cannot have changed the service, the keychain, or devices. */
 function refreshAfterClose(id) {
-    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;
 }
@@ -412,7 +490,12 @@ function wantsOptional(deps, state, flags) {
         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
@@ -424,26 +507,19 @@ function wantsOptional(deps, state, flags) {
         : 'Install/update the agent guidance skill through the native npx skills flow?';
     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) {
+    return state.id === 'hooks' || state.id === 'skill';
+}
 function isSetupScope(value) {
     return value === 'project' || value === 'global';
 }
-async function resolveSetupScope(deps, flags) {
+/**
+ * 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, flags) {
     if (flags.setupScope !== undefined && !isSetupScope(flags.setupScope)) {
         deps.io.err('Invalid setup scope. Choose `project` or `global`.');
         return 'usage';
@@ -462,11 +538,35 @@ async function resolveSetupScope(deps, flags) {
         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, flags) {
     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?', [
             {
@@ -483,14 +583,27 @@ async function resolveSetupScope(deps, flags) {
         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, flags) {
     const workingDeps = flags.json === true
         ? {
@@ -504,12 +617,14 @@ export async function initCommand(deps, flags) {
             },
         }
         : deps;
-    const setupScope = await resolveSetupScope(workingDeps, flags);
-    if (setupScope === 'usage')
+    const scopeFromFlags = checkSetupScopeFlags(workingDeps, flags);
+    if (scopeFromFlags === 'usage')
         return EXIT.usage;
-    const resolved = {
+    let resolved = {
         ...flags,
-        ...(setupScope === undefined ? {} : { setupScope, skillsScope: flags.skillsScope ?? setupScope }),
+        ...(scopeFromFlags === undefined
+            ? {}
+            : { setupScope: scopeFromFlags, skillsScope: flags.skillsScope ?? scopeFromFlags }),
     };
     await workingDeps.io.intro?.('Notifai setup');
     const skillOpts = resolved.setupScope === undefined ? {} : { skillScope: resolved.setupScope };
@@ -520,6 +635,11 @@ export async function initCommand(deps, flags) {
         ...(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 = null;
     const attempted = new Set();
     // Re-assess after every successful action. This is how a browser approval or
     // companion registration can unlock the next state while the user is still
@@ -530,24 +650,37 @@ export async function initCommand(deps, flags) {
         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)
+                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);
@@ -559,25 +692,33 @@ export async function initCommand(deps, flags) {
                     break;
                 }
                 if (result !== 'closed') {
-                    stop = true;
-                    break;
+                    if (halt())
+                        break;
+                    continue;
                 }
                 readiness = await reassess(refreshAfterClose(state.id));
                 advanced = true;
                 break;
             }
             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;
@@ -590,7 +731,7 @@ export async function initCommand(deps, flags) {
                 workingDeps.io.interactive === true) {
                 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;
@@ -615,50 +756,68 @@ export async function initCommand(deps, flags) {
                 break;
             }
             // 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);
+        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) {
-    return id === 'hooks' || id.startsWith('hooks-') || id === 'question-routing-settings';
-}
 function leftoverOptionals(readiness, flags) {
     return readiness.states.filter((state) => {
         if (state.status !== 'optional-gap')
             return false;
-        if (isHookSubstate(state.id))
+        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, readiness) {
+    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, leftovers) {
     for (const state of leftovers) {
         deps.io.out(`Optional, not set up — ${remedyLine(state)}`);
     }
 }
-async function printInitClose(deps, readiness, flags) {
-    const blocker = firstBlocker(readiness);
+async function printInitClose(deps, readiness, flags, stoppedBy = null) {
+    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((state) => state.id !== 'contract');
     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 = [
@@ -675,7 +834,9 @@ async function printInitClose(deps, readiness, flags) {
             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)) {