@bli-cockpit/cli 0.2.28 → 0.2.30

package/dist/commands/backfill.js

@@ -1163,6 +1163,13 @@ async function syncBackfillBatch(options) {
         })),
         claudeAttributionScan: options.claudeAttribution ?? undefined,
         rawEvidenceBudget: options.rawEvidenceBudget,
+        // `cockpit backfill` is only ever an operator asking — by hand, through
+        // onboarding, through doctor, or by running the retry command Cockpit
+        // printed. The delivery-backoff window is the scheduler's cadence, so it
+        // does not gate this pass: honouring it here made the retry that follows a
+        // failed commit a 15-minute no-op that reported
+        // `durable_session_pointer_missing` and never named the hold (BLI-3118).
+        evidenceDeliveryMode: "operator_retry",
         fetch: options.fetchImpl,
     };
     try {

package/dist/commands/cli-io.js

@@ -0,0 +1,92 @@
+import { createCapturedExecRunner, createInteractiveExecRunner, } from "../process-runner.js";
+export function writeLine(stream, text) {
+    stream.write(`${text}\n`);
+}
+/** Writes text through unchanged, adding only the trailing newline it lacks. */
+export function writeRaw(stream, text) {
+    if (!text)
+        return;
+    stream.write(text);
+    if (!text.endsWith("\n"))
+        stream.write("\n");
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function writeExecOutput(io, result, options) {
+    if (options.stdout)
+        writeRaw(io.stdout, result.stdout);
+    if (options.stderr)
+        writeRaw(io.stderr, result.stderr);
+}
+export 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.
+ */
+export 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);
+    });
+}
+/** Enter means yes: only an explicit `n`/`no` declines. */
+export function yesByDefault(raw) {
+    const answer = raw.trim().split(/\s+/u)[0]?.toLowerCase() ?? "";
+    return answer !== "n" && answer !== "no";
+}
+/** Collects what a nested command writes instead of letting it reach the user. */
+export function bufferedWritable(chunks) {
+    return {
+        write(chunk) {
+            chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+            return true;
+        },
+    };
+}
+export function replayCaptured(stream, chunks) {
+    for (const chunk of chunks)
+        stream.write(chunk);
+}
+/** Captured `--json` stdout, parsed when it is JSON and handed back raw when it is not. */
+export function parseCapturedJson(chunks) {
+    const text = chunks.join("").trim();
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+export function defaultExec() {
+    return createCapturedExecRunner();
+}
+export function defaultInteractiveExec() {
+    return createInteractiveExecRunner();
+}
+export 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(),
+    };
+}

package/dist/commands/collection-report.js

