carrick 0.3.83 → 0.3.85

package/dist/init/run.js

@@ -9,41 +9,70 @@
 // this many packages, this index.
 import fs from "node:fs";
 import path from "node:path";
-import { spawnSync } from "node:child_process";
 import { readCredential } from "../auth/credentials.js";
 import { signIn } from "../auth/run.js";
 import { resolveRepos } from "../auth/read.js";
 import { deriveWorkspace, selectedProposal, selectRepos, writeProposal, PROPOSAL_FILE, repoIdentity, } from "./repos.js";
 import { connectRepos, reposAreInProject, projectAssignments } from "./connect.js";
-import { downloadHostedIndex, hostedReport, nativeRunner } from "./hosted.js";
+import { DOWNLOAD_LABEL, downloadHostedIndex, hostedReport, nativeRunner } from "./hosted.js";
 import { createProject, listProjects, planProject, projectLabel, projectStep, SLUG, } from "./projects.js";
-import { connectMcpClients, mcpLine } from "./mcp.js";
+import { connectMcpClients, mcpLine, offeredFileClients } from "./mcp.js";
 import { hookCommand, mergeCarrickHooks, removeCarrickHooks } from "./settings.js";
 import { CODEX_HOOKS_FILE, writeCodexHooks } from "./codex.js";
 import { ignoredSkillRoots, taskSkillLines, writeTaskSkills } from "./task-skills.js";
+import { recordCliVersion } from "./outdated.js";
+import { findCarrick, offerGlobalInstall } from "../global-install.js";
+import { currentVersion } from "../update.js";
 import { writeIfChanged } from "./files.js";
 import { excludedRepos, writeSelection, WORKSPACE_FILE } from "./workspace-file.js";
 import { createOutput, DOCS, PromptCancelled } from "./output.js";
-import { renderTemplate } from "../templates.js";
+import { renderTemplate, TEMPLATE_PATHS } from "../templates.js";
 /**
- * The one sentence the run ends on.
+ * The repos this run covers that the scaffold tool still has work in.
  *
- * The scaffold tool carries the instructions — which files to create, how to
- * seed `carrick.json` from the proposal, whether to run the scan at all
- * (carrick-cloud#832) — so the terminal names the tool and stops. The copy
- * that used to stand here was a second statement of the same instructions, and
- * two copies of a sequence drift.
+ * The two files that tool writes: the `carrick.json` a scan reads, and the
+ * workflow that runs the scan. A repo holding both has been scaffolded, and
+ * the closing instruction is then an instruction to do nothing — which is what
+ * it was on a folder where every repo was already set up (carrick#1365).
  *
- * The argument is named because the tool's branch turns on it and turns soft
- * without it: `repo` is what resolves the hosted rows, and with no `repo` the
- * response keeps its default ending and tells the agent to run the scan — on a
- * repo CI already indexes, which is the row the whole workspace reads
- * (carrick-cloud `src/tools/scaffold.ts`, cloud#805 item 1).
+ * The repo root only, because that is where the scanner looks for a config
+ * (`Config::load_services`): a `carrick.json` deeper in the tree is a fixture
+ * or a nested example, not this repo's.
  */
