@bli-cockpit/cli 0.2.236 → 0.2.238

package/dist/commands/notes-writes.js

@@ -19,115 +19,92 @@ export async function uploadNotes(command, door) {
     const results = [];
     let worstExit = 0;
     for (const filePath of paths) {
-        // Read and screen locally BEFORE any network call — a refusal here never
-        // reaches the dashboard, same discipline as `cockpit jarvis --image`.
-        const read = await readNoteFile(filePath, { allowDirectAudio: true });
-        if (!read.ok) {
-            const sentence = noteFileRefusalSentence(read.refusal, filePath);
-            writeLine(door.io.stderr, `${TAG} file refused ${JSON.stringify({ reason: read.refusal, detail: read.detail })}`);
-            if (!door.json)
-                writeLine(door.io.stderr, sentence);
-            results.push({ path: filePath, ok: false, reason: read.refusal });
-            worstExit = 1;
-            continue;
-        }
-        if (!read.direct && read.bytes.byteLength >= NOTE_SLOW_UPLOAD_BYTES) {
-            // The route reads the whole note with one model call and may take
-            // minutes. A still cursor reads as a hang, so say what is happening.
-            writeLine(door.io.stderr, `Reading ${read.fileName} (${Math.round(read.bytes.byteLength / 1024)} KB). This can take a couple of minutes.`);
-        }
-        // A whole-meeting recording (over 4 MB) goes straight to storage and is
-        // transcribed in the background (BLI-12963); everything else keeps the
-        // upload route.
-        let answer;
-        if (read.direct) {
-            const direct = await uploadAudioDirect(door, {
-                filePath, fileName: read.fileName, size: read.size, exclude: command.exclude, folder: command.folder,
-            });
-            answer = direct.ok ? { ok: true, body: direct.body } : { ok: false, reason: direct.reason, detail: direct.detail };
-        }
-        else {
-            const form = new FormData();
-            form.set("file", new File([new Uint8Array(read.bytes)], read.fileName, { type: noteAudioMime(read.fileName) ?? "" }));
-            if (command.exclude)
-                form.set("exclusions", command.exclude);
-            if (command.folder)
-                form.set("folder_path", command.folder);
-            answer = await ask(door, {
-                path: "/api/notes/upload",
-                method: "POST",
-                label: "notes upload",
-                timeoutMs: UPLOAD_DEADLINE_MS,
-                body: form,
-            });
-        }
-        if (!answer.ok) {
-            writeLine(door.io.stderr, `${TAG} upload failed ${JSON.stringify({ reason: answer.reason })}`);
-            if (!door.json)
-                writeLine(door.io.stderr, `${read.fileName}: ${answer.detail}`);
-            results.push({ path: filePath, ok: false, reason: answer.reason });
+        const uploaded = await uploadOneNote(command, door, filePath);
+        results.push(uploaded.result);
+        if (uploaded.failed)
             worstExit = 1;
-            continue;
-        }
-        const body = answer.body;
-        if (command.wait && body.noteId && body.transcription?.status === "pending") {
-            body.transcription = await waitForTranscription(door, body.noteId, read.direct);
-        }
-        if (body.transcription?.status === "failed")
-            worstExit = 1;
-        if (!door.json && body.transcription)
-            writeLine(door.io.stdout, `${body.noteId}: transcription ${body.transcription.status}${body.transcription.reason ? ": " + body.transcription.reason : ""}`);
-        results.push({ path: filePath, ok: body.stored === true && body.transcription?.status !== "failed", body });
-        if (body.stored !== true)
-            worstExit = 1;
-        if (!door.json)
-            sayUpload(door, body);
-        writeLine(door.io.stderr, `${TAG} upload answered ${JSON.stringify({
-            stored: body.stored === true,
-            note_id: body.noteId ?? null,
-            scope: body.scope ?? null,
-            byte_size: read.size,
-            direct: read.direct,
-            extension: read.extension,
-        })}`);
     }
     if (door.json) {
         emit(door, { ok: worstExit === 0, uploaded: results.length, results });
     }
     return worstExit;
 }