@@ -0,0 +1,139 @@
+import { writeLine } from "./cli-io.js";
+import { matchesLiveSyncWorktree, } from "./session-sync.js";
+export function shortSha(value) {
+    return value ? value.slice(0, 12) : "unknown";
+}
+export function displayTicketId(ticketId) {
+    return ticketId ?? "none (general work)";
+}
+export 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";
+}
+function sourceFunnelLine(label, counts) {
+    // Same counters, plain words. Every counter still prints, including the ones
+    // that are zero: a funnel that hides a bucket cannot show where sessions go.
+    const readFailures = counts.read_failures > 0 ? `, ${counts.read_failures} could not be read` : "";
+    return `${label} sessions: ${counts.attributed} matched to a repo, ${counts.attributed_fallback} by best guess, ${counts.ambiguous} unclear which repo, ${counts.unattributed} could not be matched, ${counts.stale} too old, ${counts.skipped} skipped${readFailures}`;
+}
+function attributionReportLine(summary) {
+    // The parenthesised value is the machine reason label and never changes.
+    return summary.report_posted
+        ? "Session report: saved"
+        : `Session 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).
+ */
+export 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(`${claude.sidecars_skipped} helper sessions skipped`);
+    if (claude.sidecars_capped)
+        parts.push(`${claude.sidecars_capped} helper sessions cut short`);
+    if (claude.sidecars_failed)
+        parts.push(`${claude.sidecars_failed} helper sessions could not be read`);
+    if (claude.mains_oversized)
+        parts.push(`${claude.mains_oversized} sessions too big`);
+    if (claude.oversized_lines_skipped)
+        parts.push(`${claude.oversized_lines_skipped} oversized lines skipped`);
+    if (claude.project_dirs_skipped)
+        parts.push(`${claude.project_dirs_skipped} folders skipped`);
+    if (claude.sessions_schema_drift)
+        parts.push(`${claude.sessions_schema_drift} sessions in an unexpected format`);
+    if (claude.growth_damped)
+        parts.push(`${claude.growth_damped} fast-growing sessions slowed down`);
+    if (claude.first_run_backfill)
+        parts.push("first run, catching up on history");
+    if (summary.files_deferred_byte_budget)
+        parts.push(`${summary.files_deferred_byte_budget} files held back, size limit`);
+    if (summary.files_deferred_object_budget)
+        parts.push(`${summary.files_deferred_object_budget} files held back, file-count limit`);
+    return parts.length > 0 ? `Claude problems: ${parts.join(", ")}` : null;
+}
+export function rawEvidenceSyncLine(sync) {
+    // The reason lists themselves are machine labels and stay verbatim.
+    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
+        ? `, ${sync.raw_evidence_delivery_held_count} waiting`
+        : "";
+    const stuck = sync.raw_evidence_stuck_object_count > 0
+        ? `, ${sync.raw_evidence_stuck_object_count} stuck (${sync.raw_evidence_max_delivery_attempts} tries since ${sync.raw_evidence_oldest_delivery_failure_at ?? "unknown"})`
+        : "";
+    return `Files: ${sync.raw_evidence_uploaded_object_count} uploaded, ${sync.raw_evidence_reused_count} already there, ${sync.raw_evidence_failed_count} failed${held}${stuck}${failures}${retries}`;
+}
+export function cursorStatusLine(sync) {
+    return `Tracked so far: ${sync.cursor_tracked_object_count} uploaded item(s)`;
+}
+/**
+ * One line that cannot say "fine" while an object has never been accepted.
+ * Named reasons, worst attempt count, and the date it started.
+ */
+export 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"})`;
+}
+/** The `--json` row for one synced worktree, shared by onboard and sync. */
+export 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,
+    };
+}
+/** Green only when the whole run is green; an accepted upload with partial collection is `partial`. */
+export function attributedSyncRunStatus(run) {
+    if (run.ok)
+        return "uploaded";
+    return run.outcomes.every((outcome) => outcome.sync.status === "uploaded")
+        ? "partial"
+        : "spooled";
+}

package/dist/commands/collection-roots.js

@@ -0,0 +1,153 @@
+/**
+ * The folders this machine is allowed to collect from: resolving them, saving
+ * them, and reading them back to prove setup actually worked.
+ *
+ * Widening the boundary is a consent decision a person makes, never a fix an
+ * agent applies — so everything here either asks or reports, and the read-back
+ * fails loudly rather than handing over a machine that will never collect.
+ * Split out of commands/local.ts (BLI-3104); moved verbatim.
+ */
+import os from "node:os";
+import path from "node:path";
+import { stat } from "node:fs/promises";
+import { isInteractiveStdin, readLine, writeLine, yesByDefault } from "./cli-io.js";
+import { COLLECTION_ROOT_REQUIRED, resolveOnboardingRoots, } from "../onboarding-roots.js";
+import { getCollectorRuntimePaths, installLocalCollector, readLocalCollectorConfig, } from "../local-state.js";
+import { collectionRootPathAliases } from "../repo-identity.js";
+import { normalizeCollectionRoots } from "../root-normalization.js";
+export function onboardingRootPrompt(io) {
+    return {
+        confirm: async (message) => yesByDefault(await readLine(io, message)),
+        input: (message) => readLine(io, message),
+        message: (message) => writeLine(io.stdout, message),
+    };
+}
+export 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({
+        homeDir: command.homeDir,
+        explicitRoots: command.collectionRoots ?? (command.repoRoot ? [command.repoRoot] : []),
+        config: existingConfig,
+        interactive,
+        allowHomeRoot: command.allowHomeRoot,
+        prompt: interactive ? onboardingRootPrompt(io) : undefined,
+    });
+    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,
+    };
+}
+export async function persistOnboardingRootConfig(command, resolution) {
+    const result = await installLocalCollector({
+        homeDir: command.homeDir,
+        repoRoot: resolution.primaryRoot,
+        repoRoots: resolution.collectionRoots,
+        replaceRepoRoots: resolution.replaceRepoRoots,
+        dashboardUrl: command.dashboardUrl,
+        deviceName: command.deviceName,
+    });
+    await assertCollectionRootPersisted(command.homeDir);
+    return result;
+}
+/**
+ * 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.
+ */
+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;
+}
+/**
+ * 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.
+ */
+export async function collectionRootConsentAliases(roots) {
+    return normalizeCollectionRoots(await collectionRootPathAliases(roots));
+}
+// 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);
+}

