@bli-cockpit/cli 0.2.28 → 0.2.29

package/dist/commands/local.js

@@ -1,52 +1,58 @@
-import { execFile } from "node:child_process";
-import { readdir, readFile, stat } from "node:fs/promises";
-import os from "node:os";
+/**
+ * The `cockpit` subcommands and the router that picks one.
+ *
+ * Read `runLocalCockpitCli` below as the table of contents: one case per
+ * command, each delegating to a `run<Command>` function. The commands that
+ * grew their own supporting cast now live beside this file and are re-exported
+ * here so `./local.js` stays the single published entry point (BLI-3104):
+ *
+ *   local-help.ts        what --help prints, and the recognised command names
+ *   cli-io.ts            stdout/stderr/stdin plumbing and the production CliIo
+ *   install-receipts.ts  the named step results this machine reports back
+ *   local-auth.ts        which email, the OTP exchange, pairing with fallback
+ *   collection-roots.ts  which folders may be collected, saved and read back
+ *   local-discovery.ts   finding git worktrees inside those roots
+ *   collection-report.ts how one collection run reads back to a person
+ *   install-update.ts    install, update, self-update, release
+ *   status.ts            `cockpit status`
+ *   sessions.ts          `cockpit sessions`
+ *
+ * What stays here is orchestration: onboard, login/logout/start, the sync tick,
+ * analyze, serve, autostart and agent-rules.
+ */
 import path from "node:path";
+import { bufferedWritable, defaultExec, defaultIo, errorMessage, parseCapturedJson, replayCaptured, writeLine, } from "./cli-io.js";
+import { isLocalHelpRequest, localCommandHelp } from "./local-help.js";
+import { addInstallEvent, classifySyncHealthError, redactedSyncErrorDetail, reportInstallEventsBestEffort, } from "./install-receipts.js";
+import { canReuseOnboardSession, pairLocalCollectorWithAuthFallback, readOnboardSessionReuseCandidate, requestPairingAccessToken, requestPairingAccessTokenDetailed, resolveInteractiveLoginEmail, resolveOnboardEmail, } from "./local-auth.js";
+import { collectionRootConsentAliases, persistOnboardingRootConfig, resolveOnboardingRootsForCommand, } from "./collection-roots.js";
+import { discoverCommandWorktrees, rememberDiscoveryLimits } from "./local-discovery.js";
+import { attributedSyncRunStatus, cursorStatusLine, displayTicketId, rawEvidenceSyncLine, shortSha, worktreeSyncRow, writeAgentSessionSummary, } from "./collection-report.js";
+import { runInstall, runRelease, runSelfUpdate, runUpdate, SelfUpdateError, } from "./install-update.js";
+import { runStatus } from "./status.js";
+import { runSessions } from "./sessions.js";
 import { createCollectorServer } from "../server.js";
 import { inspectAgentRules, installAgentRules, uninstallAgentRules, } from "../agent-rules.js";
 import { backfillRetryCommand, runBackfill, runBackfillCommand, } from "./backfill.js";
 import { runDoctor } from "./doctor.js";
 import { inspectBackfillLock } from "../backfill-lock.js";
-import { maskLocalIdentifiers, redactedHealthDetail, } from "../health-detail.js";
 import { parseLocalArgs, normalizeUrl } from "./local-args.js";
 import { autostartStatus, installAutostartAgent, uninstallAutostartAgent, } from "../autostart.js";