-export const SCAFFOLD_SENTENCE = "Run the carrick scaffold tool for this repo, passing its owner/repo as `repo`, and follow what it returns.";
+export function reposToScaffold(repos, exists = fs.existsSync) {
+    return repos.filter((repo) => !exists(path.join(repo.path, TEMPLATE_PATHS["carrick.json"])) ||
+        !exists(path.join(repo.path, TEMPLATE_PATHS.workflow)));
+}
+/**
+ * The instruction to paste, naming the repos it is about.
+ *
+ * The scaffold tool's branch turns on `repo` and turns soft without it: with
+ * no `repo` the response keeps its default ending and tells the agent to run
+ * the scan — on a repo CI already indexes, which is the row the whole
+ * workspace reads (carrick-cloud `src/tools/scaffold.ts`, cloud#805 item 1).
+ * So the names are in the sentence, one call per repo.
+ */
+export function scaffoldSentence(repos) {
+    const names = repos.map((repo) => repo.name ?? path.basename(repo.path));
+    if (names.length === 1) {
+        return `Run the carrick scaffold tool for ${names[0]}, passing its owner/repo as \`repo\`, and follow what it returns.`;
+    }
+    const shown = names.length > 3 ? `${names.slice(0, 3).join(", ")} and ${names.length - 3} more` : names.join(", ");
+    return `Run the carrick scaffold tool for ${shown}, once each, passing that repo's owner/repo as \`repo\`, and follow what it returns.`;
+}
+/** What a run with nothing left to set up closes on: what this machine can do now. */
+export const READY_SENTENCE = "The index is on this machine: `carrick check <file>` answers for a file, and your agent can ask who calls an operation.";
 const OWNER_REPO = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
 export function parseArgs(argv, cwd = process.cwd()) {
-    const options = { workspace: cwd, project: null, repos: [], assumeYes: false, allowMove: false };
+    const options = {
+        workspace: cwd,
+        project: null,
+        repos: [],
+        editors: [],
+        assumeYes: false,
+        allowMove: false,
+        installGlobal: false,
+    };
     for (let index = 0; index < argv.length; index += 1) {
         const argument = argv[index];
         switch (argument) {
@@ -51,6 +80,9 @@ export function parseArgs(argv, cwd = process.cwd()) {
             case "-y":
                 options.assumeYes = true;
                 break;
+            case "--install-global":
+                options.installGlobal = true;
+                break;
             case "--allow-move":
                 options.allowMove = true;
                 break;
@@ -65,6 +97,20 @@ export function parseArgs(argv, cwd = process.cwd()) {
                 index += 1;
                 break;
             }
+            case "--mcp": {
+                const value = argv[index + 1];
+                if (!value)
+                    return "--mcp needs an editor name";
+                for (const name of value.split(",")) {
+                    const trimmed = name.trim();
+                    if (trimmed === "")
+                        return `invalid editor "${name}": name it as carrick init prints it`;
+                    if (!options.editors.includes(trimmed))
+                        options.editors.push(trimmed);
+                }
+                index += 1;
+                break;
+            }
             case "--repo": {
                 const value = argv[index + 1];
                 if (!value)
@@ -100,7 +146,7 @@ export function parseArgs(argv, cwd = process.cwd()) {
 }
 function help() {
     return [
-        "carrick init [DIRECTORY] [--repo OWNER/REPO]... [--project SLUG] [--allow-move]",
+        "carrick init [DIRECTORY] [--repo OWNER/REPO]... [--project SLUG] [--mcp EDITOR] [--allow-move]",
         "",
         "Sign in (here, or beforehand with carrick login), then set up a repository",
         "or a folder of repos: which repos this install covers, the project, the repo",
@@ -123,17 +169,29 @@ function help() {
         "                         querying either project can see, so the move is named",
         "                         and asked about separately",
         "        --allow-move     Accept those moves without being asked. --yes does not",
+        "        --mcp EDITOR     Also add Carrick to this editor's own MCP configuration,",
+        "                         which is a file outside this workspace: repeatable, or one",
+        "                         comma-separated list. Without a terminal no editor file is",
+        "                         written unless this names one, and --yes does not name one",
         "    -y, --yes            Take the proposal as printed",
+        "        --install-global Install carrick on this machine where there is none,",
+        "                         so the agent hooks can run it by name after this run",
+        "                         ends. A terminal is asked instead; --yes is not this",
         "",
         `The editor extension, the hooks, CI and a carrick.json written by hand: ${DOCS}`,
     ].join("\n");
 }
-/** Whether a command answers on this machine, for a line we should not print. */
-function onPath(command) {
-    const probe = spawnSync(process.platform === "win32" ? "where" : "which", [command], {
-        stdio: "ignore",
-    });
-    return probe.status === 0;
+/**
+ * Whether `carrick` answers on this machine after this run ends.
+ *
+ * Not `which`: npm puts the exec tree's own `node_modules/.bin` first on PATH
+ * for the child it runs, so inside `npx carrick init` a `which carrick` says
+ * yes on a machine with no global — and the hooks were then written as a bare
+ * `carrick hook post-edit`, naming a command that stopped existing when npx
+ * exited (carrick#1372). `findCarrick` skips the copy doing the looking.
+ */
+function carrickOnPath() {
+    return findCarrick() !== null;
 }
 /**
  * The repos a project holds that this folder does not, one line per project.
@@ -222,18 +280,6 @@ export function mcpClientLines(mcp) {
         .filter((outcome) => outcome.state === "written" && outcome.client !== "Claude Code")
         .map((outcome) => `MCP added for ${outcome.client}: ${outcome.detail}`);
 }
-/**
- * One warning per client connected before the install id existed.
- *
- * Not a failure — the client works, and this run deliberately changed nothing
- * on its entry — so the line is the client, what is missing, and the commands
- * that put it there, which are the owner's to run (`mcp.ts`).
- */
-export function mcpUnstampedLines(mcp) {
-    return mcp
-        .filter((outcome) => outcome.state === "unstamped")
-        .map((outcome) => `${outcome.client}: ${outcome.detail}`);
-}
 /**
  * An end to the run with its own exit code, decided before anything is written.
  *
@@ -260,14 +306,70 @@ export const CANCELLED = "Cancelled. Nothing was written, here or in Carrick.";
  * they were, and both say it.
  */
 export const NOTHING_WRITTEN = "Nothing written, here or in Carrick.";
-/** A repo as the picker lists it: what it is called, and what is in it. */
-export function repoChoices(plan, candidates) {
+/**
+ * The repos that start selected, and why each of the others does not.
+ *
+ * A default is a claim about somebody's folder, so only the repos something
+ * already says belong here carry one: connected to this workspace, and in the
+ * project most of this folder's connected repos are in. Everything else — a
+ * repo nobody connected, one sitting in a different project, one with no
+ * GitHub identity to ask about — starts out, with the reason on its row, and
+ * the reader adds it in one keystroke (carrick#1365).
+ *
+ * Two cases preselect nothing at all, and neither is in the ruling because
+ * neither is a majority: a folder where nothing is connected (a first run), and
+ * a tie between two projects. A guess there is a guess about which half of
+ * somebody's folder this install is for.
+ *
+ * Unconnected is not the same as unknown: with no read of the workspace — no
+ * login yet, or a read that did not answer — `identity` is null and nothing is
+ * preselected, because "not connected" would then be this command's assumption
+ * rather than the server's answer.
+ */
+export function preselectedRepos(candidates, identity, label = (slug) => slug) {
+    const reasons = new Map();
+    const project = new Map();
+    for (const repo of candidates) {
+        if (repo.name === null) {
+            reasons.set(repo.path, "no GitHub identity");
+            continue;
+        }
+        if (identity === null)
+            continue;
+        const row = identity.repos.find((entry) => entry.full_name.toLowerCase() === repo.name?.toLowerCase());
+        if (row === undefined || !row.connected) {
+            reasons.set(repo.path, "not connected");
+            continue;
+        }
+        project.set(repo.path, row.project_slug);
+    }
+    const counts = new Map();
+    for (const slug of project.values()) {
+        if (slug !== null)
+            counts.set(slug, (counts.get(slug) ?? 0) + 1);
+    }
+    const ranked = [...counts.entries()].sort((left, right) => right[1] - left[1]);
+    const majority = ranked.length > 0 && (ranked.length === 1 || ranked[0][1] > ranked[1][1]) ? ranked[0][0] : null;
+    const keep = [];
+    for (const [repoPath, slug] of project) {
+        if (majority !== null && slug === majority)
+            keep.push(repoPath);
+        else if (slug === null)
+            reasons.set(repoPath, "connected, in no project");
+        else
+            reasons.set(repoPath, `in ${label(slug)}`);
+    }
+    return { keep, reasons };
+}
+/** A repo as the picker lists it: what it is called, what is in it, and why it is out. */
+export function repoChoices(plan, candidates, reasons = new Map()) {
     return candidates.map((repo) => {
         const found = plan.repos.find((entry) => entry.path === repo.path);
         const packages = found?.services.length ?? 0;
+        const reason = reasons.get(repo.path);
         const hint = [
             `${packages} package${packages === 1 ? "" : "s"}`,
-            ...(repo.name === null ? ["no GitHub identity"] : []),
+            ...(reason === undefined ? [] : [reason]),
         ].join(", ");
         return { value: repo.path, label: repo.name ?? path.basename(repo.path), hint };
     });
@@ -298,7 +400,8 @@ export async function chooseRepos(plan, candidates, options, out) {
     if (!options.interactive) {
         throw new Error(`${plan.workspace} holds ${candidates.length} repos and there is no terminal to choose in. Name the ones this install covers with --repo owner/repo (repeatable), or add --yes to cover all ${candidates.length}.`);
     }
-    const kept = new Set(await out.choose("Which repos does this install cover?", repoChoices(plan, candidates)));
+    const { keep, reasons } = preselectedRepos(candidates, options.identity ?? null, options.label);
+    const kept = new Set(await out.choose("Which repos does this install cover?", "a repo", repoChoices(plan, candidates, reasons), { initial: keep, required: true }));
     return candidates.filter((repo) => kept.has(repo.path));
 }
 /**
@@ -328,6 +431,50 @@ export function namedButExcluded(workspace, excluded, requested, identify = repo
         return identity.name !== null && wanted.has(identity.name.toLowerCase());
     });
 }
+/**
+ * Which editors outside the workspace get an MCP entry written for them.
+ *
+ * The answer is a set of names, and the default is the empty one: these are
+ * files in somebody's home directory for editors they may not use, so the
+ * strongest thing a configuration directory can do is put a row in the
+ * question (carrick#1365). An editor whose own command answers on PATH starts
+ * ticked; without a terminal, `--mcp` names them and nothing else is written.
+ *
+ * `--yes` does not cover these. It takes the proposal as printed — a list of
+ * packages and a set of files inside this workspace — and an entry in
+ * `~/.cursor/mcp.json` is neither.
+ */
+export async function chooseEditors(offered, options, out) {
+    if (offered.length === 0)
+        return [];
+    if (options.editors.length > 0) {
+        const known = new Map(offered.map((client) => [client.name.toLowerCase(), client.name]));
+        const chosen = [];
+        for (const wanted of options.editors) {
+            const name = known.get(wanted.toLowerCase());
+            if (name === undefined) {
+                throw new Error(`--mcp ${wanted} names no editor configured on this machine. The ones here are: ${offered.map((client) => client.name).join(", ")}.`);
+            }
+            if (!chosen.includes(name))
+                chosen.push(name);
+        }
+        return chosen;
+    }
+    if (!options.interactive || options.assumeYes)
+        return [];
+    return out.choose("Which editors should Carrick be added to? These files are outside this workspace.", "an editor", offered.map((client) => ({
+        value: client.name,
+        label: client.name,
+        hint: client.installed ? client.file : `${client.file}, not detected on this machine`,
+    })), { initial: offered.filter((client) => client.installed).map((client) => client.name), required: false });
+}
+/** What the proposal question adds when an editor file is part of the answer. */
+export function editorClause(offered, chosen) {
+    const files = offered.filter((client) => chosen.includes(client.name)).map((client) => client.file);
+    if (files.length === 0)
+        return "";
+    return `, and add Carrick to ${files.join(" and ")}`;
+}
 /** The repos this install covers, one line each, for the proposal. */
 export function coverageLines(plan, selected) {
     return selected.slice(0, 10).map((repo) => {
@@ -387,6 +534,11 @@ export async function initWith(argv, out, interactive) {
     const movable = new Set();
     // The directory names this run leaves out, for the workspace file below.
     let deselected = [];
+    // The editors outside this workspace the answer covers, settled before it.
+    let editors = [];
+    // The repos this install covers, for the closing line that names what is
+    // still to set up in them.
+    let selectedRepos = [];
     try {
         // What a previous run wrote down, before anything is derived from it: the
         // scanner has already dropped an excluded repo by the time the proposal
@@ -404,9 +556,43 @@ export async function initWith(argv, out, interactive) {
         // and a run nobody has chosen in yet must not have signed anything in.
         derived = deriveWorkspace(workspace);
         const candidates = derived.plan.repos.map((repo) => repoIdentity(repo.path));
-        const selected = await chooseRepos(derived.plan, candidates, { repos: parsed.repos, assumeYes: parsed.assumeYes, interactive }, out);
+        // What Carrick already knows about this folder, before the picker draws
+        // its defaults. A read, not a write: the credential has to exist already,
+        // so a machine nobody has signed in on still chooses first and signs in
+        // afterwards, which is what keeps "nothing written, here or in Carrick"
+        // true of a cancelled run (carrick#1338). A read that does not answer
+        // preselects nothing rather than guessing, and the authoritative read
+        // below then reports the failure in its own words.
+        const saved = readCredential();
+        let known = null;
+        projects = null;
+        const knownNames = [...new Set(candidates.map((repo) => repo.name).filter((name) => name !== null))];
+        // Only where a picker is actually going to draw. Every other path has its
+        // answer already — `--repo` names it, `--yes` takes the list as derived, a
+        // single repo is not a choice — and asking about a repo whose name the
+        // reader never offered is a request that buys nothing (carrick#1338's
+        // test pins it: a repo left out is named in no request at all).
+        const picking = parsed.repos.length === 0 && !parsed.assumeYes && interactive && candidates.length > 1;
+        if (picking && saved !== null && knownNames.length > 0) {
+            try {
+                known = await resolveRepos(saved.token, knownNames);
+                projects = await listProjects(saved.token);
+            }
+            catch {
+                known = null;
+                projects = null;
+            }
+        }
+        const selected = await chooseRepos(derived.plan, candidates, {
+            repos: parsed.repos,
+            assumeYes: parsed.assumeYes,
+            interactive,
+            identity: known,
+            label: (slug) => projectLabel(slug, projects),
+        }, out);
         if (selected.length === 0)
             throw new Stop(0);
+        selectedRepos = selected;
         derived = selectedProposal(derived, selected.map((repo) => repo.path));
         const kept = new Set(selected.map((repo) => repo.path));
         deselected = candidates
@@ -420,7 +606,6 @@ export async function initWith(argv, out, interactive) {
         // to run another command: `carrick login` is the same browser round trip,
         // and refusing to take it was the first thing a new install did
         // (carrick#955). Without a terminal there is no browser to hand it to.
-        const saved = readCredential();
         if (saved)
             credential = saved;
         else {
@@ -461,12 +646,19 @@ export async function initWith(argv, out, interactive) {
             // later upload has no repo identity to resolve a project from.
             out.warn("No repo here names a GitHub repository, so this run chooses no project and checks no connection.");
         }
-        initial = await resolveRepos(credential.token, names);
+        // The read the rest of this run is decided from. The one the picker's
+        // defaults came from is reused only where the selection kept every repo,
+        // because `project_repos` answers for the repos that were ASKED about: a
+        // wider read would have the absent-repo lines below naming projects this
+        // install does not cover (carrick#993 row 18).
+        const everyCandidate = known !== null && names.length === knownNames.length;
+        initial = everyCandidate && known !== null ? known : await resolveRepos(credential.token, names);
         // Read once, for the names: every project this run prints is printed as
         // the dashboard shows it, with the slug beside it (carrick#1338). A
         // workspace whose API has no such action answers null and the lines carry
         // slugs alone, as they did.
-        projects = names.length > 0 ? await listProjects(credential.token) : null;
+        if (projects === null)
+            projects = names.length > 0 ? await listProjects(credential.token) : null;
         // The project half of the browser round trip, where this API can do it
         // from here. Nothing is created or moved in it: it settles what this run
         // would do, and the proposal below is where that is accepted. Without
@@ -527,14 +719,24 @@ export async function initWith(argv, out, interactive) {
             if (decision.create)
                 out.say(`  Project "${project}" will be created in this workspace`);
         }
+        // Which editors get an entry, asked before the yes that covers it. The
+        // files are outside the workspace and belong to editors this reader may not
+        // use, and they used to be written on the strength of a yes to the proposal
+        // (carrick#1365). An editor with no configuration directory is not offered,
+        // and one this machine has no command for is offered unticked.
+        const offered = offeredFileClients();
+        editors = await chooseEditors(offered, { editors: parsed.editors, assumeYes: parsed.assumeYes, interactive }, out);
         const subject = packagesFound(plan);
         if (!parsed.assumeYes) {
             if (!interactive) {
                 throw new Stop(1, `use --yes to accept this proposal without a terminal${moving.length > 0 && !parsed.allowMove ? ", and --allow-move to accept the move above" : ""}.`);
             }
             // The count is in the question, because the listing that used to stand
-            // above it is gone: this is where a reader decides (carrick#1026).
-            if (!(await out.confirm(`Write the proposal for ${subject} and configure hooks?`))) {
+            // above it is gone: this is where a reader decides (carrick#1026). The
+            // editor files are named in it too, because a question that does not
+            // name a file is not consent to write it.
+            const alsoEditors = editorClause(offered, editors);
+            if (!(await out.confirm(`Write the proposal for ${subject} and configure hooks${alsoEditors}?`))) {
                 out.refuse(NOTHING_WRITTEN);
                 throw new Stop(0);
             }
@@ -659,7 +861,27 @@ export async function initWith(argv, out, interactive) {
     // connection, for work that crosses repos this machine does not hold,
     // configured for every client this machine has rather than printed for one
     // of them (carrick#955).
-    const command = hookCommand({ onPath });
+    // Before the hook commands are decided, because what they say depends on the
+    // answer: with a global, they are the bare `carrick`, which every shell and
+    // every agent on this machine resolves; without one, they name this install,
+    // and an npx cache is cleared (carrick#1372). A machine that already has one
+    // was brought level before this command started.
+    try {
+        await offerGlobalInstall({
+            assumeYes: parsed.assumeYes,
+            install: parsed.installGlobal,
+            confirm: (question) => out.confirm(question),
+            say: (line) => out.warn(line),
+        });
+    }
+    catch (error) {
+        // Including a cancelled prompt: somebody answering Ctrl-C to an offer is
+        // answering the offer, not ending the setup.
+        if (!(error instanceof PromptCancelled)) {
+            out.warn(`The global install was not offered: ${error.message}`);
+        }
+    }
+    const command = hookCommand({ onPath: carrickOnPath });
     const settingsName = path.join(".claude", command.bare ? "settings.json" : "settings.local.json");
     const settingsFile = path.join(workspace, settingsName);
     let hooksWritten = true;
@@ -702,6 +924,10 @@ export async function initWith(argv, out, interactive) {
             out.done(line);
         for (const line of warn)
             out.warn(line);
+        // Which build wrote them, so a hook running an older `carrick` than this
+        // one says so instead of answering from files it does not match
+        // (carrick#1372).
+        recordCliVersion(workspace, currentVersion());
         const ignored = ignoredSkillRoots(workspace);
         if (ignored.length > 0) {
             const one = ignored.length === 1;
@@ -711,21 +937,17 @@ export async function initWith(argv, out, interactive) {
     catch (error) {
         out.refuse(`Could not write the task skills: ${error.message}`);
     }
-    const mcp = connectMcpClients();
+    const mcp = connectMcpClients(editors);
     if (hooksWritten)
         out.done(configuredLine(mcp));
     for (const line of mcpClientLines(mcp))
         out.done(line);
-    if (!command.bare) {
-        out.warn(`\`carrick\` is not on PATH, so the hooks in ${settingsName} name this install. Run \`npm install -g carrick\` and carrick init again for the short command.`);
-    }
+    // Nothing here about `carrick` not being on PATH: the offer above said it, in
+    // front of the decision it changes, and with the command for this machine's
+    // package manager rather than a guess at npm (carrick#1372).
     for (const outcome of mcp.filter((entry) => entry.state === "failed")) {
         out.warn(`MCP not configured for ${outcome.client}: ${outcome.detail}`);
     }
-    // Connected, and older than the install id: nothing was changed on that
-    // entry and nothing here failed (carrick-cloud#890, `mcp.ts`).
-    for (const line of mcpUnstampedLines(mcp))
-        out.warn(line);
     if (mcp.length === 0)
         out.warn(`No agent client found on this machine. In Claude Code: ${mcpLine()}`);
     // No paid scan ran here, and that is the point (carrick-cloud#799): the one
@@ -736,13 +958,25 @@ export async function initWith(argv, out, interactive) {
     if (hostedIndex.length > 0) {
         // The step reports its own outcome, so the read is one line in a terminal
         // as well as in a pipe: a spinner that stopped with its label spent a
-        // second line on the same event (carrick#1032).
-        await out.step("Reading the hosted index into .carrick/", () => downloadHostedIndex(plan.workspace, nativeRunner(out.quiet)), hostedReport);
+        // second line on the same event (carrick#1032). What it says while it runs
+        // is the scanner's own count of where it has got to (carrick#1365).
+        const startedAt = Date.now();
+        await out.step(DOWNLOAD_LABEL, (progress) => downloadHostedIndex(plan.workspace, nativeRunner(out.quiet, progress)), (outcome) => hostedReport(outcome, (Date.now() - startedAt) / 1000));
     }
     else {
         out.done("No index yet: your agent runs the one scan");
     }
-    out.note("Next: paste this to your agent", [SCAFFOLD_SENTENCE]);
+    // The scaffold tool writes the files a repo needs; a repo that has them needs
+    // nothing pasted anywhere. The line used to close every run, including one
+    // where every covered repo already had its config and its workflow, and
+    // "this repo" named nothing in a folder of several (carrick#1365).
+    const unscaffolded = reposToScaffold(selectedRepos);
+    if (unscaffolded.length > 0) {
+        out.note("Next: paste this to your agent", [scaffoldSentence(unscaffolded)]);
+    }
+    else {
+        out.done(READY_SENTENCE);
+    }
     out.say(`Docs: ${out.accent(DOCS)}`);
     return 0;
 }