package/dist/commands/doctor.js

@@ -175,7 +175,7 @@ async function readAuthState(context) {
     if (session?.session_state === "valid" &&
         typeof session.device_token === "string" &&
         session.device_token) {
-        return ok("authed", "device_token_present", "device token present");
+        return ok("authed", "device_token_present", "this machine is signed in");
     }
     return hardStop("authed", "pairing_required", [
         "device is not signed in.",
@@ -216,12 +216,12 @@ async function checkAutostartState(context) {
         exec,
     });
     if (result.status === "loaded") {
-        return ok("autostart-alive", "already_installed", "autostart scheduler loaded");
+        return ok("autostart-alive", "already_installed", "background sync is running");
     }
     if (result.status === "unsupported") {
         return skipped("autostart-alive", "unsupported", result.message ?? "unsupported");
     }
-    return needsFix("autostart-alive", result.status === "not_loaded" ? "not_loaded" : "absent", "autostart is not loaded");
+    return needsFix("autostart-alive", result.status === "not_loaded" ? "not_loaded" : "absent", "background sync is not running");
 }
 async function fixAutostartState(context) {
     const exec = context.io.exec;
@@ -241,7 +241,7 @@ async function fixAutostartState(context) {
     if (result.loaded === false) {
         return fail("autostart-alive", "autostart_load_failed", result.message ?? "operating-system scheduler load failed");
     }
-    return ok("autostart-alive", "installed", "autostart installed and loaded");
+    return ok("autostart-alive", "installed", "background sync installed and running");
 }
 /**
  * Pure so it can be unit-tested without touching the real machine's home
@@ -261,10 +261,10 @@ export function backfillCompletionStepState(marker, roots) {
     }
     const oversized = marker?.oversized_skips;
     if (oversized && oversized.count > 0) {
-        return ok("backfill-complete", "complete_with_oversized_skips", `backfill completion covers the current saved roots and both session sources ` +
-            `(complete_with_oversized_skips · ${oversized.count} file${oversized.count === 1 ? "" : "s"} over the upload cap)`);
+        return ok("backfill-complete", "complete_with_oversized_skips", `caught up on old Codex and Claude sessions in every saved folder ` +
+            `(complete_with_oversized_skips · ${oversized.count} file${oversized.count === 1 ? "" : "s"} too big to upload)`);
     }
-    return ok("backfill-complete", "complete", "backfill completion covers the current saved roots and both session sources");
+    return ok("backfill-complete", "complete", "caught up on old Codex and Claude sessions in every saved folder");
 }
 async function checkBackfillState(context) {
     const paths = getCollectorRuntimePaths();
@@ -275,10 +275,10 @@ async function checkBackfillState(context) {
         return covered;
     const lock = await inspectBackfillLock(paths);
     if (lock.held) {
-        return needsFix("backfill-complete", "backfill_already_running", `backfill completion is not yet proven; another run holds the lock since ${lock.held_since ?? "unknown"}`);
+        return needsFix("backfill-complete", "backfill_already_running", `another catch-up run is still going, and this one has not finished yet (running since ${lock.held_since ?? "unknown"})`);
     }
     const cursor = await readBackfillCursor(paths);
-    return needsFix("backfill-complete", cursor.updated_at ? "partial" : "never_run", "backfill completion marker missing");
+    return needsFix("backfill-complete", cursor.updated_at ? "partial" : "never_run", "the catch-up over your old sessions has not finished");
 }
 async function fixBackfillState(context) {
     const capture = capturedIo(context.io, !context.command.json);
@@ -308,20 +308,20 @@ async function fixBackfillState(context) {
 }
 async function checkGcState(context) {
     if (context.io.env["COCKPIT_DISABLE_GC"] === "1") {
-        return skipped("gc-checked", "skipped_disabled", "raw-evidence GC disabled");
+        return skipped("gc-checked", "skipped_disabled", "cleanup is switched off");
     }
     const paths = getCollectorRuntimePaths();
     const marker = path.join(paths.state_dir, ".last-raw-evidence-gc");
     const info = await fs.stat(marker).catch(() => null);
     if (info && Date.now() - info.mtimeMs < GC_MIN_INTERVAL_MS) {
-        return skipped("gc-checked", "skipped_throttled", "raw-evidence GC ran within 24h");
+        return skipped("gc-checked", "skipped_throttled", "cleanup already ran today");
     }
-    return needsFix("gc-checked", "due", "raw-evidence GC is due");
+    return needsFix("gc-checked", "due", "cleanup is due");
 }
 async function fixGcState(context) {
     const result = await runRawEvidenceLocalGc(getCollectorRuntimePaths(), context.io.env);
     if (result.skipped) {
-        return skipped("gc-checked", "skipped_throttled", "raw-evidence GC skipped");
+        return skipped("gc-checked", "skipped_throttled", "cleanup already ran today");
     }
     if (result.removed_dirs === 0) {
         return ok("gc-checked", "nothing_eligible", rawEvidenceGcSummary(result));
@@ -422,8 +422,8 @@ async function fixSyncState(context) {
         if (result.code !== 0) {
             const draining = syncBacklogDrainingVerdict(parsed);
             if (draining) {
-                return needsFix("sync-fresh", "backlog_draining", `${repoRoot}: raw-evidence backlog is still draining (${draining.remainingObjects} ` +
-                    `object${draining.remainingObjects === 1 ? "" : "s"} deferred this tick); ` +
+                return needsFix("sync-fresh", "backlog_draining", `${repoRoot}: still catching up (${draining.remainingObjects} ` +
+                    `file${draining.remainingObjects === 1 ? "" : "s"} left for later this run); ` +
                     "rerun `cockpit sync` to continue");
             }
             return fail("sync-fresh", status ?? "sync_failed", `sync failed for ${repoRoot}`);
@@ -464,9 +464,11 @@ function writeDoctorOutput(command, io, rows) {
         return;
     }
     writeLine(io.stdout, command.dryRun ? "Cockpit doctor dry-run" : "Cockpit doctor");
-    writeLine(io.stdout, "state step                 code                    result");
+    // The machine `code` stays in `--json`; a human reading the table wants the
+    // sentence, not the label (BLI-3194).
+    writeLine(io.stdout, "state step                 result");
     for (const row of rows) {
-        writeLine(io.stdout, `${doctorMark(row)} ${row.id.padEnd(20)} ${row.code.padEnd(23)} ${oneLine(row.message)}`);
+        writeLine(io.stdout, `${doctorMark(row)} ${row.id.padEnd(20)} ${oneLine(row.message)}`);
     }
     const explanations = rows.filter((row) => (row.hardStop || row.status === "fail") && row.message.includes("\n"));
     for (const row of explanations) {