-import { DEFAULT_DASHBOARD_URL, ensureLocalCollectorConfig, getCollectorRuntimePaths, inspectLocalCollectorStatus, installLocalCollector, logoutLocalCollector, pairLocalCollector, LOCAL_COLLECTOR_VERSION, readLocalCollectorConfig, readLocalCollectorSessionFile, readLocalSessionReference, startLocalWorkContext, } from "../local-state.js";
-import { redactSecretLikeContent, } from "@bli-cockpit/telemetry-core";
-import { CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT, CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES, defaultCodexSessionDirs, scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
-import { scanAndAttributeClaudeSessions } from "../adapters/claude-attribution.js";
-import { backfillCompletionCovers, emptyBackfillCursorState, prepareBackfillCursorForScope, readBackfillCompletionMarker, readBackfillCursor, } from "../cursors/backfill-cursor.js";
+import { DEFAULT_DASHBOARD_URL, ensureLocalCollectorConfig, getCollectorRuntimePaths, inspectLocalCollectorStatus, logoutLocalCollector, LOCAL_COLLECTOR_VERSION, readLocalCollectorConfig, readLocalCollectorSessionFile, startLocalWorkContext, } from "../local-state.js";
 import { acquireSyncLock } from "../sync-lock.js";
-import { collectionRootPathAliases, discoverGitWorktreesInRootsWithStatus, } from "../repo-identity.js";
-import { resolveDiscoveryLimits, saveDiscoveryLimits, } from "../discovery-limits.js";
-import { runAttributedWorktreeSync, matchesLiveSyncWorktree, } from "./session-sync.js";
-import { COLLECTION_ROOT_REQUIRED, missingCollectionRootMessage, normalizeRootsDetailed, resolveOnboardingRoots, rootRejectionExplanation, } from "../onboarding-roots.js";
+import { runAttributedWorktreeSync, } from "./session-sync.js";
+import { COLLECTION_ROOT_REQUIRED, missingCollectionRootMessage, } from "../onboarding-roots.js";
 import { rawEvidenceDedupSummary, rawEvidenceGcSummary, runRawEvidenceLocalGc, sweepDuplicateStagedRawEvidence, } from "../raw-evidence-gc.js";
 import { envWithNodeRuntimeOnPath, runScheduledSelfUpdate, } from "../scheduled-self-update.js";
 import { runAutostartSelfHeal, } from "../autostart-self-heal.js";
-import { enqueueInstallEventEntry, readPendingInstallEventEntries, recordInstallEventAttemptFailure, removeInstallEventEntry, } from "../spool/install-event-outbox.js";
-import { createCapturedExecRunner, createInteractiveExecRunner, } from "../process-runner.js";
 import { normalizeCollectionRoots } from "../root-normalization.js";
-export const rootCommandNames = new Set([
-    "onboard",
-    "update",
-    "upgrade",
-    "do-everything",
-    "fix",
-    "install",
-    "login",
-    "pair",
-    "logout",
-    "start",
-    "sync",
-    "analyze",
-    "backfill",
-    "status",
-    "sessions",
-    "serve",
-    "autostart",
-    "agent-rules",
-    "release",
-]);
+// `./local.js` is the published entry point for this command surface: the
+// public CLI's generated root, commands/root.ts, doctor.ts and the test suite
+// all import from here. Splitting the file must not move a name off it.
+export { rootCommandNames, localCommandHelp } from "./local-help.js";
+export { classifySyncHealthError, redactedSyncErrorDetail, reportInstallEventsBestEffort, SYNC_ERROR_DETAIL_MAX_CHARS, } from "./install-receipts.js";
+export { assertCollectionRootPersisted } from "./collection-roots.js";
+export { runSelfUpdate, SelfUpdateError, } from "./install-update.js";
 export async function runLocalCockpitCli(argv, io = defaultIo()) {
     if (isLocalHelpRequest(argv)) {
         writeLine(io.stdout, localCommandHelp(argv[0]));
@@ -112,553 +118,6 @@ export async function runLocalCockpitCli(argv, io = defaultIo()) {
         return 1;
     }
 }
-export function localCommandHelp(command) {
-    if (command)
-        return localSubcommandHelp(command);
-    return [
-        "  cockpit onboard [--ticket <id>] [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--allow-home-root] [--branch <name>] [--no-auth] [--max-depth <n>] [--max-repos <n>] [--json]",
-        "  cockpit update [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--allow-home-root] [--no-auth] [--json]",
-        "  cockpit upgrade [same flags as update]",
-        "  cockpit do-everything [--workspace <path>] [--dashboard-url <url>] [--update-tag <tag>] [--dry-run] [--json]",
-        "  cockpit fix [same flags as do-everything]",
-        "  cockpit install [--dashboard-url <url>] [--workspace <path>] [--allow-home-root] [--json]",
-        "  cockpit login [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--no-auth] [--json]",
-        "  cockpit pair [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--no-auth] [--json]",
-        "  cockpit logout",
-        "  cockpit start [--ticket <id>|--clear-ticket] [--topic <label>] [--intent <intent>] [--phase <phase>] [--workspace <path>] [--branch <name>] [--max-depth <n>] [--max-repos <n>] [--json]",
-        "  cockpit sync [--workspace <path>] [--dashboard-url <url>] [--max-depth <n>] [--max-repos <n>] [--json]",
-        "  cockpit analyze [--workspace <path>] [--dashboard-url <url>] [--max-depth <n>] [--max-repos <n>] [--json]",
-        "  cockpit backfill (--since-days <n>|--all) [--source codex|claude] [--dry-run] [--max-files <n>] [--max-depth <n>] [--max-repos <n>] [--yes] [--workspace <path>] [--json]",
-        "  cockpit status [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
-        "  cockpit sessions [--source codex|claude] [--since-days <n>|--all] [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
-        "  cockpit serve [--port <port>] [--workspace <path>]",
-        "  cockpit autostart [install|uninstall|status] [--workspace <path>] [--dashboard-url <url>] [--interval-seconds <n>] [--json]",
-        "  cockpit agent-rules [install|uninstall|status] [--host codex|claude|all] [--workspace <path>] [--json]",
-        "  cockpit release [--dry-run] [--skip-checks] [--tag <tag>] [--access <public|restricted>] [--otp <code>]",
-        "",
-        `Default dashboard: ${DEFAULT_DASHBOARD_URL}. Omit --dashboard-url for normal production use; pass it only for staging/custom dashboards or to force a different pairing.`,
-    ].join("\n");
-}
-function localSubcommandHelp(command) {
-    const helpByCommand = new Map([
-        [
-            "onboard",
-            [
-                "Usage: cockpit onboard [--ticket <id>] [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--allow-home-root] [--branch <name>] [--no-auth] [--max-depth <n>] [--max-repos <n>] [--json]",
-                "",
-                "Installs, pairs, starts work context(s), syncs once, completes all-history",
-                "Codex and Claude backfill for the saved roots, and then prints readiness proof.",
-                "If --workspace is a parent folder, scans child git repos/worktrees and rolls them up by repo.",
-                "`--repo <path>` remains supported as a backward-compatible alias.",
-                `Omit --dashboard-url for normal production setup (${DEFAULT_DASHBOARD_URL}).`,
-                "Pass --dashboard-url only for staging/custom dashboards or to force a different pairing.",
-                "Run with no flags in a terminal and it prompts for the dashboard email and OTP code; pass --email to skip the email prompt. Use --no-auth to force the manual approval fallback.",
-                "Interactive runs also offer to add Cockpit ticket-binding rules to AGENTS.md and CLAUDE.md after readiness proof.",
-            ],
-        ],
-        [
-            "install",
-            [
-                "Usage: cockpit install [--dashboard-url <url>] [--workspace <path>] [--allow-home-root] [--json]",
-                "",
-                "Writes local collector config. Pair with `cockpit login`, then run `cockpit start` when work begins.",
-                "`--repo <path>` remains supported as a backward-compatible alias.",
-                "Omit --dashboard-url for the production dashboard; pass it only for staging/custom dashboards.",
-            ],
-        ],
-        [
-            "update",
-            [
-                "Usage: cockpit update [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--allow-home-root] [--no-auth] [--json]",
-                "",
-                "Updates the global public CLI from npm, then reruns `cockpit onboard`",
-                "with the same setup flags so pairing, saved roots, all-history backfill,",
-                "agent rules, autostart, and the initial sync are refreshed in one command.",
-                "`cockpit upgrade` is an alias.",
-            ],
-        ],
-        [
-            "upgrade",
-            [
-                "Usage: cockpit upgrade [same flags as cockpit update]",
-                "",
-                "Alias for `cockpit update`.",
-            ],
-        ],
-        [
-            "do-everything",
-            [
-                "Usage: cockpit do-everything [--workspace <path>] [--dashboard-url <url>] [--update-tag <tag>] [--dry-run] [--json]",
-                "",
-                "Converges a blank, existing, or reused intern machine: latest CLI, interactive auth and collection-root recovery when needed, saved roots, autostart, all-history backfill, raw-evidence GC, and sync freshness.",
-                "`cockpit fix` is an alias.",
-                "Maintainer canary: use `--update-tag next` so self-update and re-exec stay on the prerelease candidate.",
-                "--dry-run prints the checks and would-fix steps without writing config, plists, cursors, or install telemetry.",
-            ],
-        ],
-        [
-            "fix",
-            [
-                "Usage: cockpit fix [same flags as cockpit do-everything]",
-                "",
-                "Alias for `cockpit do-everything`.",
-            ],
-        ],
-        [
-            "login",
-            [
-                "Usage: cockpit login [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--no-auth] [--json]",
-                "",
-                "Signs in with an email OTP when interactive, starts dashboard device pairing, and stores the approved local session.",
-                "Omit --dashboard-url for the production dashboard; pass it only for staging/custom dashboards.",
-            ],
-        ],
-        [
-            "pair",
-            [
-                "Usage: cockpit pair [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--no-auth] [--json]",
-                "",
-                "Alias for `cockpit login`.",
-            ],
-        ],
-        ["logout", ["Usage: cockpit logout [--json]", "", "Removes the local device session."]],
-        [
-            "start",
-            [
-                "Usage: cockpit start [--ticket <id>|--clear-ticket] [--topic <label>] [--topic-summary <summary>] [--intent <intent>] [--phase <phase>] [--intent-confidence <0..1>] [--workspace <path>] [--branch <name>] [--json]",
-                "",
-                "Starts local ambient capture. Parent folders start each child git worktree.",
-                "Add --ticket only when the work already has a visible ticket; omit it to preserve an existing binding.",
-                "Use --clear-ticket to intentionally return the context to general ambient capture.",
-                "Use --topic/--intent/--phase for planning, discovery, and learning work that has no ticket yet.",
-                "Supported intents: implementation, bug_fix, root_cause_analysis, planning, discovery, review, testing, documentation, release, learning, coordination, maintenance, analysis, unknown, other.",
-                "Supported phases: planning, discovery, implementation, debugging, review, testing, documentation, release, handoff, analysis, unknown, other.",
-                "`--repo <path>` remains supported as a backward-compatible alias; use --workspace in agent guidance.",
-            ],
-        ],
-        [
-            "sync",
-            [
-                "Usage: cockpit sync [--workspace <path>] [--dashboard-url <url>] [--json]",
-                "",
-                "Uploads latest local ambient envelope(s), or spools safe retries if blocked.",
-                "Omit --dashboard-url for normal production sync; pass it only for staging/custom dashboards or forced re-pairing.",
-                "`--repo <path>` remains supported as a backward-compatible alias.",
-                "Parent folders sync each child git worktree; Codex AND Claude Code JSONL",
-                "transcripts (and Claude subagent sidecars) are attributed to repos",
-                "deterministically and ambiguous transcripts are retained as unattributed",
-                "instead of being duplicated across repos. Use `cockpit sessions` to see why",
-                "a session is or is not collected.",
-                "Newly discovered repos get a general ambient work context automatically.",
-                "Discovery scans 3 folder levels and up to 50 repos by default; tune with",
-                "--max-depth and --max-repos.",
-                "Also self-updates the CLI from npm latest once per day, strictly after",
-                "collection finishes; set COCKPIT_DISABLE_AUTO_UPDATE=1 to freeze the",
-                "installed version during incident triage.",
-            ],
-        ],
-        [
-            "analyze",
-            [
-                "Usage: cockpit analyze [--workspace <path>] [--dashboard-url <url>] [--json]",
-                "",
-                "Uploads the latest local ambient evidence, then queues one analysis job.",
-                "The command returns after the batch is queued; view status and results in My Work.",
-                "Omit --dashboard-url for production; pass it only for staging/custom dashboards.",
-                "`--repo <path>` remains supported as a backward-compatible alias.",
-            ],
-        ],
-        [
-            "backfill",
-            [
-                "Usage: cockpit backfill (--since-days <n>|--all) [--source codex|claude] [--dry-run] [--max-files <n>] [--max-depth <n>] [--max-repos <n>] [--yes] [--workspace <path>] [--json]",
-                "",
-                "Backfills historical Codex and Claude Code session evidence using the saved collection roots from local config when --workspace is omitted.",
-                "Omit --source to scan both sources; there is no --source all literal.",
-                "The non-all window is capped at the collector session paired_at timestamp.",
-                "--all requires a dry-run review and TTY confirmation; pass --yes for headless agent runs.",
-                "Repo discovery scans 3 folder levels and up to 50 repos by default.",
-                "Raise --max-depth or --max-repos when a partial result reports a discovery cap.",
-                "--dry-run validates the paired collector and dashboard reachability, prints the same summary tables, and writes nothing.",
-            ],
-        ],
-        [
-            "status",
-            [
-                "Usage: cockpit status [--workspace <path>] [--json]",
-                "",
-                "Prints install, pairing, active work, upload, and retry state.",
-                "`--repo <path>` remains supported as a backward-compatible alias.",
-            ],
-        ],
-        [
-            "sessions",
-            [
-                "Usage: cockpit sessions [--source codex|claude] [--since-days <n>|--all] [--workspace <path>] [--json]",
-                "",
-                "Read-only: re-runs Codex + Claude session attribution and prints each",
-                "session's id, source, state, reason, scores, signals, and per-sidecar",
-                "skip reasons. No upload, no cursor writes. Answers \"why is session X",
-                "missing?\" locally — counts and labels only, never paths or content.",
-                "--since-days uses the same paired_at cap as `cockpit backfill`; --all scans the full local history.",
-                "`--repo <path>` remains supported as a backward-compatible alias.",
-            ],
-        ],
-        [
-            "serve",
-            [
-                "Usage: cockpit serve [--port <port>] [--workspace <path>]",
-                "",
-                "Starts the local collector HTTP status server.",
-                "`--repo <path>` remains supported as a backward-compatible alias.",
-            ],
-        ],
-        [
-            "autostart",
-            [
-                "Usage: cockpit autostart [install|uninstall|status] [--workspace <path>] [--dashboard-url <url>] [--interval-seconds <n>] [--json]",
-                "",
-                "Installs background sync through launchd on Apple Silicon macOS or a",
-                "per-user Task Scheduler task on native Windows.",
-                "Runs `cockpit sync` every 15 min by default and survives reboots;",
-                "the Windows task runs while the user is signed in.",
-                "Action defaults to `install`. `--workspace` is the parent work folder to sync.",
-                "`--repo <path>` remains supported as a backward-compatible alias.",
-                "Omit --dashboard-url for production; pass it only for staging/custom dashboards.",
-                "See docs/runbooks/cockpit-launchd-sync.md and",
-                "docs/runbooks/cockpit-windows-task-scheduler-sync.md.",
-            ],
-        ],
-        [
-            "agent-rules",
-            [
-                "Usage: cockpit agent-rules [install|uninstall|status] [--host codex|claude|all] [--workspace <path>] [--json]",
-                "",
-                "Installs a managed Cockpit Ticket Binding block into ~/.codex/AGENTS.md",
-                "and ~/.claude/CLAUDE.md by default. Pass --host to manage only one.",
-                "The block is scoped to --workspace, or the current directory when omitted,",
-                "so Codex and Claude only run Cockpit ticket binding inside that onboarded folder.",
-                "Action defaults to `install`.",
-            ],
-        ],
-        [
-            "release",
-            [
-                "Usage: cockpit release [--dry-run] [--skip-checks] [--tag <tag>] [--access <public|restricted>] [--otp <code>]",
-                "",
-                "Maintainer-only helper. Run from inside the bli-cockpit repo checkout.",
-                "Requires a clean `main` branch and runs `git pull --ff-only` before publishing.",
-                "Delegates to `npm run publish:public -- ...` so public packages are",
-                "built, checked, and published in the safe telemetry-core then CLI order.",
-            ],
-        ],
-    ]);
-    return (helpByCommand.get(command) ?? [localCommandHelp()]).join("\n");
-}
-function isLocalHelpRequest(argv) {
-    const command = argv[0];
-    if (!command || !rootCommandNames.has(command))
-        return false;
-    return argv.length === 2 && (argv[1] === "--help" || argv[1] === "-h");
-}
-async function runInstall(command, io) {
-    const installEvents = [];
-    const finish = async (code) => {
-        await reportInstallEventsBestEffort({
-            homeDir: command.homeDir,
-            dashboardUrl: command.dashboardUrl,
-            command: "install",
-            events: installEvents,
-            json: command.json,
-            io,
-        });
-        return code;
-    };
-    const resolved = resolveInstallCommandRoots(command);
-    if (resolved.homeRootOptIn) {
-        addInstallEvent(installEvents, "home_root_optin", "ok");
-    }
-    const result = await installLocalCollector(resolved.command);
-    // Same invariant as the onboarding path: never report a successful install
-    // over a config that saved no usable collection root.
-    await assertCollectionRootPersisted(resolved.command.homeDir);
-    addInstallEvent(installEvents, "install", "ok");
-    if (command.json) {
-        writeLine(io.stdout, JSON.stringify(result, null, 2));
-        return finish(0);
-    }
-    writeLine(io.stdout, "Cockpit local collector installed.");
-    writeLine(io.stdout, `Config: ${result.paths.config_file}`);
-    writeLine(io.stdout, `Session: ${result.paths.session_file}`);
-    writeLine(io.stdout, "Auth: missing; upload stays local-only until pairing/login.");
-    writeLine(io.stdout, "Next: run `cockpit login`, then `cockpit start` inside the repo; add `--ticket <id>` only when ticket work begins.");
-    return finish(0);
-}
-function resolveInstallCommandRoots(command) {
-    const detailed = normalizeRootsDetailed([command.repoRoot ?? process.cwd()], {
-        homeDir: command.homeDir,
-        allowHomeRoot: command.allowHomeRoot,
-    });
-    if (detailed.roots.length > 0) {
-        const root = detailed.roots[0];
-        return {
-            command: {
-                ...command,
-                repoRoot: root,
-            },
-            homeRootOptIn: Boolean(command.allowHomeRoot) &&
-                path.resolve(root) === path.resolve(command.homeDir ?? os.homedir()),
-        };
-    }
-    if (detailed.rejected.length > 0) {
-        throw new Error(`${COLLECTION_ROOT_REQUIRED}: ${rootRejectionExplanation(detailed.rejected[0], command)}`);
-    }
-    throw new Error(`${COLLECTION_ROOT_REQUIRED}: ${missingCollectionRootMessage(command)}`);
-}
-async function runUpdate(command, io) {
-    const installEvents = [];
-    const finish = async (code) => {
-        await reportInstallEventsBestEffort({
-            homeDir: command.homeDir,
-            dashboardUrl: command.dashboardUrl,
-            command: "update",
-            events: installEvents,
-            json: command.json,
-            io,
-        });
-        return code;
-    };
-    const exec = io.exec ?? defaultExec();
-    try {
-        await runSelfUpdate(io, { json: command.json });
-    }
-    catch (error) {
-        if (!(error instanceof SelfUpdateError))
-            throw error;
-        addInstallEvent(installEvents, "npm_install", "fail", error.eacces
-            ? "npm_install_eacces"
-            : "npm_install_failed");
-        if (command.json) {
-            writeLine(io.stdout, JSON.stringify({
-                status: "blocked",
-                step: "npm_install",
-                command: `npm ${selfUpdateInstallArgs().join(" ")}`,
-                exit_code: error.result.code,
-            }, null, 2));
-        }
-        else {
-            writeLine(io.stderr, "BLOCKED: npm install failed; Cockpit CLI was not refreshed.");
-            if (error.eacces) {
-                writeLine(io.stderr, "Fix Homebrew npm ownership once: sudo chown -R $(whoami) /opt/homebrew/lib/node_modules/@bli-cockpit /opt/homebrew/bin/cockpit");
-                writeLine(io.stderr, "Do not use `sudo npm i -g`; it makes the ownership problem come back.");
-            }
-        }
-        return finish(error.result.code || 1);
-    }
-    addInstallEvent(installEvents, "npm_install", "ok");
-    if (!command.json) {
-        writeLine(io.stdout, "Cockpit CLI updated. Rechecking onboarding...");
-    }
-    const onboard = await exec("cockpit", [
-        "onboard",
-        ...updateOnboardArgs(command),
-    ]);
-    writeExecOutput(io, onboard, { stdout: true, stderr: true });
-    addInstallEvent(installEvents, "onboard_rerun", onboard.code === 0 ? "ok" : "fail", onboard.code === 0 ? undefined : updateOnboardFailureCode(onboard));
-    return finish(onboard.code);
-}
-export class SelfUpdateError extends Error {
-    result;
-    eacces;
-    constructor(result) {
-        super("npm install failed; Cockpit CLI was not refreshed.");
-        this.name = "SelfUpdateError";
-        this.result = result;
-        this.eacces = isNpmEaccesFailure(result.stderr);
-    }
-}
-export async function runSelfUpdate(io, options = {}) {
-    const exec = io.exec ?? defaultExec();
-    const tag = options.tag ?? "latest";
-    if (!options.json) {
-        writeLine(io.stdout, `Updating Cockpit CLI from npm (${tag})...`);
-    }
-    const install = await exec("npm", selfUpdateInstallArgs(tag));
-    writeExecOutput(io, install, { stdout: !options.json, stderr: true });
-    if (install.code !== 0) {
-        throw new SelfUpdateError(install);
-    }
-    return { updated: true, version: LOCAL_COLLECTOR_VERSION };
-}
-function selfUpdateInstallArgs(tag = "latest") {
-    return [
-        "install",
-        "-g",
-        `@bli-cockpit/cli@${tag}`,
-        "--prefer-online",
-    ];
-}
-async function runRelease(command, io) {
-    const releaseRoot = await findPublicReleaseRoot(process.cwd());
-    if (!releaseRoot) {
-        writeLine(io.stderr, "cockpit release must be run inside the bli-cockpit repo checkout (missing publish:public script).");
-        return 1;
-    }
-    const exec = io.exec ?? defaultExec();
-    const gitReady = await prepareReleaseMainBranch(releaseRoot, exec, io);
-    if (!gitReady)
-        return 1;
-    writeLine(io.stdout, "Running Cockpit public package release...");
-    const npmArgs = ["--prefix", releaseRoot, "run", "publish:public"];
-    if (command.args.length > 0)
-        npmArgs.push("--", ...command.args);
-    const releaseExec = io.interactiveExec ?? defaultInteractiveExec();
-    const result = await releaseExec("npm", npmArgs);
-    writeExecOutput(io, result, { stdout: true, stderr: true });
-    return result.code;
-}
-async function prepareReleaseMainBranch(releaseRoot, exec, io) {
-    const branch = await exec("git", [
-        "-C",
-        releaseRoot,
-        "rev-parse",
-        "--abbrev-ref",
-        "HEAD",
-    ]);
-    writeExecOutput(io, branch, { stdout: false, stderr: true });
-    if (branch.code !== 0) {
-        writeLine(io.stderr, "BLOCKED: cockpit release could not read the current git branch.");
-        return false;
-    }
-    const currentBranch = branch.stdout.trim();
-    if (currentBranch !== "main") {
-        writeLine(io.stderr, `BLOCKED: cockpit release only publishes from main. Current branch is ${currentBranch || "unknown"}.`);
-        writeLine(io.stderr, "Merge the release changes, switch to main, then rerun `cockpit release`.");
-        return false;
-    }
-    const status = await exec("git", [
-        "-C",
-        releaseRoot,
-        "status",
-        "--porcelain",
-    ]);
-    writeExecOutput(io, status, { stdout: false, stderr: true });
-    if (status.code !== 0) {
-        writeLine(io.stderr, "BLOCKED: cockpit release could not inspect git status.");
-        return false;
-    }
-    if (status.stdout.trim()) {
-        writeLine(io.stderr, "BLOCKED: cockpit release requires a clean main checkout.");
-        writeLine(io.stderr, "Commit or discard local changes, then rerun `cockpit release`.");
-        return false;
-    }
-    writeLine(io.stdout, "Syncing main with git pull --ff-only...");
-    const pull = await exec("git", ["-C", releaseRoot, "pull", "--ff-only"]);
-    writeExecOutput(io, pull, { stdout: true, stderr: true });
-    if (pull.code !== 0) {
-        writeLine(io.stderr, "BLOCKED: git pull --ff-only failed; main is not safely current.");
-        return false;
-    }
-    return true;
-}
-async function findPublicReleaseRoot(startDir) {
-    let current = path.resolve(startDir);
-    while (true) {
-        const packageJsonPath = path.join(current, "package.json");
-        try {
-            const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
-            if (packageJson.scripts?.["publish:public"] !== undefined)
-                return current;
-        }
-        catch {
-            // Keep walking: nested packages may be missing package.json or have one
-            // without the release script.
-        }
-        const parent = path.dirname(current);
-        if (parent === current)
-            return null;
-        current = parent;
-    }
-}
-function updateOnboardArgs(command) {
-    const args = [];
-    if (command.homeDir)
-        args.push("--home", command.homeDir);
-    for (const root of updateCollectionRoots(command)) {
-        args.push("--workspace", root);
-    }
-    if (command.dashboardUrlExplicit) {
-        args.push("--dashboard-url", command.dashboardUrl);
-    }
-    if (command.claimedOwnerEmail)
-        args.push("--email", command.claimedOwnerEmail);
-    if (command.noAuth)
-        args.push("--no-auth");
-    if (command.deviceName)
-        args.push("--device-name", command.deviceName);
-    if (command.activeTicketId)
-        args.push("--ticket", command.activeTicketId);
-    if (command.branch)
-        args.push("--branch", command.branch);
-    if (command.pollIntervalMs !== undefined) {
-        args.push("--poll-interval-ms", String(command.pollIntervalMs));
-    }
-    if (command.timeoutMs !== undefined) {
-        args.push("--timeout-ms", String(command.timeoutMs));
-    }
-    if (command.maxDepth !== undefined)
-        args.push("--max-depth", String(command.maxDepth));
-    if (command.maxRepos !== undefined)
-        args.push("--max-repos", String(command.maxRepos));
-    if (command.allowHomeRoot)
-        args.push("--allow-home-root");
-    if (command.json)
-        args.push("--json");
-    return args;
-}
-function isNpmEaccesFailure(stderr) {
-    return /EACCES|permission denied/i.test(stderr);
-}
-function updateOnboardFailureCode(result) {
-    const output = `${result.stdout}\n${result.stderr}`;
-    if (output.includes(COLLECTION_ROOT_REQUIRED))
-        return COLLECTION_ROOT_REQUIRED;
-    if (/pairing|approval|device_pairing/i.test(output))
-        return "pairing_timeout";
-    if (/sync_blocked|spooled|upload failed|network_or_ingest/i.test(output)) {
-        return "sync_blocked";
-    }
-    return "onboard_rerun_failed";
-}
-function updateCollectionRoots(command) {
-    const roots = command.collectionRoots?.length
-        ? command.collectionRoots
-        : command.repoRoot
-            ? [command.repoRoot]
-            : [];
-    const seen = new Set();
-    const deduped = [];
-    for (const root of roots) {
-        if (seen.has(root))
-            continue;
-        seen.add(root);
-        deduped.push(root);
-    }
-    return deduped;
-}
-function addInstallEvent(events, step, status, errorCode, 
-// BLI-2542: the bucket alone cannot be acted on. Callers that hold the reason
-// pass it; it is redacted at this boundary, not at the call site.
-errorMessage) {
-    const detail = errorMessage ? redactedHealthDetail(errorMessage) : "";
-    const code = errorCode ? sanitizeInstallErrorCode(errorCode) : undefined;
-    events.push({
-        step,
-        status,
-        ...(code ? { error_code: code } : {}),
-        ...(detail && detail !== code ? { error_detail: detail } : {}),
-    });
-}
 function addOnboardFailureEvent(events, blocker) {
     const step = onboardFailureStep(blocker, events);
     const existing = events.find((event) => event.step === step && event.status === "fail");
@@ -703,395 +162,6 @@ function onboardFailureStep(blocker, events) {
     const lastIncomplete = ["install", "auth", "pair", "work_context", "sync"].find((step) => !events.some((event) => event.step === step));
     return lastIncomplete ?? "sync";
 }
-function sanitizeInstallErrorCode(value) {
-    const normalized = value
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9_]+/gu, "_")
-        .replace(/^_+|_+$/gu, "")
-        .slice(0, 120);
-    return normalized || "unknown";
-}
-/**
- * Posts pending install events. Also the collector's only per-tick listening
- * post: the response carries the server-published `min_cli_version` floor
- * (BLI-2678), so the last one observed is returned for the scheduled
- * self-update step to act on. Every early-out returns null — no receipt, no
- * floor.
- */
-export async function reportInstallEventsBestEffort(options) {
-    if (options.events.length === 0)
-        return null;
-    const paths = getCollectorRuntimePaths(options.homeDir);
-    try {
-        await enqueueInstallEventEntry(paths, {
-            dashboardUrl: options.dashboardUrl,
-            cliVersion: LOCAL_COLLECTOR_VERSION,
-            command: options.command,
-            osPlatform: os.platform(),
-            events: options.events.map((event) => ({
-                step: event.step.trim().slice(0, 120),
-                status: event.status,
-                ...(event.error_code
-                    ? { error_code: sanitizeInstallErrorCode(event.error_code) }
-                    : {}),
-                // Already redacted and capped at the point it was produced; bounded
-                // again here because this mapping is what the server contract sees.
-                ...(event.error_detail
-                    ? {
-                        error_detail: event.error_detail
-                            .trim()
-                            .slice(0, SYNC_ERROR_DETAIL_MAX_CHARS),
-                    }
-                    : {}),
-                ...(event.at ? { at: event.at } : {}),
-            })),
-        });
-    }
-    catch {
-        if (options.json) {
-            writeLine(options.io.stderr, "Install event outbox unavailable: local_write_failed");
-        }
-        return null;
-    }
-    const session = await readLocalCollectorSessionFile(paths).catch(() => null);
-    if (!session ||
-        session.session_state !== "valid" ||
-        typeof session.device_token !== "string" ||
-        !session.device_token) {
-        return null;
-    }
-    const pending = (await readPendingInstallEventEntries(paths)).slice(0, 20);
-    const failures = [];
-    let observedMinCliVersion = null;
-    for (let offset = 0; offset < pending.length; offset += 5) {
-        await Promise.all(pending.slice(offset, offset + 5).map(async (entry) => {
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), 5_000);
-            try {
-                const response = await options.io.fetch(`${entry.dashboard_url}/api/ambient/install-events`, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        Authorization: `Bearer ${session.device_token}`,
-                    },
-                    body: JSON.stringify({
-                        cli_version: entry.cli_version,
-                        command: entry.command,
-                        os_platform: entry.os_platform,
-                        events: entry.events,
-                    }),
-                    signal: controller.signal,
-                });
-                if (!response.ok) {
-                    throw new Error(`http_${response.status}`);
-                }
-                const receipt = (await response
-                    .json()
-                    .catch(() => null));
-                if (typeof receipt?.min_cli_version === "string" &&
-                    receipt.min_cli_version.trim()) {
-                    observedMinCliVersion = receipt.min_cli_version.trim();
-                }
-                await removeInstallEventEntry(paths, entry.outbox_id);
-            }
-            catch (error) {
-                const failureReason = classifyInstallTelemetryError(error);
-                failures.push(failureReason);
-                await recordInstallEventAttemptFailure(paths, entry, {
-                    attemptedAt: new Date().toISOString(),
-                    failureReason,
-                }).catch(() => undefined);
-            }
-            finally {
-                clearTimeout(timeout);
-            }
-        }));
-    }
-    if (options.json && failures.length > 0) {
-        writeLine(options.io.stderr, `Install event telemetry queued for retry: ${[...new Set(failures)].join(",")}`);
-    }
-    return observedMinCliVersion;
-}
-function classifyInstallTelemetryError(error) {
-    if (error instanceof Error && error.name === "AbortError") {
-        return "timeout";
-    }
-    const message = errorMessage(error);
-    const status = message.match(/http_(\d{3})/i)?.[1];
-    if (status)
-        return `http_${status}`;
-    if (/fetch|network|ENOTFOUND|ECONNREFUSED/i.test(message))
-        return "network";
-    return "failed";
-}
-function writeExecOutput(io, result, options) {
-    if (options.stdout)
-        writeRaw(io.stdout, result.stdout);
-    if (options.stderr)
-        writeRaw(io.stderr, result.stderr);
-}
-function writeRaw(stream, text) {
-    if (!text)
-        return;
-    stream.write(text);
-    if (!text.endsWith("\n"))
-        stream.write("\n");
-}
-function isInteractiveStdin(io) {
-    return Boolean(io.stdin.isTTY);
-}
-/**
- * Reads one line from stdin after writing a prompt. Shared by the onboard email
- * prompt and the autostart prompt; callers gate on `isInteractiveStdin` first so
- * headless / piped / spawned runs never block on input.
- */
-async function readLine(io, prompt) {
-    io.stdout.write(prompt);
-    io.stdin.setEncoding("utf8");
-    return new Promise((resolve) => {
-        const onData = (chunk) => {
-            io.stdin.removeListener("data", onData);
-            io.stdin.pause();
-            resolve(chunk);
-        };
-        io.stdin.resume();
-        io.stdin.on("data", onData);
-    });
-}
-/**
- * Asks for the dashboard email so `cockpit onboard` (no flags) need not force a
- * `--email`. Only called when stdin is a TTY and not in --json mode. An empty
- * answer or a non-email skips rather than failing, matching `optionalEmail`'s
- * leniency (the approving admin's account then owns the device).
- */
-async function promptOnboardEmail(io) {
-    const raw = await readLine(io, "What's your @buildlaunchiterate.ca email? (press enter to skip): ");
-    const answer = raw.trim().toLowerCase();
-    if (!answer)
-        return undefined;
-    if (!answer.includes("@")) {
-        writeLine(io.stderr, `"${answer}" is not an email; continuing without one — the approving admin's account will own this device.`);
-        return undefined;
-    }
-    return answer;
-}
-function onboardingRootPrompt(io) {
-    return {
-        confirm: async (message) => yesByDefault(await readLine(io, message)),
-        input: (message) => readLine(io, message),
-        message: (message) => writeLine(io.stdout, message),
-    };
-}
-function yesByDefault(raw) {
-    const answer = raw.trim().split(/\s+/u)[0]?.toLowerCase() ?? "";
-    return answer !== "n" && answer !== "no";
-}
-const OTP_CODE_PROMPT = [
-    "Email code needed:",
-    "  Check your latest Cockpit email for a 6- to 10-digit code.",
-    "What you can do:",
-    "  1) Paste the code here.",
-    "  2) No code yet: wait for the resend window, then rerun this command.",
-    "  3) Can't use email: rerun with --no-auth for manual approval.",
-    "Code: ",
-].join("\n");
-const OTP_INVALID_MESSAGE = [
-    "Email code was not accepted:",
-    "  Cockpit expects digits only, length 6 to 10.",
-    "What you can do:",
-    "  1) Rerun and paste the latest email code.",
-    "  2) Use manual approval: rerun this command with --no-auth --email <you@buildlaunchiterate.ca>",
-].join("\n");
-async function resolveOnboardEmail(command, roots, config, io) {
-    if (command.claimedOwnerEmail)
-        return command.claimedOwnerEmail;
-    const inferred = await inferOnboardEmail(command.homeDir, roots, config);
-    const interactive = !command.json && isInteractiveStdin(io);
-    if (!inferred) {
-        return interactive ? promptOnboardEmail(io) : undefined;
-    }
-    if (inferred.source === "session") {
-        if (!command.json)
-            writeLine(io.stdout, `Dashboard email: ${inferred.email}`);
-        return inferred.email;
-    }
-    if (!interactive)
-        return inferred.email;
-    const answer = (await readLine(io, `Use ${inferred.email} for Cockpit pairing? [Y/n] `)).trim().toLowerCase();
-    const typedEmail = answer.split(/\s+/u).find((part) => part.includes("@"));
-    if (typedEmail)
-        return typedEmail;
-    if (yesByDefault(answer)) {
-        return inferred.email;
-    }
-    return promptOnboardEmail(io);
-}
-async function resolveInteractiveLoginEmail(command, io) {
-    if (command.claimedOwnerEmail)
-        return command.claimedOwnerEmail;
-    if (command.noAuth || command.json || !isInteractiveStdin(io)) {
-        return undefined;
-    }
-    return promptOnboardEmail(io);
-}
-async function requestPairingAccessToken(input, io) {
-    return (await requestPairingAccessTokenDetailed(input, io)).accessToken;
-}
-async function requestPairingAccessTokenDetailed(input, io) {
-    if (!input.email ||
-        input.noAuth ||
-        input.json ||
-        !isInteractiveStdin(io)) {
-        return {
-            status: "skipped",
-            errorCode: authSkippedReason(input, io),
-        };
-    }
-    try {
-        const fetchImpl = io.fetch;
-        writeLine(io.stdout, `Signing in as ${input.email}.`);
-        const start = await postOtpStart(fetchImpl, input.dashboardUrl, input.email);
-        const resendAfter = typeof start.resend_after_seconds === "number"
-            ? start.resend_after_seconds
-            : 60;
-        writeLine(io.stdout, `Code sent; valid 1h, resend in ${resendAfter}s by rerunning this command.`);
-        const code = (await readLine(io, OTP_CODE_PROMPT)).trim();
-        if (!/^\d{6,10}$/.test(code)) {
-            throw new Error(OTP_INVALID_MESSAGE);
-        }
-        const verified = await postOtpVerify(fetchImpl, input.dashboardUrl, input.email, code);
-        if (typeof verified.access_token !== "string" || !verified.access_token) {
-            throw new Error("OTP verified but dashboard returned no access token.");
-        }
-        writeLine(io.stdout, `Signed in as ${input.email}.`);
-        return { status: "ok", accessToken: verified.access_token };
-    }
-    catch (error) {
-        writeLine(io.stderr, `Auth step skipped: ${errorMessage(error)}`);
-        writeLine(io.stderr, "Continuing with manual dashboard approval.");
-        return { status: "fail", errorCode: classifyAuthError(error) };
-    }
-}
-function authSkippedReason(input, io) {
-    if (!input.email)
-        return "email_missing";
-    if (input.noAuth)
-        return "no_auth";
-    if (input.json)
-        return "json_mode";
-    if (!isInteractiveStdin(io))
-        return "non_interactive";
-    return "auth_skipped";
-}
-function classifyAuthError(error) {
-    const message = errorMessage(error);
-    if (/\b(otp|code|digit|invalid)\b/i.test(message))
-        return "otp_invalid";
-    if (/fetch|network|ENOTFOUND|ECONNREFUSED|HTTP/i.test(message)) {
-        return "network_or_auth";
-    }
-    return "auth_failed";
-}
-async function pairLocalCollectorWithAuthFallback(options, io) {
-    try {
-        return await pairLocalCollector(options);
-    }
-    catch (error) {
-        if (!options.pairingAccessToken || !isPairingAuthFailure(error)) {
-            throw error;
-        }
-        writeLine(io.stderr, `Authenticated pairing failed: ${errorMessage(error)}`);
-        writeLine(io.stderr, "Continuing with manual dashboard approval.");
-        return pairLocalCollector({
-            ...options,
-            pairingAccessToken: undefined,
-        });
-    }
-}
-function isPairingAuthFailure(error) {
-    return /\b(auth|authorization|bearer|token|jwt|otp)\b/i.test(errorMessage(error));
-}
-async function postOtpStart(fetchImpl, dashboardUrl, email) {
-    const response = await fetchImpl(`${dashboardUrl}/api/auth/otp/start`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ email }),
-    });
-    const parsed = await readJsonResponse(response);
-    if (!response.ok) {
-        throw new Error(responseErrorMessage(parsed, "OTP start failed"));
-    }
-    return parsed;
-}
-async function postOtpVerify(fetchImpl, dashboardUrl, email, code) {
-    const response = await fetchImpl(`${dashboardUrl}/api/auth/otp/verify`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ email, code }),
-    });
-    const parsed = await readJsonResponse(response);
-    if (!response.ok) {
-        throw new Error(responseErrorMessage(parsed, "OTP verify failed"));
-    }
-    return parsed;
-}
-async function readJsonResponse(response) {
-    const text = await response.text();
-    if (!text)
-        return null;
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return text;
-    }
-}
-function responseErrorMessage(parsed, fallback) {
-    if (parsed && typeof parsed === "object") {
-        const record = parsed;
-        if (typeof record["message"] === "string" && record["message"].trim()) {
-            return record["message"];
-        }
-        if (typeof record["error"] === "string" && record["error"].trim()) {
-            return record["error"];
-        }
-    }
-    return fallback;
-}
-async function inferOnboardEmail(homeDir, roots, config) {
-    const session = await readOnboardSessionReuseCandidate(homeDir).catch(() => null);
-    const sessionEmail = normalizeEmailForComparison(session?.email);
-    if (session?.session_state === "valid" && sessionEmail) {
-        return { email: sessionEmail, source: "session" };
-    }
-    const configEmail = normalizeEmailForComparison(config?.claimed_owner_email);
-    if (configEmail)
-        return { email: configEmail, source: "config" };
-    const gitEmail = await inferUniqueGitEmail(roots);
-    return gitEmail ? { email: gitEmail, source: "git" } : null;
-}
-async function inferUniqueGitEmail(roots) {
-    const emails = new Set();
-    for (const root of roots) {
-        const email = await readGitConfigEmail(root);
-        if (email)
-            emails.add(email);
-    }
-    return emails.size === 1 ? [...emails][0] ?? null : null;
-}
-async function readGitConfigEmail(root) {
-    return new Promise((resolve) => {
-        execFile("git", ["config", "user.email"], { cwd: root, encoding: "utf8" }, (error, stdout) => {
-            if (error) {
-                resolve(null);
-                return;
-            }
-            const email = normalizeEmailForComparison(stdout);
-            resolve(email?.includes("@") ? email : null);
-        });
-    });
-}
 /** Refreshes the host autostart backend after successful onboarding. */
 async function refreshOnboardAutostart(command, roots, io) {
     if (!io.exec)
@@ -1199,6 +269,25 @@ function onboardBackfillPayload(outcome) {
         retry_command: outcome.retryCommand,
     });
 }