-export async function pasteNote(command, door) {
-    let text;
-    if (command.filePath) {
-        const read = await readNoteFile(command.filePath);
-        if (!read.ok) {
-            const sentence = noteFileRefusalSentence(read.refusal, command.filePath);
-            writeLine(door.io.stderr, `${TAG} file refused ${JSON.stringify({ reason: read.refusal, detail: read.detail })}`);
-            return fail(door, read.refusal, sentence);
-        }
-        const decoded = decodeTextBytes(read.bytes);
-        if (!decoded.ok) {
-            writeLine(door.io.stderr, `${TAG} file refused ${JSON.stringify({ reason: decoded.reason })}`);
-            return fail(door, decoded.reason, "That file is not text this command can decode (it may be a binary or an unusual encoding). Nothing was sent.");
-        }
-        text = decoded.text;
+async function uploadOneNote(command, door, filePath) {
+    // Read and screen locally BEFORE any network call — a refusal here never
+    // reaches the dashboard, same discipline as `cockpit jarvis --image`.
+    const read = await readNoteFile(filePath, { allowDirectAudio: true });
+    if (!read.ok) {
+        const sentence = noteFileRefusalSentence(read.refusal, filePath);
+        writeLine(door.io.stderr, `${TAG} file refused ${JSON.stringify({ reason: read.refusal, detail: read.detail })}`);
+        if (!door.json)
+            writeLine(door.io.stderr, sentence);
+        return { result: { path: filePath, ok: false, reason: read.refusal }, failed: true };
     }
-    else {
-        if (isInteractiveStdin(door.io)) {
-            return fail(door, "nothing_piped", "Pass --file <path> (safest on Windows), or pipe the note in "
-                + "(`pbpaste | cockpit notes paste` on macOS; on Windows use PowerShell 7 — "
-                + "Windows PowerShell 5.1 turns non-ASCII into `?` on pipes).");
-        }
-        try {
-            text = await readPipedText(door.io.stdin, {
-                maxChars: PASTE_MAX_CHARS,
-                overflowMessage: `A pasted note is limited to ${PASTE_MAX_CHARS} characters. Save it to a file and use --file instead.`,
-            });
-        }
-        catch (error) {
-            return fail(door, "paste_too_long", errorText(error));
-        }
+    if (!read.direct && read.bytes.byteLength >= NOTE_SLOW_UPLOAD_BYTES) {
+        // The route reads the whole note with one model call and may take
+        // minutes. A still cursor reads as a hang, so say what is happening.
+        writeLine(door.io.stderr, `Reading ${read.fileName} (${Math.round(read.bytes.byteLength / 1024)} KB). This can take a couple of minutes.`);
+    }
+    const answer = await sendNoteFile(command, door, filePath, read);
+    if (!answer.ok) {
+        writeLine(door.io.stderr, `${TAG} upload failed ${JSON.stringify({ reason: answer.reason })}`);
+        if (!door.json)
+            writeLine(door.io.stderr, `${read.fileName}: ${answer.detail}`);
+        return { result: { path: filePath, ok: false, reason: answer.reason }, failed: true };
+    }
+    const body = answer.body;
+    if (command.wait && body.noteId && body.transcription?.status === "pending") {
+        body.transcription = await waitForTranscription(door, body.noteId, read.direct);
+    }
+    let failed = body.transcription?.status === "failed";
+    if (!door.json && body.transcription)
+        writeLine(door.io.stdout, `${body.noteId}: transcription ${body.transcription.status}${body.transcription.reason ? ": " + body.transcription.reason : ""}`);
+    const result = { path: filePath, ok: body.stored === true && body.transcription?.status !== "failed", body };
+    if (body.stored !== true)
+        failed = true;
+    if (!door.json)
+        sayUpload(door, body);
+    writeLine(door.io.stderr, `${TAG} upload answered ${JSON.stringify({
+        stored: body.stored === true,
+        note_id: body.noteId ?? null,
+        scope: body.scope ?? null,
+        byte_size: read.size,
+        direct: read.direct,
+        extension: read.extension,
+    })}`);
+    return { result, failed };
+}
+/**
+ * A whole-meeting recording (over 4 MB) goes straight to storage and is
+ * transcribed in the background (BLI-12963); everything else keeps the
+ * upload route.
+ */
+async function sendNoteFile(command, door, filePath, read) {
+    if (read.direct) {
+        const direct = await uploadAudioDirect(door, {
+            filePath, fileName: read.fileName, size: read.size, exclude: command.exclude, folder: command.folder,
+        });
+        return direct.ok ? { ok: true, body: direct.body } : { ok: false, reason: direct.reason, detail: direct.detail };
     }
+    const form = new FormData();
+    form.set("file", new File([new Uint8Array(read.bytes)], read.fileName, { type: noteAudioMime(read.fileName) ?? "" }));
+    if (command.exclude)
+        form.set("exclusions", command.exclude);
+    if (command.folder)
+        form.set("folder_path", command.folder);
+    return await ask(door, {
+        path: "/api/notes/upload",
+        method: "POST",
+        label: "notes upload",
+        timeoutMs: UPLOAD_DEADLINE_MS,
+        body: form,
+    });
+}
+export async function pasteNote(command, door) {
+    const pasted = command.filePath ? await readPasteFromFile(door, command.filePath) : await readPasteFromStdin(door);
+    if ("exitCode" in pasted)
+        return pasted.exitCode;
+    const text = pasted.text;
     if (text.trim() === "") {
         return fail(door, "empty_paste", "There was nothing to paste. Nothing was sent.");
     }
@@ -171,6 +148,44 @@ export async function pasteNote(command, door) {
     sayUpload(door, body);
     return body.stored === true ? 0 : 1;
 }
+/** The note text from `--file`, or the exit code of the refusal already written. */
+async function readPasteFromFile(door, filePath) {
+    const read = await readNoteFile(filePath);
+    if (!read.ok) {
+        const sentence = noteFileRefusalSentence(read.refusal, filePath);
+        writeLine(door.io.stderr, `${TAG} file refused ${JSON.stringify({ reason: read.refusal, detail: read.detail })}`);
+        return { exitCode: fail(door, read.refusal, sentence) };
+    }
+    const decoded = decodeTextBytes(read.bytes);
+    if (!decoded.ok) {
+        writeLine(door.io.stderr, `${TAG} file refused ${JSON.stringify({ reason: decoded.reason })}`);
+        return {
+            exitCode: fail(door, decoded.reason, "That file is not text this command can decode (it may be a binary or an unusual encoding). Nothing was sent."),
+        };
+    }
+    return { text: decoded.text };
+}
+/** The note text piped on stdin, or the exit code of the refusal already written. */
+async function readPasteFromStdin(door) {
+    if (isInteractiveStdin(door.io)) {
+        return {
+            exitCode: fail(door, "nothing_piped", "Pass --file <path> (safest on Windows), or pipe the note in "
+                + "(`pbpaste | cockpit notes paste` on macOS; on Windows use PowerShell 7 — "
+                + "Windows PowerShell 5.1 turns non-ASCII into `?` on pipes)."),
+        };
+    }
+    try {
+        return {
+            text: await readPipedText(door.io.stdin, {
+                maxChars: PASTE_MAX_CHARS,
+                overflowMessage: `A pasted note is limited to ${PASTE_MAX_CHARS} characters. Save it to a file and use --file instead.`,
+            }),
+        };
+    }
+    catch (error) {
+        return { exitCode: fail(door, "paste_too_long", errorText(error)) };
+    }
+}
 export async function shareNote(command, door) {
     const wantsToShare = command.action === "share";
     // Only sharing asks. Taking a note back narrows who can read it, and nobody

package/dist/commands/notes.js

@@ -57,6 +57,38 @@ export { showGranolaStatus } from "./notes-granola-status.js";
 export { showTranscriptionStats } from "./notes-transcription-stats.js";
 export { listRecordings, showRecording } from "./notes-recordings.js";
 export { ask, emit, fail, sayUpload, sayScope, errorText, TAG, } from "./notes-door.js";
+/** Which function answers each `cockpit notes <verb>`; typed over every action so a new one cannot be forgotten. */
+const NOTES_VERBS = {
+    folders: runFolderCommand,
+    mkdir: runFolderCommand,
+    rmdir: runFolderCommand,
+    rename: runFolderCommand,
+    list: listNotes,
+    shelves: listShelves,
+    show: showNote,
+    shelf: showShelf,
+    upload: uploadNotes,
+    paste: pasteNote,
+    share: shareNote,
+    unshare: shareNote,
+    summarize: summarizeNote,
+    move: moveNote,
+    place: placeNote,
+    // BLI-4394. `--show-webhook <id>` turns the list into one account's
+    // webhook URL, because that is the question a person asks WHILE looking
+    // at the list rather than a verb of its own.
+    accounts: (command, door) => (command.showWebhook ? showNotesWebhook(command, door) : listNotesAccounts(command, door)),
+    connect: connectNotetaker,
+    detach: detachNotetaker,
+    sync: syncNotetaker,
+    "sync-status": syncStatusNotetakers,
+    recordings: listRecordings,
+    recording: showRecording,
+    webhook: armNotesWebhook,
+    "bot-upcoming": showBotUpcoming,
+    "granola-status": showGranolaStatus,
+    "transcription-stats": showTranscriptionStats,
+};
 export async function runNotes(command, io) {
     const session = await loadPairedSession("notes", command.homeDir);
     const door = {
@@ -65,59 +97,5 @@ export async function runNotes(command, io) {
         io,
         json: command.json,
     };
-    switch (command.action) {
-        case "folders":
-        case "mkdir":
-        case "rmdir":
-        case "rename":
-            return runFolderCommand(command, door);
-        case "list":
-            return listNotes(command, door);
-        case "shelves":
-            return listShelves(command, door);
-        case "show":
-            return showNote(command, door);
-        case "shelf":
-            return showShelf(command, door);
-        case "upload":
-            return uploadNotes(command, door);
-        case "paste":
-            return pasteNote(command, door);
-        case "share":
-        case "unshare":
-            return shareNote(command, door);
-        case "summarize":
-            return summarizeNote(command, door);
-        case "move":
-            return moveNote(command, door);
-        case "place":
-            return placeNote(command, door);
-        case "accounts":
-            // BLI-4394. `--show-webhook <id>` turns the list into one account's
-            // webhook URL, because that is the question a person asks WHILE looking
-            // at the list rather than a verb of its own.
-            return command.showWebhook
-                ? showNotesWebhook(command, door)
-                : listNotesAccounts(command, door);
-        case "connect":
-            return connectNotetaker(command, door);
-        case "detach":
-            return detachNotetaker(command, door);
-        case "sync":
-            return syncNotetaker(command, door);
-        case "sync-status":
-            return syncStatusNotetakers(command, door);
-        case "recordings":
-            return listRecordings(command, door);
-        case "recording":
-            return showRecording(command, door);
-        case "webhook":
-            return armNotesWebhook(command, door);
-        case "bot-upcoming":
-            return showBotUpcoming(command, door);
-        case "granola-status":
-            return showGranolaStatus(command, door);
-        case "transcription-stats":
-            return showTranscriptionStats(command, door);
-    }
+    return NOTES_VERBS[command.action](command, door);
 }

package/dist/commands/onboard-flows.js

@@ -8,7 +8,7 @@ import { runAttributedWorktreeSync, } from "./session-sync.js";
 import { inspectLocalCollectorStatus, startLocalWorkContext, } from "../local-state.js";
 /** The parent-folder arm: sync every discovered worktree, then backfill and finish setup once. */
 export async function runOnboardMultiRepoFlow(ctx) {
-    const { command, resolvedCommand, collectionRoots, rootsResult, install, pair, installEvents, io, worktrees, } = ctx;
+    const { command, resolvedCommand, collectionRoots, installEvents, io, worktrees, } = ctx;
     const multi = await runMultiRepoOnboard(resolvedCommand, io, worktrees);
     addInstallEvent(installEvents, "work_context", "ok");
     addInstallEvent(installEvents, "sync", multi.ok ? "ok" : "fail", multi.ok ? undefined : "sync_blocked");
@@ -23,16 +23,7 @@ export async function runOnboardMultiRepoFlow(ctx) {
         ? undefined
         : backfill.failureReason ?? "backfill_incomplete");
     if (!completedBackfill) {
-        writeOnboardBackfillBlockedResult(io, {
-            json: command.json,
-            base: onboardJsonPayload("blocked", resolvedCommand, install, pair, null, null, rootsResult),
-            extra: {
-                mode: "multi_repo",
-                repos: multi.results,
-                codex_sessions: multi.codex_sessions,
-            },
-            backfill,
-        });
+        reportMultiRepoBackfillBlocked(ctx, multi, backfill);
         return finishOnboardRun(command, installEvents, io, 1);
     }
     const multiSetup = await completeOnboardingSetup(resolvedCommand, collectionRoots, installEvents, io);
@@ -43,9 +34,48 @@ export async function runOnboardMultiRepoFlow(ctx) {
     });
     return finishOnboardRun(command, installEvents, io, multiSetup.ok ? 0 : 1);
 }
+function reportMultiRepoBackfillBlocked(ctx, multi, backfill) {
+    const { command, resolvedCommand, rootsResult, install, pair, io } = ctx;
+    writeOnboardBackfillBlockedResult(io, {
+        json: command.json,
+        base: onboardJsonPayload("blocked", resolvedCommand, install, pair, null, null, rootsResult),
+        extra: {
+            mode: "multi_repo",
+            repos: multi.results,
+            codex_sessions: multi.codex_sessions,
+        },
+        backfill,
+    });
+}
 /** The single-repo arm: start the work context, sync it, backfill, then finish setup once. */
 export async function runOnboardSingleRepoFlow(ctx, single) {
-    const { command, resolvedCommand, collectionRoots, rootsResult, install, pair, installEvents, io, worktrees, } = ctx;
+    const { command, resolvedCommand, rootsResult, install, pair, installEvents, io } = ctx;
+    const { run, sync, status, worktreeRoot } = await startContextAndSync(ctx, single);
+    if (!run.ok || sync.status !== "uploaded") {
+        addInstallEvent(installEvents, "sync", "fail", "sync_blocked");
+        reportOnboardSyncBlocked(ctx, { run, sync, status, worktreeRoot });
+        return finishOnboardRun(command, installEvents, io, 1);
+    }
+    addInstallEvent(installEvents, "sync", "ok");
+    const backfill = await runRequiredOnboardBackfill(resolvedCommand, io);
+    const completedBackfill = backfill.status === "complete" ? backfill.result : null;
+    addInstallEvent(installEvents, "backfill", completedBackfill ? "ok" : "fail", completedBackfill
+        ? undefined
+        : backfill.failureReason ?? "backfill_incomplete");
+    if (!completedBackfill) {
+        writeOnboardBackfillBlockedResult(io, {
+            json: command.json,
+            base: onboardJsonPayload("blocked", resolvedCommand, install, pair, sync, status, rootsResult),
+            extra: { codex_sessions: run.summary },
+            backfill,
+        });
+        return finishOnboardRun(command, installEvents, io, 1);
+    }
+    return await finishSingleRepoSetup(ctx, { run, sync, status, completedBackfill });
+}
+/** Work context started, the one worktree synced, and the collector's own reading of the repo. */
+async function startContextAndSync(ctx, single) {
+    const { command, installEvents, io, worktrees } = ctx;
     const worktreeRoot = worktrees[0]?.repo_root ?? single.primaryRoot;
     const context = await startLocalWorkContext({
         homeDir: command.homeDir,
@@ -74,26 +104,12 @@ export async function runOnboardSingleRepoFlow(ctx, single) {
         repoRoot: worktreeRoot,
         branch: command.branch,
     });
-    if (!run.ok || sync.status !== "uploaded") {
-        addInstallEvent(installEvents, "sync", "fail", "sync_blocked");
-        reportOnboardSyncBlocked(ctx, { run, sync, status, worktreeRoot });
-        return finishOnboardRun(command, installEvents, io, 1);
-    }
-    addInstallEvent(installEvents, "sync", "ok");
-    const backfill = await runRequiredOnboardBackfill(resolvedCommand, io);
-    const completedBackfill = backfill.status === "complete" ? backfill.result : null;
-    addInstallEvent(installEvents, "backfill", completedBackfill ? "ok" : "fail", completedBackfill
-        ? undefined
-        : backfill.failureReason ?? "backfill_incomplete");
-    if (!completedBackfill) {
-        writeOnboardBackfillBlockedResult(io, {
-            json: command.json,
-            base: onboardJsonPayload("blocked", resolvedCommand, install, pair, sync, status, rootsResult),
-            extra: { codex_sessions: run.summary },
-            backfill,
-        });
-        return finishOnboardRun(command, installEvents, io, 1);
-    }
+    return { run, sync, status, worktreeRoot };
+}
+/** Backfill is complete: finish setup once, and say it as JSON or as the narrative. */
+async function finishSingleRepoSetup(ctx, facts) {
+    const { command, resolvedCommand, collectionRoots, pair, installEvents, io } = ctx;
+    const { run, sync, status, completedBackfill } = facts;
     if (command.json) {
         const jsonSetup = await completeOnboardingSetup(resolvedCommand, collectionRoots, installEvents, io);
         writeOnboardSingleRepoResultJson(ctx, {
@@ -141,25 +157,27 @@ async function runMultiRepoOnboard(command, io, worktrees) {
         fetchImpl: io.fetch,
     });
     const results = run.outcomes.map((outcome) => worktreeSyncRow(outcome, run));
+    if (!command.json)
+        writeMultiRepoSyncReport(io, command, run, results);
+    return { ok: run.ok, results, codex_sessions: run.summary };
+}
+function writeMultiRepoSyncReport(io, command, run, results) {
     const collectionRunStatus = attributedSyncRunStatus(run);
-    if (!command.json) {
-        for (const [index, outcome] of run.outcomes.entries()) {
-            const row = results[index];
-            if (!row)
-                continue;
-            const uploaded = outcome.sync.status === "uploaded";
-            writeLine(uploaded ? io.stdout : io.stderr, `${uploaded ? "SYNCED" : "BLOCKED"} ${row["repo_label"]}/${row["worktree_label"]} (${row["branch"]}) head:${shortSha(outcome.sync.head_sha ?? outcome.worktree.head_sha)} ${outcome.sync.status} objects:${outcome.sync.raw_evidence_uploaded_object_count} chunks:${outcome.sync.raw_evidence_uploaded_chunk_count} reused:${outcome.sync.raw_evidence_reused_count} failed:${outcome.sync.raw_evidence_failed_count} sessions:${row["attributed_session_count"]}${row["failure_reason"] ? ` reason:${row["failure_reason"]}` : ""}`);
-        }
-        writeLine(io.stdout, "4/5 Parent worktree sync complete.");
-        writeLine(io.stdout, `Uploaded: ${results.filter((row) => row["upload_status"] === "uploaded").length}/${results.length}`);
-        writeAgentSessionSummary(io, run.summary);
-        if (run.ok) {
-            writeLine(io.stdout, "Live sync receipts complete; verifying all-history Codex and Claude backfill.");
-        }
-        else {
-            writeLine(io.stderr, `BLOCKED: Tower collection is ${collectionRunStatus}; retry until every eligible session has a durable receipt or explicit terminal reason.`);
-        }
-        writeLine(io.stdout, `Open: ${command.dashboardUrl}/my-work`);
+    for (const [index, outcome] of run.outcomes.entries()) {
+        const row = results[index];
+        if (!row)
+            continue;
+        const uploaded = outcome.sync.status === "uploaded";
+        writeLine(uploaded ? io.stdout : io.stderr, `${uploaded ? "SYNCED" : "BLOCKED"} ${row["repo_label"]}/${row["worktree_label"]} (${row["branch"]}) head:${shortSha(outcome.sync.head_sha ?? outcome.worktree.head_sha)} ${outcome.sync.status} objects:${outcome.sync.raw_evidence_uploaded_object_count} chunks:${outcome.sync.raw_evidence_uploaded_chunk_count} reused:${outcome.sync.raw_evidence_reused_count} failed:${outcome.sync.raw_evidence_failed_count} sessions:${row["attributed_session_count"]}${row["failure_reason"] ? ` reason:${row["failure_reason"]}` : ""}`);
     }
-    return { ok: run.ok, results, codex_sessions: run.summary };
+    writeLine(io.stdout, "4/5 Parent worktree sync complete.");
+    writeLine(io.stdout, `Uploaded: ${results.filter((row) => row["upload_status"] === "uploaded").length}/${results.length}`);
+    writeAgentSessionSummary(io, run.summary);
+    if (run.ok) {
+        writeLine(io.stdout, "Live sync receipts complete; verifying all-history Codex and Claude backfill.");
+    }
+    else {
+        writeLine(io.stderr, `BLOCKED: Tower collection is ${collectionRunStatus}; retry until every eligible session has a durable receipt or explicit terminal reason.`);
+    }
+    writeLine(io.stdout, `Open: ${command.dashboardUrl}/my-work`);
 }

package/dist/commands/onboard.js

@@ -16,9 +16,7 @@ export async function runOnboard(command, io) {
     let install = null;
     let pair = null;
     let rootsResult = null;
-    // `sync` has to survive a throw from inside either flow function, so it is
-    // mutated through this holder rather than returned — a return only happens
-    // on the success path, and the failure path needs the value too.
+    // Both failure paths need the last sync value, even when a flow throws.
     const syncHolder = {
         current: null,
     };
@@ -30,12 +28,7 @@ export async function runOnboard(command, io) {
         const claimedOwnerEmail = await resolveOnboardEmail(roots.resolvedCommand, roots.collectionRoots, roots.existingConfig, io);
         install = await installOnboardConfig(command, roots.resolvedRoots, installEvents, io);
         pair = await pairForOnboarding(command, { primaryRoot: roots.primaryRoot, claimedOwnerEmail }, installEvents, io);
-        const worktrees = await discoverCommandWorktrees(roots.collectionRoots, {
-            maxDepth: command.maxDepth,
-            maxRepos: command.maxRepos,
-            homeDir: command.homeDir,
-            allowEmpty: true,
-        }, io);
+        const worktrees = await discoverOnboardWorktrees(command, roots, io);
         const ctx = {
             command,
             resolvedCommand: roots.resolvedCommand,
@@ -59,4 +52,13 @@ export async function runOnboard(command, io) {
     catch (error) {
         return await handleOnboardFailure(error, command, rootsResult, install, pair, syncHolder.current, installEvents, io);
     }
+}
+async function discoverOnboardWorktrees(command, roots, io) {
+    const worktrees = await discoverCommandWorktrees(roots.collectionRoots, {
+        maxDepth: command.maxDepth,
+        maxRepos: command.maxRepos,
+        homeDir: command.homeDir,
+        allowEmpty: true,
+    }, io);
+    return worktrees;
 }

package/dist/commands/ops-render-memory.js

@@ -49,6 +49,16 @@ export function renderMemoryUsage(memory, dim) {
             return leftOrphan - rightOrphan;
         return agentSaves(right.counts) - agentSaves(left.counts);
     });
+    appendMemoryPeople(lines, ranked, days, nameWidth, dim);
+    if (memory.truncated) {
+        lines.push(dim("  this read stopped at its page cap, so every number above is a FLOOR — it can understate use and never invent it"));
+    }
+    if (memory.searches?.counted === false) {
+        lines.push(dim(`  searches are not counted (${memory.searches.reason ?? "no ledger"}): nothing in Tower records one, so this is saves only`));
+    }
+    return lines;
+}
+function appendMemoryPeople(lines, ranked, days, nameWidth, dim) {
     for (const person of ranked) {
         const byDay = new Map((person.days ?? []).map((entry) => [entry.day ?? "", entry]));
         const cells = days
@@ -66,13 +76,6 @@ export function renderMemoryUsage(memory, dim) {
             `${String(counts.import ?? 0).padStart(5)}`;
         lines.push(agentSaves(counts) > 0 ? row : dim(row));
     }
-    if (memory.truncated) {
-        lines.push(dim("  this read stopped at its page cap, so every number above is a FLOOR — it can understate use and never invent it"));
-    }
-    if (memory.searches?.counted === false) {
-        lines.push(dim(`  searches are not counted (${memory.searches.reason ?? "no ledger"}): nothing in Tower records one, so this is saves only`));
-    }
-    return lines;
 }
 /**
  * The hook half: one line per machine, the server's own words.

package/dist/commands/ops-render.js

@@ -102,36 +102,7 @@ options = {}) {
         .join(" · ");
     lines.push(`PIPELINES  ${rows.length} job${rows.length === 1 ? "" : "s"}${summary ? ` · ${summary}` : ""}`);
     lines.push("");
-    const idWidth = Math.max(4, ...rows.map((row) => (row.id ?? "").length));
-    for (const row of rows) {
-        const verdict = verdictWord(row.verdict).padEnd(6);
-        const id = (row.id ?? "?").padEnd(idWidth);
-        // BLI-3723: a row that has no age BY DESIGN says `n/a`, never `—`. The two
-        // look alike and mean opposite things — `—` is "the table is empty".
-        const age = (row.ageAbsence ? "n/a" : ageWord(row.ageHours)).padStart(7);
-        // BLI-3722: name the device this age belongs to right in the row — a bare
-        // `STALE collector-fleet 11h` was already misread once (BLI-3699) as "the
-        // fleet", not "one machine in it", and the name is otherwise buried in
-        // `detail` below.
-        // BLI-4057 generalised it from `stale` alone: `memory-hooks` names the
-        // machine whose hooks stopped and reads `failing`, because nothing about
-        // it is late. A row that took the trouble to name a device is naming it
-        // for the reader, whatever word it printed beside it.
-        const staleName = row.staleDeviceName ? ` ${dim(`(${row.staleDeviceName})`)}` : "";
-        lines.push(`${verdict} ${id}  ${age}${staleName}  ${dim(intervalWord(row))}`);
-        if (row.verdict !== "healthy") {
-            // The absence of an age is explained BEFORE the detail, because it is
-            // the first thing a reader's eye stopped on.
-            if (row.ageAbsence)
-                lines.push(dim(`       no age: ${row.ageAbsence}`));
-            if (row.detail)
-                lines.push(dim(`       ${row.detail}`));
-            if (row.caveat)
-                lines.push(dim(`       note: ${row.caveat}`));
-            if (row.configFile)
-                lines.push(dim(`       scheduled by ${row.configFile} (${row.cron ?? "?"})`));
-        }
-    }
+    appendPipelineRows(lines, rows, dim);
     if (payload.fleet)
         lines.push(...renderFleet(payload.fleet, dim));
     if (payload.coverage) {
@@ -163,6 +134,38 @@ options = {}) {
     }
     return lines;
 }
+function appendPipelineRows(lines, rows, dim) {
+    const idWidth = Math.max(4, ...rows.map((row) => (row.id ?? "").length));
+    for (const row of rows) {
+        const verdict = verdictWord(row.verdict).padEnd(6);
+        const id = (row.id ?? "?").padEnd(idWidth);
+        // BLI-3723: a row that has no age BY DESIGN says `n/a`, never `—`. The two
+        // look alike and mean opposite things — `—` is "the table is empty".
+        const age = (row.ageAbsence ? "n/a" : ageWord(row.ageHours)).padStart(7);
+        // BLI-3722: name the device this age belongs to right in the row — a bare
+        // `STALE collector-fleet 11h` was already misread once (BLI-3699) as "the
+        // fleet", not "one machine in it", and the name is otherwise buried in
+        // `detail` below.
+        // BLI-4057 generalised it from `stale` alone: `memory-hooks` names the
+        // machine whose hooks stopped and reads `failing`, because nothing about
+        // it is late. A row that took the trouble to name a device is naming it
+        // for the reader, whatever word it printed beside it.
+        const staleName = row.staleDeviceName ? ` ${dim(`(${row.staleDeviceName})`)}` : "";
+        lines.push(`${verdict} ${id}  ${age}${staleName}  ${dim(intervalWord(row))}`);
+        if (row.verdict !== "healthy") {
+            // The absence of an age is explained BEFORE the detail, because it is
+            // the first thing a reader's eye stopped on.
+            if (row.ageAbsence)
+                lines.push(dim(`       no age: ${row.ageAbsence}`));
+            if (row.detail)
+                lines.push(dim(`       ${row.detail}`));
+            if (row.caveat)
+                lines.push(dim(`       note: ${row.caveat}`));
+            if (row.configFile)
+                lines.push(dim(`       scheduled by ${row.configFile} (${row.cron ?? "?"})`));
+        }
+    }
+}
 /**
  * The laptops. Red first, because a person reading this at 9am should not have
  * to scroll past nine healthy machines to find the dead one.

package/dist/commands/ops.js

@@ -170,6 +170,9 @@ function writeHumanOpsStatus(command, io, payload, memory, models, turns, toolRo
         for (const line of memory.experience.lines)
             writeLine(io.stdout, `  ${line}`);
     }
+    writeOptionalOpsSections(io, memory, models, turns, toolRouter);
+}
+function writeOptionalOpsSections(io, memory, models, turns, toolRouter) {
     if (models) {
         writeLine(io.stdout, "");
         if (models.lines.length > 0) {