+/**
+ * The blocked-backfill result, identical in both onboarding arms. `extra`
+ * carries the arm-specific keys and is spread where those keys appeared before,
+ * so the `--json` key order is unchanged.
+ */
+function writeOnboardBackfillBlockedResult(io, options) {
+    if (!options.json) {
+        writeOnboardBackfillBlocker(io, options.backfill);
+        return;
+    }
+    writeLine(io.stdout, JSON.stringify({
+        ...options.base,
+        ...options.extra,
+        backfill: onboardBackfillPayload(options.backfill),
+        blocker: "backfill_incomplete",
+        backfill_failure_reason: options.backfill.failureReason,
+        next_step: options.backfill.retryCommand,
+    }, null, 2));
+}
 function writeOnboardBackfillBlocker(io, outcome) {
     writeLine(io.stderr, "BLOCKED: all-history Codex and Claude backfill is incomplete for the approved collection roots.");
     writeLine(io.stderr, `Failure: ${outcome.failureReason ?? `backfill_${outcome.status}`}`);
@@ -1216,125 +305,80 @@ function backgroundSyncLine(result) {
     }
     return result.status;
 }
-async function resolveOnboardingRootsForCommand(command, io) {
-    const paths = getCollectorRuntimePaths(command.homeDir);
-    const existingConfig = await readLocalCollectorConfig(paths).catch(() => null);
-    const interactive = !command.json && isInteractiveStdin(io);
-    const rootsResult = await resolveOnboardingRoots({
+function writeOnboardBanner(command, io) {
+    writeLine(io.stdout, "Cockpit harvest onboarding");
+    writeLine(io.stdout, `Dashboard: ${command.dashboardUrl}`);
+    writeLine(io.stdout, `Ticket: ${command.activeTicketId ?? "general ambient"}`);
+}
+/**
+ * Step 2 of onboarding: reuse the device session when it already belongs to
+ * this owner on this dashboard, otherwise sign in and pair — logging the old
+ * session out first when it belongs to someone else.
+ *
+ * Returns null when an existing session was reused, which is why the caller's
+ * `pair` stays null and the readiness proof falls back to the status file.
+ */
+async function pairForOnboarding(command, input, installEvents, io) {
+    const installedStatus = await inspectLocalCollectorStatus({
         homeDir: command.homeDir,
-        explicitRoots: command.collectionRoots ?? (command.repoRoot ? [command.repoRoot] : []),
-        config: existingConfig,
-        interactive,
-        allowHomeRoot: command.allowHomeRoot,
-        prompt: interactive ? onboardingRootPrompt(io) : undefined,
+        repoRoot: input.primaryRoot,
+        branch: command.branch,
     });
-    const collectionRoots = rootsResult.roots;
-    const primaryRoot = collectionRoots[0];
-    if (!primaryRoot) {
-        throw new Error(`${COLLECTION_ROOT_REQUIRED}: no collection root confirmed.`);
-    }
-    const replaceRepoRoots = rootsResult.source === "prompt" &&
-        !command.collectionRoots?.length &&
-        (existingConfig?.default_repo_paths.length ?? 0) > 0;
-    return {
-        existingConfig,
-        rootsResult,
-        collectionRoots,
-        primaryRoot,
-        replaceRepoRoots,
-    };
-}
-async function persistOnboardingRootConfig(command, resolution) {
-    const result = await installLocalCollector({
+    const installedSession = await readOnboardSessionReuseCandidate(command.homeDir);
+    const canReuseInstalledSession = canReuseOnboardSession(installedSession, input.claimedOwnerEmail, command.dashboardUrl);
+    if (installedStatus.session_state === "valid" && canReuseInstalledSession) {
+        addInstallEvent(installEvents, "auth", "skipped", "existing_session");
+        addInstallEvent(installEvents, "pair", "skipped", "existing_session");
+        if (!command.json) {
+            writeLine(io.stdout, "2/5 Existing valid device session found; pairing skipped.");
+        }
+        return null;
+    }
+    if (installedStatus.session_state === "valid") {
+        await logoutLocalCollector({ homeDir: command.homeDir });
+        if (!command.json) {
+            writeLine(io.stdout, "2/5 Existing valid device session does not match requested owner or dashboard; pairing again.");
+        }
+    }
+    const authResult = await requestPairingAccessTokenDetailed({
+        dashboardUrl: command.dashboardUrl,
+        email: input.claimedOwnerEmail,
+        noAuth: command.noAuth,
+        json: command.json,
+    }, io);
+    addInstallEvent(installEvents, "auth", authResult.status, authResult.errorCode);
+    const pair = await pairLocalCollectorWithAuthFallback({
         homeDir: command.homeDir,
-        repoRoot: resolution.primaryRoot,
-        repoRoots: resolution.collectionRoots,
-        replaceRepoRoots: resolution.replaceRepoRoots,
         dashboardUrl: command.dashboardUrl,
+        claimedOwnerEmail: input.claimedOwnerEmail,
         deviceName: command.deviceName,
-    });
-    await assertCollectionRootPersisted(command.homeDir);
-    return result;
+        pollIntervalMs: command.pollIntervalMs,
+        timeoutMs: command.timeoutMs,
+        pairingAccessToken: authResult.accessToken,
+        fetch: io.fetch,
+        onPairStarted: command.json
+            ? undefined
+            : (request) => writePairingInstructions(io, request),
+    }, io);
+    addInstallEvent(installEvents, "pair", "ok");
+    if (!command.json) {
+        writeLine(io.stdout, "2/5 Device paired.");
+        writeLine(io.stdout, `User: ${pair.session.email ?? pair.session.auth_subject_id}`);
+        writeLine(io.stdout, `Device: ${pair.session.device_name ?? pair.session.device_id ?? "unknown"}`);
+    }
+    return pair;
 }
 /**
- * Setup does not get to claim success on its own say-so.
- *
- * Onboarding used to write the config and report success without ever reading
- * it back. Savina's onboard did exactly that, persisted nothing, and every
- * scheduled sync afterwards threw `collection_root_required` into a log nobody
- * reads — twelve consecutive failures, six days at 3 uploaded of 195, found
- * only by hand-querying the database. BLI-1986 fixed one path into that state;
- * this closes the state itself.
- *
- * So we read the config back through the SAME resolution the scheduled sync
- * will use, and fail here — in front of a human who can still fix it — rather
- * than silently handing back a machine that will never collect.
+ * The last two setup steps of a successful onboard, in the order both arms run
+ * them. `ok` is false only when a supported scheduler was asked to load
+ * recurring collection and refused — an unsupported host is not a failure.
  */
-export async function assertCollectionRootPersisted(homeDir) {
-    const config = await readLocalCollectorConfig(getCollectorRuntimePaths(homeDir)).catch(() => null);
-    const saved = normalizeCollectionRoots(config?.default_repo_paths ?? []);
-    if (saved.length === 0) {
-        throw new Error(`${COLLECTION_ROOT_REQUIRED}: ${collectionRootNotPersistedMessage(homeDir)}`);
-    }
-    // Present in the file is not the same as usable. A root that no longer
-    // exists on disk resolves to nothing at sync time, which is the same silent
-    // dead end arriving one step later.
-    const usable = [];
-    for (const root of saved) {
-        if (await directoryExists(root))
-            usable.push(root);
-    }
-    if (usable.length === 0) {
-        throw new Error(`${COLLECTION_ROOT_REQUIRED}: ${collectionRootMissingOnDiskMessage(saved, homeDir)}`);
-    }
-    return usable;
-}
-// Placeholders like <path-to-your-work-folder> make a person stop and think.
-// These print real, paste-able commands with this machine's actual paths in
-// them, so the fix is a copy away rather than a puzzle.
-function collectionRootNotPersistedMessage(homeDir) {
-    const home = path.resolve(homeDir ?? os.homedir());
-    return [
-        "Setup finished without saving a collection root, so this machine would never collect anything.",
-        "Nothing was saved, so nothing is broken — setup just did not finish.",
-        "",
-        "Fix it by running ONE of these:",
-        "",
-        "  # Sync everything on this machine (what most people want on a work laptop)",
-        "  cockpit do-everything --allow-home-root",
-        "",
-        "  # Or sync one folder — replace the path with where your projects live",
-        `  cockpit do-everything --workspace ${path.join(home, "BLI")}`,
-        "",
-        "  # Or answer the folder question interactively",
-        "  cockpit do-everything",
-        "",
-        "Then check it worked:",
-        "  cockpit status",
-    ].join("\n");
-}
-function collectionRootMissingOnDiskMessage(saved, homeDir) {
-    const home = path.resolve(homeDir ?? os.homedir());
-    return [
-        "Cockpit is set up to collect from a folder that is not on this machine:",
-        ...saved.map((root) => `  ${root}`),
-        "",
-        "That usually means the folder was renamed, moved, or deleted since setup.",
-        "",
-        "Fix it by running ONE of these:",
-        "",
-        "  # Point Cockpit at where your projects actually live now",
-        `  cockpit do-everything --workspace ${path.join(home, "BLI")}`,
-        "",
-        "  # Or sync everything on this machine and stop worrying about the path",
-        "  cockpit do-everything --allow-home-root",
-        "",
-        "Not sure where your projects are? This lists the folders Cockpit can see:",
-        "  cockpit status",
-    ].join("\n");
-}
-async function directoryExists(dir) {
-    return stat(dir).then((stats) => stats.isDirectory(), () => false);
+async function completeOnboardingSetup(resolvedCommand, collectionRoots, installEvents, io) {
+    const agentRules = await refreshOnboardAgentRules(resolvedCommand, collectionRoots, io);
+    addInstallEvent(installEvents, "agent_rules", "ok");
+    const autostart = await refreshOnboardAutostart(resolvedCommand, collectionRoots, io);
+    addAutostartInstallEvent(installEvents, autostart);
+    return { agentRules, autostart, ok: !onboardAutostartFailed(autostart) };
 }
 async function runDoctorLogin(command, io) {
     return runLogin({
@@ -1383,11 +427,8 @@ async function runOnboard(command, io) {
     let agentRules = null;
     let autostart = null;
     try {
-        if (!command.json) {
-            writeLine(io.stdout, "Cockpit harvest onboarding");
-            writeLine(io.stdout, `Dashboard: ${command.dashboardUrl}`);
-            writeLine(io.stdout, `Ticket: ${command.activeTicketId ?? "general ambient"}`);
-        }
+        if (!command.json)
+            writeOnboardBanner(command, io);
         const resolvedRoots = await resolveOnboardingRootsForCommand(command, io);
         const existingConfig = resolvedRoots.existingConfig;
         rootsResult = resolvedRoots.rootsResult;
@@ -1412,54 +453,7 @@ async function runOnboard(command, io) {
             writeLine(io.stdout, "1/5 Installed local collector.");
             writeLine(io.stdout, `Config: ${install.paths.config_file}`);
         }
-        const installedStatus = await inspectLocalCollectorStatus({
-            homeDir: command.homeDir,
-            repoRoot: primaryRoot,
-            branch: command.branch,
-        });
-        const installedSession = await readOnboardSessionReuseCandidate(command.homeDir);
-        const canReuseInstalledSession = canReuseOnboardSession(installedSession, claimedOwnerEmail, command.dashboardUrl);
-        if (installedStatus.session_state === "valid" && canReuseInstalledSession) {
-            addInstallEvent(installEvents, "auth", "skipped", "existing_session");
-            addInstallEvent(installEvents, "pair", "skipped", "existing_session");
-            if (!command.json) {
-                writeLine(io.stdout, "2/5 Existing valid device session found; pairing skipped.");
-            }
-        }
-        else {
-            if (installedStatus.session_state === "valid" && !canReuseInstalledSession) {
-                await logoutLocalCollector({ homeDir: command.homeDir });
-                if (!command.json) {
-                    writeLine(io.stdout, "2/5 Existing valid device session does not match requested owner or dashboard; pairing again.");
-                }
-            }
-            const authResult = await requestPairingAccessTokenDetailed({
-                dashboardUrl: command.dashboardUrl,
-                email: claimedOwnerEmail,
-                noAuth: command.noAuth,
-                json: command.json,
-            }, io);
-            addInstallEvent(installEvents, "auth", authResult.status, authResult.errorCode);
-            pair = await pairLocalCollectorWithAuthFallback({
-                homeDir: command.homeDir,
-                dashboardUrl: command.dashboardUrl,
-                claimedOwnerEmail,
-                deviceName: command.deviceName,
-                pollIntervalMs: command.pollIntervalMs,
-                timeoutMs: command.timeoutMs,
-                pairingAccessToken: authResult.accessToken,
-                fetch: io.fetch,
-                onPairStarted: command.json
-                    ? undefined
-                    : (request) => writePairingInstructions(io, request),
-            }, io);
-            addInstallEvent(installEvents, "pair", "ok");
-            if (!command.json) {
-                writeLine(io.stdout, "2/5 Device paired.");
-                writeLine(io.stdout, `User: ${pair.session.email ?? pair.session.auth_subject_id}`);
-                writeLine(io.stdout, `Device: ${pair.session.device_name ?? pair.session.device_id ?? "unknown"}`);
-            }
-        }
+        pair = await pairForOnboarding(command, { primaryRoot, claimedOwnerEmail }, installEvents, io);
         const worktrees = await discoverCommandWorktrees(collectionRoots, {
             maxDepth: command.maxDepth,
             maxRepos: command.maxRepos,
@@ -1491,30 +485,26 @@ async function runOnboard(command, io) {
                 ? undefined
                 : backfill.failureReason ?? "backfill_incomplete");
             if (!completedBackfill) {
-                if (command.json) {
-                    writeLine(io.stdout, JSON.stringify({
+                writeOnboardBackfillBlockedResult(io, {
+                    json: command.json,
+                    base: {
                         ...onboardResult("blocked", resolvedCommand, install, pair, null, null),
                         collection_roots: collectionRoots,
                         root_resolution: rootsResult,
+                    },
+                    extra: {
                         mode: "multi_repo",
                         repos: multi.results,
                         codex_sessions: multi.codex_sessions,
-                        backfill: onboardBackfillPayload(backfill),
-                        blocker: "backfill_incomplete",
-                        backfill_failure_reason: backfill.failureReason,
-                        next_step: backfill.retryCommand,
-                    }, null, 2));
-                }
-                else {
-                    writeOnboardBackfillBlocker(io, backfill);
-                }
+                    },
+                    backfill,
+                });
                 return finish(1);
             }
-            agentRules = await refreshOnboardAgentRules(resolvedCommand, collectionRoots, io);
-            addInstallEvent(installEvents, "agent_rules", "ok");
-            autostart = await refreshOnboardAutostart(resolvedCommand, collectionRoots, io);
-            addAutostartInstallEvent(installEvents, autostart);
-            const onboardOk = !onboardAutostartFailed(autostart);
+            const multiSetup = await completeOnboardingSetup(resolvedCommand, collectionRoots, installEvents, io);
+            agentRules = multiSetup.agentRules;
+            autostart = multiSetup.autostart;
+            const onboardOk = multiSetup.ok;
             if (command.json) {
                 writeLine(io.stdout, JSON.stringify({
                     ...onboardResult(onboardOk ? "pass" : "blocked", resolvedCommand, install, pair, null, null),
@@ -1585,14 +575,14 @@ async function runOnboard(command, io) {
         });
         if (!run.ok || sync.status !== "uploaded") {
             addInstallEvent(installEvents, "sync", "fail", "sync_blocked");
-            const runStatus = attributedSyncRunStatus(run);
+            const collectionRunStatus = attributedSyncRunStatus(run);
             if (command.json) {
                 writeLine(io.stdout, JSON.stringify({
                     ...onboardResult("blocked", resolvedCommand, install, pair, sync, status),
                     collection_roots: collectionRoots,
                     root_resolution: rootsResult,
                     codex_sessions: run.summary,
-                    collection_status: runStatus,
+                    collection_status: collectionRunStatus,
                 }, null, 2));
             }
             else {
@@ -1601,7 +591,7 @@ async function runOnboard(command, io) {
                     ? sync.retry_command
                     : `cockpit sync --workspace ${JSON.stringify(worktreeRoot)}`;
                 writeLine(io.stderr, "BLOCKED: initial collection is incomplete; retry until every eligible session has a durable receipt or explicit terminal reason.");
-                writeLine(io.stderr, `Failure: ${syncFailureReason ?? (run.summary.report_posted ? runStatus : run.summary.report_reason)}`);
+                writeLine(io.stderr, `Failure: ${syncFailureReason ?? (run.summary.report_posted ? collectionRunStatus : run.summary.report_reason)}`);
                 writeAgentSessionSummary(io, run.summary);
                 writeLine(io.stderr, `Retry: ${retryCommand}`);
             }
@@ -1614,29 +604,23 @@ async function runOnboard(command, io) {
             ? undefined
             : backfill.failureReason ?? "backfill_incomplete");
         if (!completedBackfill) {
-            if (command.json) {
-                writeLine(io.stdout, JSON.stringify({
+            writeOnboardBackfillBlockedResult(io, {
+                json: command.json,
+                base: {
                     ...onboardResult("blocked", resolvedCommand, install, pair, sync, status),
                     collection_roots: collectionRoots,
                     root_resolution: rootsResult,
-                    codex_sessions: run.summary,
-                    backfill: onboardBackfillPayload(backfill),
-                    blocker: "backfill_incomplete",
-                    backfill_failure_reason: backfill.failureReason,
-                    next_step: backfill.retryCommand,
-                }, null, 2));
-            }
-            else {
-                writeOnboardBackfillBlocker(io, backfill);
-            }
+                },
+                extra: { codex_sessions: run.summary },
+                backfill,
+            });
             return finish(1);
         }
         if (command.json) {
-            agentRules = await refreshOnboardAgentRules(resolvedCommand, collectionRoots, io);
-            addInstallEvent(installEvents, "agent_rules", "ok");
-            autostart = await refreshOnboardAutostart(resolvedCommand, collectionRoots, io);
-            addAutostartInstallEvent(installEvents, autostart);
-            const onboardOk = !onboardAutostartFailed(autostart);
+            const jsonSetup = await completeOnboardingSetup(resolvedCommand, collectionRoots, installEvents, io);
+            agentRules = jsonSetup.agentRules;
+            autostart = jsonSetup.autostart;
+            const onboardOk = jsonSetup.ok;
             writeLine(io.stdout, JSON.stringify({
                 ...onboardResult(onboardOk ? "pass" : "blocked", resolvedCommand, install, pair, sync, status),
                 collection_roots: collectionRoots,
@@ -1665,11 +649,10 @@ async function runOnboard(command, io) {
         writeLine(io.stdout, "5/5 Status ready.");
         writeLine(io.stdout, `Upload state: ${status.upload_state}`);
         writeLine(io.stdout, `Open: ${command.dashboardUrl}/my-work`);
-        agentRules = await refreshOnboardAgentRules(resolvedCommand, collectionRoots, io);
-        addInstallEvent(installEvents, "agent_rules", "ok");
-        autostart = await refreshOnboardAutostart(resolvedCommand, collectionRoots, io);
-        addAutostartInstallEvent(installEvents, autostart);
-        if (onboardAutostartFailed(autostart)) {
+        const setup = await completeOnboardingSetup(resolvedCommand, collectionRoots, installEvents, io);
+        agentRules = setup.agentRules;
+        autostart = setup.autostart;
+        if (!setup.ok) {
             writeOnboardAutostartBlocker(io, autostart);
             return finish(1);
         }
@@ -1715,212 +698,6 @@ async function runOnboard(command, io) {
         return finish(1);
     }
 }
-function canReuseOnboardSession(session, claimedOwnerEmail, dashboardUrl) {
-    if (session.session_state !== "valid")
-        return false;
-    const expectedEmail = normalizeEmailForComparison(claimedOwnerEmail);
-    if (expectedEmail && normalizeEmailForComparison(session.email) !== expectedEmail) {
-        return false;
-    }
-    const expectedDashboardUrl = normalizeUrlForComparison(dashboardUrl);
-    if (expectedDashboardUrl &&
-        normalizeUrlForComparison(session.dashboard_url) !== expectedDashboardUrl) {
-        return false;
-    }
-    return true;
-}
-function normalizeEmailForComparison(value) {
-    const normalized = value?.trim().toLowerCase();
-    return normalized ? normalized : null;
-}
-async function readOnboardSessionReuseCandidate(homeDir) {
-    const paths = getCollectorRuntimePaths(homeDir);
-    try {
-        return await readLocalCollectorSessionFile(paths);
-    }
-    catch {
-        return readLocalSessionReference(paths);
-    }
-}
-function normalizeUrlForComparison(value) {
-    return value ? normalizeUrl(value) : null;
-}
-function shortSha(value) {
-    return value ? value.slice(0, 12) : "unknown";
-}
-function sourceFunnelLine(label, counts) {
-    const readFailures = counts.read_failures > 0 ? `, read_failures ${counts.read_failures}` : "";
-    return `${label} sessions: attributed ${counts.attributed}, fallback ${counts.attributed_fallback}, ambiguous ${counts.ambiguous}, unattributed ${counts.unattributed}, skipped ${counts.skipped}, stale ${counts.stale}${readFailures}`;
-}
-function attributionReportLine(summary) {
-    return summary.report_posted
-        ? "Attribution report: recorded"
-        : `Attribution report: skipped (${summary.report_reason})`;
-}
-/**
- * One funnel line per source, an anomaly diagnostics line only when something
- * is nonzero (clean syncs stay one line per source), and the report line.
- * Counts only — project-dir slugs encode full local paths and never print
- * (B.4 §5).
- */
-function writeAgentSessionSummary(io, summary) {
-    writeLine(io.stdout, sourceFunnelLine("Codex", summary.codex));
-    writeLine(io.stdout, sourceFunnelLine("Claude", summary.claude));
-    const claudeDiagnostics = claudeDiagnosticsLine(summary);
-    if (claudeDiagnostics)
-        writeLine(io.stdout, claudeDiagnostics);
-    writeLine(io.stdout, attributionReportLine(summary));
-}
-function claudeDiagnosticsLine(summary) {
-    // Anomaly-only (D34): sidecars_collected/uploaded are normal-operation
-    // counters and must NOT trigger this line, or a healthy orchestrated sync
-    // prints it 48×/day in launchd logs. Clean syncs stay one line per source.
-    const claude = summary.claude;
-    const parts = [];
-    if (claude.sidecars_skipped)
-        parts.push(`sidecars_skipped ${claude.sidecars_skipped}`);
-    if (claude.sidecars_capped)
-        parts.push(`sidecars_capped ${claude.sidecars_capped}`);
-    if (claude.sidecars_failed)
-        parts.push(`sidecars_failed ${claude.sidecars_failed}`);
-    if (claude.mains_oversized)
-        parts.push(`mains_oversized ${claude.mains_oversized}`);
-    if (claude.oversized_lines_skipped)
-        parts.push(`oversized_lines_skipped ${claude.oversized_lines_skipped}`);
-    if (claude.project_dirs_skipped)
-        parts.push(`project_dirs_skipped ${claude.project_dirs_skipped}`);
-    if (claude.sessions_schema_drift)
-        parts.push(`schema_drift ${claude.sessions_schema_drift}`);
-    if (claude.growth_damped)
-        parts.push(`growth_damped ${claude.growth_damped}`);
-    if (claude.first_run_backfill)
-        parts.push("first_run_backfill");
-    if (summary.files_deferred_byte_budget)
-        parts.push(`deferred_byte_budget ${summary.files_deferred_byte_budget}`);
-    if (summary.files_deferred_object_budget)
-        parts.push(`deferred_object_budget ${summary.files_deferred_object_budget}`);
-    return parts.length > 0 ? `Claude diagnostics: ${parts.join(", ")}` : null;
-}
-function rawEvidenceSyncLine(sync) {
-    const failures = sync.raw_evidence_failure_reasons.length > 0
-        ? ` failures: ${sync.raw_evidence_failure_reasons.join(",")}`
-        : "";
-    const retries = sync.raw_evidence_retry_reasons.length > 0
-        ? ` retry_required: ${sync.raw_evidence_retry_reasons.join(",")}`
-        : "";
-    // A held object and a nine-day-old first failure both belong on this line.
-    // Neither used to appear anywhere, which is how a 1,030-attempt loop stayed
-    // invisible (BLI-3066).
-    const held = sync.raw_evidence_delivery_held_count > 0
-        ? ` held: ${sync.raw_evidence_delivery_held_count}`
-        : "";
-    const stuck = sync.raw_evidence_stuck_object_count > 0
-        ? ` stuck: ${sync.raw_evidence_stuck_object_count} (worst ${sync.raw_evidence_max_delivery_attempts} attempt(s) since ${sync.raw_evidence_oldest_delivery_failure_at ?? "unknown"})`
-        : "";
-    return `Raw evidence: uploaded ${sync.raw_evidence_uploaded_object_count} object(s) in ${sync.raw_evidence_uploaded_chunk_count} chunk(s), reused ${sync.raw_evidence_reused_count}, failed ${sync.raw_evidence_failed_count}${held}${stuck}${failures}${retries}`;
-}
-function cursorStatusLine(sync) {
-    return `Cursor: ${sync.cursor_tracked_object_count} durable object(s) tracked`;
-}
-const ALL_SESSION_SCAN_WINDOW_MINUTES = 20 * 365 * 24 * 60;
-const SESSION_SCAN_OVERRIDE_LIMIT = 10_000;
-async function discoverCommandWorktrees(repoRoot, discovery = {}, io) {
-    // What the operator typed this run, else what they typed some previous run,
-    // else the built-in defaults (BLI-2362).
-    const limits = await resolveDiscoveryLimits(discovery, discovery.homeDir);
-    const maxWorktrees = limits.maxRepos;
-    const roots = Array.isArray(repoRoot)
-        ? repoRoot
-        : [repoRoot ?? process.cwd()];
-    const result = await discoverGitWorktreesInRootsWithStatus(roots, {
-        maxDepth: limits.maxDepth,
-        maxWorktrees,
-    });
-    if (io && result.unreadable_dirs.length > 0) {
-        // Never silently dropped: anything under these folders is missing from the
-        // scan, so say so even when the run otherwise succeeds.
-        writeLine(io.stderr, unreadableDirectoriesMessage(result.unreadable_dirs));
-    }
-    const worktrees = result.worktrees;
-    if (!result.complete) {
-        // Sync fails closed here ON PURPOSE, and that is not the bug. Advancing a
-        // cursor after a partial scan would mark the run as covering repos it
-        // never saw, permanently skipping their sessions — backfill can tolerate
-        // partial only because it keeps per-scope completion markers, and sync
-        // does not. The bug (BLI-2362) was that the refusal named no roots and
-        // gave no runnable command, so a big workspace just stayed red forever.
-        const message = incompleteDiscoveryMessage({
-            result,
-            roots,
-            maxDepth: limits.maxDepth,
-            maxRepos: maxWorktrees,
-            found: worktrees.length,
-        });
-        if (io)
-            writeLine(io.stderr, message);
-        throw new Error(message);
-    }
-    if (worktrees.length === 0 && !discovery.allowEmpty) {
-        throw new Error("No git repos found. Run from a git repo, or from a parent folder containing git repos.");
-    }
-    return worktrees;
-}
-/**
- * Persists `--max-depth` / `--max-repos` when a command carried them, so the
- * number survives into the background sync and the doctor's own sync — neither
- * of which has anywhere to type one (BLI-2362). Best-effort: failing to record
- * a preference must never fail the command the operator actually asked for.
- */
-async function rememberDiscoveryLimits(command) {
-    const limits = command;
-    if (limits.maxDepth === undefined && limits.maxRepos === undefined)
-        return;
-    await saveDiscoveryLimits({ maxDepth: limits.maxDepth, maxRepos: limits.maxRepos }, limits.homeDir).catch(() => undefined);
-}
-/**
- * Says which folders could not be opened, and therefore what the scan could not
- * see. Reported without failing the run — an unreadable folder cannot be fixed
- * by retrying, so blocking on one would strand the machine (BLI-2362).
- */
-function unreadableDirectoriesMessage(unreadable) {
-    return [
-        `WARNING: ${unreadable.length} folder(s) could not be opened, so anything inside them was not scanned:`,
-        ...unreadable.map((dir) => `  ${dir.path} (${dir.code})`),
-        "Collection continued for everything else. If a repo is missing from Cockpit,",
-        "check the permissions on the folders above.",
-    ].join("\n");
-}
-/**
- * Names the roots that could not be covered and hands back a command that
- * actually fixes it, with this machine's numbers already filled in.
- */
-function incompleteDiscoveryMessage(input) {
-    const { result, roots, maxDepth, maxRepos, found } = input;
-    const blocked = result.incomplete_roots.length > 0 ? result.incomplete_roots : roots;
-    const hitRepoCap = result.incomplete_reasons.includes("max_worktrees_reached");
-    const nextDepth = maxDepth + 3;
-    const nextRepos = Math.max(maxRepos * 2, found + 50);
-    const retry = [
-        "cockpit do-everything",
-        ...roots.map((root) => `--workspace ${root}`),
-        `--max-depth ${hitRepoCap ? maxDepth : nextDepth}`,
-        `--max-repos ${nextRepos}`,
-    ].join(" ");
-    return [
-        `Cockpit could not finish scanning for repos, so it stopped instead of collecting a partial picture (${result.incomplete_reasons.join(", ")}).`,
-        "It stops rather than continuing because a partial scan would mark these repos as already checked and skip them from now on.",
-        "",
-        "Could not fully scan:",
-        ...blocked.map((root) => `  ${root}`),
-        "",
-        `Found ${found} repo(s) before stopping, with --max-depth ${maxDepth} and --max-repos ${maxRepos}.`,
-        "",
-        "Run this to raise the limits and try again:",
-        `  ${retry}`,
-        "",
-        "If that still stops, the folder is deeper or larger than expected — raise the numbers again, or point --workspace at the specific project folders instead of a parent.",
-    ].join("\n");
-}
 async function runMultiRepoOnboard(command, io, worktrees) {
     if (!command.json) {
         writeLine(io.stdout, `3/5 Parent folder mode: discovered ${worktrees.length} git worktree(s).`);
@@ -1938,7 +715,7 @@ async function runMultiRepoOnboard(command, io, worktrees) {
         fetchImpl: io.fetch,
     });
     const results = run.outcomes.map((outcome) => worktreeSyncRow(outcome, run));
-    const runStatus = attributedSyncRunStatus(run);
+    const collectionRunStatus = attributedSyncRunStatus(run);
     if (!command.json) {
         for (const [index, outcome] of run.outcomes.entries()) {
             const row = results[index];
@@ -1954,42 +731,12 @@ async function runMultiRepoOnboard(command, io, worktrees) {
             writeLine(io.stdout, "Live sync receipts complete; verifying all-history Codex and Claude backfill.");
         }
         else {
-            writeLine(io.stderr, `BLOCKED: Cockpit collection is ${runStatus}; retry until every eligible session has a durable receipt or explicit terminal reason.`);
+            writeLine(io.stderr, `BLOCKED: Cockpit collection is ${collectionRunStatus}; retry until every eligible session has a durable receipt or explicit terminal reason.`);
         }
         writeLine(io.stdout, `Open: ${command.dashboardUrl}/my-work`);
     }
     return { ok: run.ok, results, codex_sessions: run.summary };
 }
-function worktreeSyncRow(outcome, run) {
-    const { worktree, context, sync } = outcome;
-    const matchesWorktree = (result) => matchesLiveSyncWorktree(result, worktree);
-    const codexSessionCount = run.codexAttribution.results.filter(matchesWorktree).length;
-    const claudeSessionCount = run.claudeAttribution.results.filter(matchesWorktree).length;
-    const attributedSessionCount = codexSessionCount + claudeSessionCount;
-    return {
-        repo_label: context?.repo_label ?? worktree.repo_label,
-        repo_fingerprint: context?.repo_fingerprint ?? worktree.repo_fingerprint,
-        worktree_label: context?.worktree_label ?? worktree.worktree_label,
-        worktree_fingerprint: context?.worktree_fingerprint ?? worktree.worktree_fingerprint,
-        branch: context?.branch ?? worktree.branch,
-        head_sha: sync.head_sha ?? worktree.head_sha,
-        work_context_id: context?.work_context_id ?? sync.work_context_id,
-        upload_status: sync.status,
-        raw_evidence_file_count: sync.raw_evidence_file_count,
-        raw_evidence_uploaded_object_count: sync.raw_evidence_uploaded_object_count,
-        raw_evidence_uploaded_chunk_count: sync.raw_evidence_uploaded_chunk_count,
-        raw_evidence_reused_count: sync.raw_evidence_reused_count,
-        raw_evidence_failed_count: sync.raw_evidence_failed_count,
-        raw_evidence_failure_reasons: sync.raw_evidence_failure_reasons,
-        raw_evidence_retry_required: sync.raw_evidence_retry_required,
-        raw_evidence_retry_reasons: sync.raw_evidence_retry_reasons,
-        attributed_session_count: attributedSessionCount,
-        codex_session_count: codexSessionCount,
-        claude_session_count: claudeSessionCount,
-        cursor_tracked_object_count: sync.cursor_tracked_object_count,
-        failure_reason: sync.status === "spooled" ? sync.failure_reason : null,
-    };
-}
 async function runLogin(command, io) {
     // Standalone `cockpit login` must work on a fresh machine: bootstrap a
     // minimal rootless config when onboard/install has not run yet, instead of
@@ -2442,46 +1189,6 @@ async function runSyncWithHealthReceipt(command, io) {
         await lock.handle.release();
     }
 }
-export function classifySyncHealthError(error) {
-    const message = errorMessage(error);
-    if (/auth|token|session|unauthorized|forbidden|401|403/iu.test(message)) {
-        return "auth_failed";
-    }
-    if (/fetch|network|enotfound|econnrefused|timeout/iu.test(message)) {
-        return "network_failed";
-    }
-    // Anchored on the code the collector actually throws rather than on loose
-    // vocabulary. The old test matched /collection.root|workspace|repo|worktree/
-    // against the message, so any failure that merely mentioned a repo was filed
-    // as a collection-root failure and the real reason was lost (BLI-2492).
-    if (message.includes(COLLECTION_ROOT_REQUIRED) ||
-        /collection root/iu.test(message)) {
-        return "collection_root_failed";
-    }
-    return "sync_failed";
-}
-// The bucket above is for aggregation. This is the reason — the actual message,
-// redacted on the machine that produced it, before it ever leaves.
-//
-// Error text can carry absolute paths and, on some auth failures, token-shaped
-// fragments. It goes through the same deterministic redaction the collector
-// already applies to evidence, and is capped so one pathological stack trace
-// cannot dominate a health receipt.
-export const SYNC_ERROR_DETAIL_MAX_CHARS = 600;
-export function redactedSyncErrorDetail(error) {
-    const message = errorMessage(error).replace(/\s+/gu, " ").trim();
-    const { text } = redactSecretLikeContent(message, {
-        appliedBy: "local_collector",
-    });
-    // BLI-2542: the comment above always said this text can carry absolute paths,
-    // and until now nothing removed them — secret redaction matches token shapes,
-    // not filesystem paths. Same masking the doctor receipts use, so one boundary
-    // rule covers every health receipt.
-    const masked = maskLocalIdentifiers(text);
-    return masked.length > SYNC_ERROR_DETAIL_MAX_CHARS
-        ? `${masked.slice(0, SYNC_ERROR_DETAIL_MAX_CHARS - 1)}…`
-        : masked;
-}
 /**
  * Turn a finished run into an exit code and the reasons behind it.
  *
@@ -2522,12 +1229,12 @@ async function runSyncLocked(command, io) {
     });
     if (run.outcomes.length > 1) {
         const rows = run.outcomes.map((outcome) => worktreeSyncRow(outcome, run));
-        const runStatus = attributedSyncRunStatus(run);
+        const collectionRunStatus = attributedSyncRunStatus(run);
         const gc = run.ok ? await runSyncRawEvidenceGc(command, io) : null;
         if (command.json) {
             writeLine(io.stdout, JSON.stringify({
                 mode: "multi_repo",
-                status: runStatus,
+                status: collectionRunStatus,
                 collection_complete: run.ok,
                 results: run.outcomes.map((outcome) => outcome.sync),
                 repos: rows,
@@ -2537,7 +1244,7 @@ async function runSyncLocked(command, io) {
             }, null, 2));
             return syncResult(run);
         }
-        writeLine(run.ok ? io.stdout : io.stderr, `Cockpit parent sync ${runStatus} ${run.outcomes.filter((outcome) => outcome.sync.status === "uploaded").length}/${run.outcomes.length} worktree(s).`);
+        writeLine(run.ok ? io.stdout : io.stderr, `Cockpit parent sync ${collectionRunStatus} ${run.outcomes.filter((outcome) => outcome.sync.status === "uploaded").length}/${run.outcomes.length} worktree(s).`);
         for (const outcome of run.outcomes) {
             const { worktree, sync } = outcome;
             const uploaded = sync.status === "uploaded";
@@ -2556,12 +1263,12 @@ async function runSyncLocked(command, io) {
     // fleet machine with a single empty root and taught people to ignore
     // sync_failed (BLI-2722). A genuinely broken run still fails via run.ok.
     if (run.outcomes.length === 0) {
-        const runStatus = attributedSyncRunStatus(run);
+        const collectionRunStatus = attributedSyncRunStatus(run);
         const gc = run.ok ? await runSyncRawEvidenceGc(command, io) : null;
         if (command.json) {
             writeLine(io.stdout, JSON.stringify({
                 mode: "no_worktrees",
-                status: runStatus,
+                status: collectionRunStatus,
                 collection_complete: run.ok,
                 codex_sessions: run.summary,
                 raw_evidence_gc: gc,
@@ -2569,7 +1276,7 @@ async function runSyncLocked(command, io) {
             }, null, 2));
             return syncResult(run);
         }
-        writeLine(run.ok ? io.stdout : io.stderr, `Cockpit sync ${runStatus}: no git worktrees under this root; session scan ran.`);
+        writeLine(run.ok ? io.stdout : io.stderr, `Cockpit sync ${collectionRunStatus}: no git worktrees under this root; session scan ran.`);
         writeAgentSessionSummary(io, run.summary);
         if (gc && !gc.skipped)
             writeLine(io.stdout, rawEvidenceGcSummary(gc));
@@ -2579,12 +1286,12 @@ async function runSyncLocked(command, io) {
     if (!result) {
         throw new Error("Sync produced no result for the repo worktree.");
     }
-    const runStatus = attributedSyncRunStatus(run);
+    const collectionRunStatus = attributedSyncRunStatus(run);
     const gc = run.ok ? await runSyncRawEvidenceGc(command, io) : null;
     if (command.json) {
         writeLine(io.stdout, JSON.stringify({
             ...result,
-            status: runStatus,
+            status: collectionRunStatus,
             collection_complete: run.ok,
             codex_sessions: run.summary,
             raw_evidence_gc: gc,
@@ -2630,20 +1337,6 @@ async function resolveSyncCollectionRoots(command) {
     }
     throw new Error(`${COLLECTION_ROOT_REQUIRED}: no explicit or saved collection root is available.`);
 }
-async function collectionRootConsentAliases(roots) {
-    // Keep both spellings when an existing root is reached through a filesystem
-    // alias such as macOS `/var` -> `/private/var`. Deleted child paths cannot be
-    // realpathed later, so either transcript spelling must remain inside the same
-    // operator-approved physical root.
-    return normalizeCollectionRoots(await collectionRootPathAliases(roots));
-}
-function attributedSyncRunStatus(run) {
-    if (run.ok)
-        return "uploaded";
-    return run.outcomes.every((outcome) => outcome.sync.status === "uploaded")
-        ? "partial"
-        : "spooled";
-}
 async function runAnalyze(command, io) {
     const syncStdout = [];
     const syncStderr = [];
@@ -2746,372 +1439,15 @@ async function readAnalyzeApiResponse(response) {
         return {};
     }
 }
-function parseCapturedJson(chunks) {
-    const text = chunks.join("").trim();
-    if (!text)
-        return null;
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return text;
-    }
-}
 function isUploadedSyncResult(value) {
     return Boolean(value
         && typeof value === "object"
         && !Array.isArray(value)
         && value["status"] === "uploaded");
 }
-function bufferedWritable(chunks) {
-    return {
-        write(chunk) {
-            chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
-            return true;
-        },
-    };
-}
-function replayCaptured(stream, chunks) {
-    for (const chunk of chunks)
-        stream.write(chunk);
-}
 async function runSyncRawEvidenceGc(command, io) {
     return runRawEvidenceLocalGc(getCollectorRuntimePaths(command.homeDir), io.env);
 }
-async function runStatus(command, io) {
-    const backfillCursor = await inspectBackfillCursor(command.homeDir);
-    const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos, homeDir: command.homeDir }, io);
-    if (worktrees.length > 1) {
-        const statuses = await Promise.all(worktrees.map(async (worktree) => ({
-            ...(await inspectLocalCollectorStatus({
-                homeDir: command.homeDir,
-                repoRoot: worktree.repo_root,
-            })),
-            head_sha: worktree.head_sha,
-        })));
-        if (command.json) {
-            writeLine(io.stdout, JSON.stringify({ mode: "multi_repo", statuses, backfill_cursor: backfillCursor }, null, 2));
-            return 0;
-        }
-        writeLine(io.stdout, "Cockpit parent status");
-        writeLine(io.stdout, `backfill: ${backfillCursorLine(backfillCursor)}`);
-        for (const status of statuses) {
-            writeLine(io.stdout, `- ${status.repo_label ?? status.repo}/${status.worktree_label ?? "worktree"} · ${status.branch} · head:${shortSha(status.head_sha)} · ${status.upload_state}`);
-        }
-        return 0;
-    }
-    const status = await inspectLocalCollectorStatus(command);
-    if (command.json) {
-        writeLine(io.stdout, JSON.stringify({ ...status, backfill_cursor: backfillCursor }, null, 2));
-        return 0;
-    }
-    writeLine(io.stdout, "Cockpit local status");
-    writeLine(io.stdout, `installed: ${status.installed}`);
-    writeLine(io.stdout, `session_state: ${status.session_state}`);
-    writeLine(io.stdout, `repo: ${status.repo}`);
-    writeLine(io.stdout, `branch: ${status.branch}`);
-    writeLine(io.stdout, `ticket: ${displayTicketId(status.active_ticket_id)}`);
-    writeLine(io.stdout, `work: ${displayWorkLabel(status)}`);
-    writeLine(io.stdout, `collector_freshness: ${status.collector_freshness}`);
-    writeLine(io.stdout, `collector_version: ${status.collector_version}`);
-    writeLine(io.stdout, `upload_state: ${status.upload_state}`);
-    writeLine(io.stdout, `last_upload_attempt: ${status.last_upload_attempt_at ?? "never"}`);
-    writeLine(io.stdout, `last_upload_success: ${status.last_upload_success_at ?? "never"}`);
-    writeLine(io.stdout, `last_upload_failure: ${status.last_upload_failure_reason ?? "none"}`);
-    writeLine(io.stdout, `pending_uploads: ${status.pending_upload_count}`);
-    writeLine(io.stdout, `pending_health_receipts: ${status.pending_health_receipt_count}`);
-    writeLine(io.stdout, `last_health_receipt_failure: ${status.last_health_receipt_failure_reason ?? "none"}`);
-    writeLine(io.stdout, `backfill: ${backfillCursorLine(backfillCursor)}`);
-    writeLine(io.stdout, `stuck_evidence: ${stuckEvidenceLine(status)}`);
-    for (const detail of status.details)
-        writeLine(io.stdout, `- ${detail}`);
-    return 0;
-}
-/**
- * One line that cannot say "fine" while an object has never been accepted.
- * Named reasons, worst attempt count, and the date it started.
- */
-function stuckEvidenceLine(status) {
-    if (status.stuck_evidence_object_count === 0)
-        return "none";
-    return `${status.stuck_evidence_object_count} object(s), ${status.stuck_evidence_held_count} held, worst ${status.stuck_evidence_max_attempts} attempt(s) since ${status.stuck_evidence_oldest_failure_at ?? "unknown"} (${status.stuck_evidence_reasons.join(",") || "unknown"})`;
-}
-function displayTicketId(ticketId) {
-    return ticketId ?? "general ambient";
-}
-function displayWorkLabel(status) {
-    if (status.work_label && status.work_id)
-        return `${status.work_label} (${status.work_id})`;
-    return status.work_label ?? status.work_id ?? "no active work context";
-}
-async function inspectBackfillCursor(homeDir) {
-    const paths = getCollectorRuntimePaths(homeDir);
-    const roots = await currentBackfillRoots(homeDir);
-    const marker = await readBackfillCompletionMarker(paths);
-    if (backfillCompletionCovers(marker, roots, ["codex", "claude_code"])) {
-        return {
-            state: "done",
-            remaining_count: 0,
-            updated_at: marker?.cursor.updated_at ?? null,
-            completed_at: marker?.completed_at ?? null,
-            sources: summarizeBackfillCursorSources(marker?.cursor ?? emptyBackfillCursorState()),
-        };
-    }
-    const cursor = (prepareBackfillCursorForScope(await readBackfillCursor(paths), roots, ["codex", "claude_code"])).cursor;
-    if (!cursor.updated_at) {
-        return {
-            state: "never_run",
-            remaining_count: 0,
-            updated_at: null,
-            completed_at: null,
-            sources: summarizeBackfillCursorSources(cursor),
-        };
-    }
-    return {
-        state: "remaining",
-        remaining_count: await countRemainingBackfillSessionFiles(homeDir ?? os.homedir(), cursor),
-        updated_at: cursor.updated_at,
-        completed_at: null,
-        sources: summarizeBackfillCursorSources(cursor),
-    };
-}
-async function currentBackfillRoots(homeDir) {
-    const config = await readLocalCollectorConfig(getCollectorRuntimePaths(homeDir)).catch(() => null);
-    return normalizeCollectionRoots(config?.default_repo_paths ?? []);
-}
-function summarizeBackfillCursorSources(cursor) {
-    return {
-        codex: summarizeBackfillSource(cursor.sources.codex),
-        claude_code: summarizeBackfillSource(cursor.sources.claude_code),
-    };
-}
-function summarizeBackfillSource(source) {
-    return {
-        oldest_mtime_processed: source.oldest_mtime_processed,
-        observed_count: Object.values(source.state_counts).reduce((total, count) => total + count, 0),
-        state_counts: source.state_counts,
-        reason_counts: source.reason_counts,
-    };
-}
-function backfillCursorLine(status) {
-    switch (status.state) {
-        case "done":
-            return `done (${status.completed_at ?? "completion marker present"})`;
-        case "never_run":
-            return "never run";
-        case "remaining":
-            return `${status.remaining_count} remaining`;
-    }
-}
-async function countRemainingBackfillSessionFiles(homeDir, cursor) {
-    const codex = await countJsonlFilesBeforeCursor(defaultCodexSessionDirs(homeDir), cursor.sources.codex.oldest_mtime_ms_processed);
-    const claude = await countClaudeMainFilesBeforeCursor(path.join(homeDir, ".claude", "projects"), cursor.sources.claude_code.oldest_mtime_ms_processed);
-    return codex + claude;
-}
-async function countJsonlFilesBeforeCursor(roots, oldestProcessedMs) {
-    let count = 0;
-    await walkFiles(roots, async (filePath, entryName) => {
-        if (!entryName.endsWith(".jsonl"))
-            return;
-        const info = await stat(filePath).catch(() => null);
-        if (!info?.isFile())
-            return;
-        if (oldestProcessedMs === null || info.mtimeMs < oldestProcessedMs)
-            count += 1;
-    });
-    return count;
-}
-async function countClaudeMainFilesBeforeCursor(projectsDir, oldestProcessedMs) {
-    let count = 0;
-    await walkFiles([projectsDir], async (filePath, entryName) => {
-        if (!entryName.endsWith(".jsonl"))
-            return;
-        if (filePath.includes(`${path.sep}subagents${path.sep}`))
-            return;
-        const info = await stat(filePath).catch(() => null);
-        if (!info?.isFile())
-            return;
-        if (oldestProcessedMs === null || info.mtimeMs < oldestProcessedMs)
-            count += 1;
-    });
-    return count;
-}
-async function walkFiles(roots, onFile, shouldStop = () => false) {
-    const stack = [...roots];
-    while (stack.length > 0 && !shouldStop()) {
-        const current = stack.pop();
-        if (!current)
-            continue;
-        let entries;
-        try {
-            entries = await readdir(current, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            if (shouldStop())
-                return;
-            const full = path.join(current, entry.name);
-            if (entry.isDirectory()) {
-                stack.push(full);
-            }
-            else if (entry.isFile()) {
-                await onFile(full, entry.name);
-            }
-        }
-    }
-}
-async function sessionsScanWindow(command, now) {
-    if (command.all) {
-        return {
-            mode: "all",
-            since_days: null,
-            started_at: new Date(now.getTime() - ALL_SESSION_SCAN_WINDOW_MINUTES * 60_000)
-                .toISOString(),
-            paired_at: await readPairedAt(command.homeDir),
-            since_minutes: ALL_SESSION_SCAN_WINDOW_MINUTES,
-            limit: SESSION_SCAN_OVERRIDE_LIMIT,
-        };
-    }
-    if (command.sinceDays !== undefined) {
-        const requestedMs = now.getTime() - command.sinceDays * 24 * 60 * 60_000;
-        const pairedAt = await readPairedAt(command.homeDir);
-        const pairedMs = pairedAt ? Date.parse(pairedAt) : Number.NaN;
-        const startedAtMs = Number.isFinite(pairedMs)
-            ? Math.max(requestedMs, pairedMs)
-            : requestedMs;
-        return {
-            mode: "since_days",
-            since_days: command.sinceDays,
-            started_at: new Date(startedAtMs).toISOString(),
-            paired_at: pairedAt,
-            since_minutes: Math.max(1, Math.ceil((now.getTime() - startedAtMs) / 60_000)),
-            limit: SESSION_SCAN_OVERRIDE_LIMIT,
-        };
-    }
-    return {
-        mode: "default",
-        since_days: null,
-        started_at: null,
-        paired_at: await readPairedAt(command.homeDir),
-        since_minutes: null,
-        limit: CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT,
-    };
-}
-async function readPairedAt(homeDir) {
-    const session = await readLocalCollectorSessionFile(getCollectorRuntimePaths(homeDir)).catch(() => null);
-    return typeof session?.paired_at === "string" ? session.paired_at : null;
-}
-function sessionsWindowLine(window) {
-    if (window.mode === "all")
-        return "all local history";
-    if (window.mode === "since_days") {
-        return `since ${window.started_at} (${window.since_days} day request, paired_at cap ${window.paired_at ?? "unavailable"})`;
-    }
-    return "default scan window";
-}
-/**
- * Read-only diagnostic: re-runs attribution (no upload, no cursor writes) and
- * prints why each session is or is not collected. Per-session reasons otherwise
- * live only in a service-role table with no UI, so this is the operator's local
- * answer to "why is session X missing?" (B.4 §6). Counts and labels only — the
- * project-dir slug encodes a local path and is never printed.
- */
-async function runSessions(command, io) {
-    const now = new Date();
-    const homeDir = command.homeDir ?? os.homedir();
-    const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos, homeDir: command.homeDir }, io);
-    const window = await sessionsScanWindow(command, now);
-    const wantCodex = command.source !== "claude";
-    const wantClaude = command.source !== "codex";
-    const codex = wantCodex
-        ? await scanAndAttributeCodexSessions({
-            sessionsDirs: defaultCodexSessionDirs(homeDir),
-            worktrees,
-            now,
-            sinceMinutes: window.since_minutes ?? CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES,
-            limit: window.limit,
-        })
-        : null;
-    const claude = wantClaude
-        ? await scanAndAttributeClaudeSessions({
-            projectsDir: path.join(homeDir, ".claude", "projects"),
-            worktrees,
-            now,
-            sinceMinutes: window.since_minutes ?? undefined,
-            limit: window.mode === "default" ? undefined : window.limit,
-        })
-        : null;
-    // Safe output contract (B.4 §6): id, state, reason, scores, signals, sidecar
-    // skip reasons, plus the repo_label basename. Branch is intentionally omitted
-    // — branch names can carry operator-authored task/customer text.
-    const codexRows = (codex?.results ?? []).map((result) => ({
-        source: "codex",
-        session_id: result.codex_session_id,
-        state: result.state,
-        reason: result.reason,
-        attribution_score: result.attribution_score,
-        path_score: result.path_score,
-        signals: result.signals,
-        repo_label: result.worktree?.repo_label ?? null,
-    }));
-    const claudeRows = (claude?.results ?? []).map((result) => ({
-        source: "claude_code",
-        session_id: result.claude_session_id,
-        state: result.state,
-        reason: result.reason,
-        attribution_score: result.attribution_score,
-        path_score: result.path_score,
-        signals: result.signals,
-        repo_label: result.worktree?.repo_label ?? null,
-        main_file_oversized: result.main_file_oversized,
-        sidecar_skips: result.sidecar_files
-            .filter((sidecar) => sidecar.skipped_reason)
-            .map((sidecar) => ({
-            file_name: sidecar.file_name,
-            reason: sidecar.skipped_reason,
-        })),
-    }));
-    if (command.json) {
-        writeLine(io.stdout, JSON.stringify({
-            window,
-            ...(codex
-                ? { codex: { counts: codex.counts, sessions: codexRows } }
-                : {}),
-            ...(claude
-                ? {
-                    claude: {
-                        counts: claude.counts,
-                        project_dirs_skipped: claude.project_dirs_skipped,
-                        sessions: claudeRows,
-                    },
-                }
-                : {}),
-        }, null, 2));
-        return 0;
-    }
-    writeLine(io.stdout, "Cockpit sessions (read-only attribution)");
-    writeLine(io.stdout, `window: ${sessionsWindowLine(window)}`);
-    for (const row of codexRows) {
-        writeLine(io.stdout, sessionRowLine(row));
-    }
-    for (const row of claudeRows) {
-        writeLine(io.stdout, sessionRowLine(row));
-        for (const sidecar of row.sidecar_skips) {
-            writeLine(io.stdout, `    sidecar ${sidecar.file_name}: ${sidecar.reason}`);
-        }
-    }
-    if (codexRows.length === 0 && claudeRows.length === 0) {
-        writeLine(io.stdout, "No sessions observed in the scan window.");
-    }
-    return 0;
-}
-function sessionRowLine(row) {
-    const repo = row.repo_label ? ` repo:${row.repo_label}` : "";
-    const signals = row.signals.length > 0 ? ` signals:${row.signals.join("|")}` : "";
-    return `- [${row.source}] ${row.session_id} ${row.state} (${row.reason}) score:${row.attribution_score} path:${row.path_score}${repo}${signals}`;
-}
 async function runServe(command, io) {
     const server = createCollectorServer(command);
     await new Promise((resolve) => {
@@ -3255,30 +1591,4 @@ function autostartLocationLine(result) {
     return result.task_name
         ? `Task: ${result.task_name}`
         : `Plist: ${result.plist_path}`;
-}
-function defaultExec() {
-    return createCapturedExecRunner();
-}
-function defaultInteractiveExec() {
-    return createInteractiveExecRunner();
-}
-function defaultIo() {
-    if (!globalThis.fetch) {
-        throw new Error("global fetch is unavailable; use Node.js 20 or newer.");
-    }
-    return {
-        stdin: process.stdin,
-        stdout: process.stdout,
-        stderr: process.stderr,
-        env: process.env,
-        fetch: globalThis.fetch.bind(globalThis),
-        exec: defaultExec(),
-        interactiveExec: defaultInteractiveExec(),
-    };
-}
-function writeLine(stream, text) {
-    stream.write(`${text}\n`);
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
 }