@bli-cockpit/cli 0.2.29 → 0.2.30

package/README.md

@@ -13,9 +13,9 @@ added <packages> in <seconds>s
 
 ```bash
 $ cockpit do-everything
-Cockpit harvest onboarding
+Setting up Cockpit
 Dashboard: https://bli-cockpit-dashboard.vercel.app
-Ticket: general ambient
+Ticket: none (general work)
 What's your @buildlaunchiterate.ca email? (press enter to skip): ian@buildlaunchiterate.ca
 Signing in as ian@buildlaunchiterate.ca.
 Code sent; valid 1h, resend in 60s by rerunning this command.
@@ -28,7 +28,7 @@ What you can do:
 Code: 482913
 Signed in as ian@buildlaunchiterate.ca.
 2/5 Device paired.
-PASS: Cockpit collector is ready for harvest.
+PASS: Cockpit is set up and collecting.
 You're live.
 Dashboard: https://bli-cockpit-dashboard.vercel.app/my-work
 Next: cockpit status
@@ -36,9 +36,15 @@ Next: cockpit status
 
 ```bash
 $ cockpit status
-Install: ready
-Auth: paired
-Upload state: ready
+Cockpit status
+Installed: yes
+Signed in: yes
+Ticket: none (general work)
+Last collected: recently
+Uploads: ready
+Waiting to upload: 0
+Old sessions: done
+Stuck files: none
 ```
 
 The OTP proves you own an approved BLI mailbox. The JWT is used once to register this device and is never saved; the durable local credential remains the existing Cockpit device token.
@@ -47,13 +53,14 @@ The OTP proves you own an approved BLI mailbox. The JWT is used once to register
 
 On a blank Mac or Windows PC, `npm i -g @bli-cockpit/cli && cockpit do-everything` is enough to sign in, choose roots, and converge the machine. `onboard` remains the named setup subset, and the rest exist for recovery and maintenance.
 
-The core collection contract is the same on Apple Silicon macOS and native
-Windows: every eligible Codex and Claude session attributable to an approved
-root is collected, redacted before ingest, and either uploaded with a durable
-receipt or surfaced with an explicit ambiguity, skip, or retry reason. A green
-machine must not hide silently missing sessions. This support claim remains
-release-gated: the packed candidate must pass normal-user canaries on both host
-families before its exact version is promoted to npm `latest`.
+Cockpit works the same way on an Apple Silicon Mac and on a normal Windows
+PC. Every Codex and Claude session in a folder you have approved is collected,
+stripped of anything sensitive before it leaves your machine, and then either
+uploaded with a receipt or listed with the exact reason it was not. If a
+session is missing, Cockpit says so — a green screen never hides one.
+
+We only publish a version to npm after it has been tested end-to-end, as a
+normal user, on both macOS and Windows.
 
 | Command | What it does | Why it exists / why this name |
 |---|---|---|
@@ -171,11 +178,11 @@ Local files:
 
 - `~/.config/bli-cockpit/config.json`: dashboard URL, device label, collection roots.
 - `~/.config/bli-cockpit/session.json`: paired device token and owner metadata.
-- `~/.local/state/bli-cockpit/spool/`: safe retry records.
+- `~/.local/state/bli-cockpit/spool/`: uploads waiting to be retried.
 - `~/.local/state/bli-cockpit/spool/install-events/`: private atomic collector
   health receipts waiting for authenticated delivery. Receipts contain only
   sanitized operation metadata, never command output or transcript content.
-- `~/.local/state/bli-cockpit/cursors/`: upload/backfill cursors, no raw content.
+- `~/.local/state/bli-cockpit/cursors/`: bookmarks for how far uploading has got, no raw content.
 - `.codex-autorunner/contextspace/active_context.md`: current work context inside a repo.
 
 Remote data:

package/dist/commands/collection-report.js

@@ -4,7 +4,7 @@ export function shortSha(value) {
     return value ? value.slice(0, 12) : "unknown";
 }
 export function displayTicketId(ticketId) {
-    return ticketId ?? "general ambient";
+    return ticketId ?? "none (general work)";
 }
 export function displayWorkLabel(status) {
     if (status.work_label && status.work_id)
@@ -12,13 +12,16 @@ export function displayWorkLabel(status) {
     return status.work_label ?? status.work_id ?? "no active work context";
 }
 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}`;
+    // 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
-        ? "Attribution report: recorded"
-        : `Attribution report: skipped (${summary.report_reason})`;
+        ? "Session report: saved"
+        : `Session report: skipped (${summary.report_reason})`;
 }
 /**
  * One funnel line per source, an anomaly diagnostics line only when something
@@ -41,30 +44,31 @@ function claudeDiagnosticsLine(summary) {
     const claude = summary.claude;
     const parts = [];
     if (claude.sidecars_skipped)
-        parts.push(`sidecars_skipped ${claude.sidecars_skipped}`);
+        parts.push(`${claude.sidecars_skipped} helper sessions skipped`);
     if (claude.sidecars_capped)
-        parts.push(`sidecars_capped ${claude.sidecars_capped}`);
+        parts.push(`${claude.sidecars_capped} helper sessions cut short`);
     if (claude.sidecars_failed)
-        parts.push(`sidecars_failed ${claude.sidecars_failed}`);
+        parts.push(`${claude.sidecars_failed} helper sessions could not be read`);
     if (claude.mains_oversized)
-        parts.push(`mains_oversized ${claude.mains_oversized}`);
+        parts.push(`${claude.mains_oversized} sessions too big`);
     if (claude.oversized_lines_skipped)
-        parts.push(`oversized_lines_skipped ${claude.oversized_lines_skipped}`);
+        parts.push(`${claude.oversized_lines_skipped} oversized lines skipped`);
     if (claude.project_dirs_skipped)
-        parts.push(`project_dirs_skipped ${claude.project_dirs_skipped}`);
+        parts.push(`${claude.project_dirs_skipped} folders skipped`);
     if (claude.sessions_schema_drift)
-        parts.push(`schema_drift ${claude.sessions_schema_drift}`);
+        parts.push(`${claude.sessions_schema_drift} sessions in an unexpected format`);
     if (claude.growth_damped)
-        parts.push(`growth_damped ${claude.growth_damped}`);
+        parts.push(`${claude.growth_damped} fast-growing sessions slowed down`);
     if (claude.first_run_backfill)
-        parts.push("first_run_backfill");
+        parts.push("first run, catching up on history");
     if (summary.files_deferred_byte_budget)
-        parts.push(`deferred_byte_budget ${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(`deferred_object_budget ${summary.files_deferred_object_budget}`);
-    return parts.length > 0 ? `Claude diagnostics: ${parts.join(", ")}` : null;
+        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(",")}`
         : "";
@@ -75,15 +79,15 @@ export function rawEvidenceSyncLine(sync) {
     // 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}`
+        ? `, ${sync.raw_evidence_delivery_held_count} waiting`
         : "";
     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"})`
+        ? `, ${sync.raw_evidence_stuck_object_count} stuck (${sync.raw_evidence_max_delivery_attempts} tries 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}`;
+    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 `Cursor: ${sync.cursor_tracked_object_count} durable object(s) tracked`;
+    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.

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) {

package/dist/commands/local-help.js

@@ -64,7 +64,7 @@ function localSubcommandHelp(command) {
                 "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.",
+                "Codex and Claude backfill for the saved roots, and then tells you it is working.",
                 "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}).`,
@@ -107,10 +107,10 @@ function localSubcommandHelp(command) {
             [
                 "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.",
+                "Gets this machine fully set up, whether it is brand new, already set up, or handed down: latest CLI, sign-in and collection-root recovery when needed, saved folders, background sync, catching up on old sessions, cleaning up old files, and one fresh upload.",
                 "`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.",
+                "Maintainers only: use `--update-tag next` so self-update and re-exec stay on the prerelease candidate.",
+                "--dry-run shows what it would do without changing anything.",
             ],
         ],
         [
@@ -144,9 +144,9 @@ function localSubcommandHelp(command) {
             [
                 "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.",
+                "Starts collecting your work in the background. If you point it at a parent folder it covers every repo inside.",
                 "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 --clear-ticket to go back to collecting general work with no ticket attached.",
                 "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.",
@@ -158,7 +158,7 @@ function localSubcommandHelp(command) {
             [
                 "Usage: cockpit sync [--workspace <path>] [--dashboard-url <url>] [--json]",
                 "",
-                "Uploads latest local ambient envelope(s), or spools safe retries if blocked.",
+                "Uploads your latest collected work. If it cannot reach Cockpit it saves a retry and tries again later.",
                 "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",
@@ -166,7 +166,7 @@ function localSubcommandHelp(command) {
                 "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.",
+                "New repos start being collected automatically, with no ticket attached.",
                 "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",
@@ -179,7 +179,7 @@ function localSubcommandHelp(command) {
             [
                 "Usage: cockpit analyze [--workspace <path>] [--dashboard-url <url>] [--json]",
                 "",
-                "Uploads the latest local ambient evidence, then queues one analysis job.",
+                "Uploads your latest collected work, then asks Cockpit to analyse it.",
                 "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.",

package/dist/commands/local.js

@@ -306,9 +306,9 @@ function backgroundSyncLine(result) {
     return result.status;
 }
 function writeOnboardBanner(command, io) {
-    writeLine(io.stdout, "Cockpit harvest onboarding");
+    writeLine(io.stdout, "Setting up Cockpit");
     writeLine(io.stdout, `Dashboard: ${command.dashboardUrl}`);
-    writeLine(io.stdout, `Ticket: ${command.activeTicketId ?? "general ambient"}`);
+    writeLine(io.stdout, `Ticket: ${displayTicketId(command.activeTicketId)}`);
 }
 /**
  * Step 2 of onboarding: reuse the device session when it already belongs to
@@ -525,7 +525,7 @@ async function runOnboard(command, io) {
                 }, null, 2));
             }
             if (onboardOk && !command.json) {
-                writeLine(io.stdout, "PASS: Cockpit collector is ready for harvest.");
+                writeLine(io.stdout, "PASS: Cockpit is set up and collecting.");
                 writeOnboardLiveStatus(io, resolvedCommand, collectionRoots, {
                     pair,
                     status,
@@ -552,7 +552,7 @@ async function runOnboard(command, io) {
             writeLine(io.stdout, "3/5 Work context active.");
             writeLine(io.stdout, `Repo: ${context.repo}`);
             writeLine(io.stdout, `Branch: ${context.branch}`);
-            writeLine(io.stdout, `Ticket: ${context.active_ticket_id ?? "general ambient"}`);
+            writeLine(io.stdout, `Ticket: ${displayTicketId(context.active_ticket_id)}`);
             writeLine(io.stdout, `Context: ${context.work_context_id}`);
         }
         addInstallEvent(installEvents, "work_context", "ok");
@@ -638,9 +638,9 @@ async function runOnboard(command, io) {
             }, null, 2));
             return finish(onboardOk ? 0 : 1);
         }
-        writeLine(io.stdout, "4/5 Ambient metadata uploaded.");
+        writeLine(io.stdout, "4/5 Uploaded what you worked on.");
         writeLine(io.stdout, `HTTP: ${sync.http_status}`);
-        writeLine(io.stdout, `Facts: ${sync.event_count}`);
+        writeLine(io.stdout, `Things recorded: ${sync.event_count}`);
         writeLine(io.stdout, `Sources: ${sync.source_scan_count}`);
         writeLine(io.stdout, `Risk flags: ${sync.risk_flag_count}`);
         writeLine(io.stdout, `Raw evidence files: ${sync.raw_evidence_file_count}`);
@@ -656,7 +656,7 @@ async function runOnboard(command, io) {
             writeOnboardAutostartBlocker(io, autostart);
             return finish(1);
         }
-        writeLine(io.stdout, "PASS: Cockpit collector is ready for harvest.");
+        writeLine(io.stdout, "PASS: Cockpit is set up and collecting.");
         writeOnboardLiveStatus(io, resolvedCommand, collectionRoots, {
             pair,
             status,
@@ -839,7 +839,7 @@ function nextStepForOnboardBlocker(blocker, options = {}) {
         case "ticket_binding":
             return "Run `cockpit start --ticket <id>` when actual ticket work begins, then run `cockpit sync`.";
         case "device_pairing":
-            return "Approve from Ambient -> Collector approvals, or paste the pairing code there, then rerun `cockpit onboard`.";
+            return "Ask Edward to approve this machine in the dashboard under Ambient -> Collector approvals, then run `cockpit onboard` again.";
         case "network_or_ingest":
             return "Check dashboard URL/network, then run `cockpit sync --json` or rerun `cockpit onboard`.";
         case "install":
@@ -1125,7 +1125,7 @@ async function runSyncWithHealthReceipt(command, io) {
             }, null, 2));
         }
         else {
-            writeLine(io.stdout, "live sync paused during backfill");
+            writeLine(io.stdout, "Pausing normal sync while it catches up on old sessions.");
         }
         return {
             exitCode: 0,
@@ -1300,11 +1300,11 @@ async function runSyncLocked(command, io) {
         return syncResult(run);
     }
     if (run.ok) {
-        writeLine(io.stdout, "Cockpit ambient envelope uploaded.");
+        writeLine(io.stdout, "Cockpit uploaded this session.");
         writeLine(io.stdout, `Ticket: ${displayTicketId(result.ticket_id)}`);
         writeLine(io.stdout, `Context: ${result.work_context_id}`);
         writeLine(io.stdout, `Head: ${shortSha(result.head_sha)}`);
-        writeLine(io.stdout, `Facts: ${result.event_count}`);
+        writeLine(io.stdout, `Things recorded: ${result.event_count}`);
         writeLine(io.stdout, `Risk flags: ${result.risk_flag_count}`);
         writeLine(io.stdout, `Raw evidence files: ${result.raw_evidence_file_count}`);
         writeLine(io.stdout, rawEvidenceSyncLine(result));
@@ -1315,11 +1315,11 @@ async function runSyncLocked(command, io) {
         return syncResult(run);
     }
     if (result.status === "uploaded") {
-        writeLine(io.stderr, "Cockpit ambient upload was accepted, but session collection is partial; retry `cockpit sync`.");
+        writeLine(io.stderr, "Cockpit uploaded, but some sessions did not make it. Run `cockpit sync` again.");
         writeAgentSessionSummary(io, run.summary);
         return syncResult(run);
     }
-    writeLine(io.stderr, "Cockpit ambient upload failed; safe retry metadata was spooled.");
+    writeLine(io.stderr, "Cockpit could not upload. It saved a note to retry and will try again on the next sync.");
     writeLine(io.stderr, `Ticket: ${displayTicketId(result.ticket_id)}`);
     writeLine(io.stderr, `Failure: ${result.failure_reason}`);
     writeLine(io.stderr, `Retry: ${result.retry_command}`);
@@ -1419,7 +1419,7 @@ async function runAnalyze(command, io) {
         return 0;
     }
     replayCaptured(io.stderr, syncStderr);
-    writeLine(io.stdout, "Cockpit latest evidence uploaded.");
+    writeLine(io.stdout, "Cockpit uploaded your latest work.");
     writeLine(io.stdout, "Cockpit analysis queued.");
     if (jobId)
         writeLine(io.stdout, `Job: ${jobId}`);

package/dist/commands/public-root.js

@@ -15,7 +15,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.29");
+    writeLine(io?.stdout ?? process.stdout, "0.2.30");
     return 0;
   }
 

package/dist/commands/status.js

@@ -3,9 +3,11 @@
  * active work, upload state, retry backlog, and how far historical backfill
  * has got.
  *
- * Read-only. Split out of commands/local.ts (BLI-3104); moved verbatim, since
- * every line here is what an intern pastes into Slack when something looks
- * wrong.
+ * Read-only. Split out of commands/local.ts (BLI-3104). BLI-3194 rewrote the
+ * human block into plain English, because these lines are what an intern
+ * pastes into Slack when something looks wrong. The `--json` payload is the
+ * machine contract and is byte-for-byte unchanged — `status-json-shape.test.ts`
+ * holds it to that.
  */
 import { readdir, stat } from "node:fs/promises";
 import os from "node:os";
@@ -32,8 +34,8 @@ export async function runStatus(command, io) {
             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)}`);
+        writeLine(io.stdout, "Cockpit status — every repo below this folder");
+        writeLine(io.stdout, `Old sessions: ${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}`);
         }
@@ -44,24 +46,26 @@ export async function runStatus(command, io) {
         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)}`);
+    writeLine(io.stdout, "Cockpit status");
+    writeLine(io.stdout, `Installed: ${status.installed ? "yes" : "no"}`);
+    writeLine(io.stdout, `Signed in: ${signedInLine(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, `Last collected: ${lastCollectedLine(status.collector_freshness)}`);
+    writeLine(io.stdout, `Version: ${status.collector_version}`);
+    writeLine(io.stdout, `Uploads: ${uploadsLine(status.upload_state)}`);
+    writeLine(io.stdout, `Last upload tried: ${status.last_upload_attempt_at ?? "never"}`);
+    writeLine(io.stdout, `Last upload worked: ${status.last_upload_success_at ?? "never"}`);
+    // The failure reason itself is a machine label and prints verbatim: a status
+    // that hides why the last upload failed is the silent-success failure mode.
+    writeLine(io.stdout, `Last upload problem: ${status.last_upload_failure_reason ?? "none"}`);
+    writeLine(io.stdout, `Waiting to upload: ${status.pending_upload_count}`);
+    writeLine(io.stdout, `Health notes waiting to send: ${status.pending_health_receipt_count}`);
+    writeLine(io.stdout, `Last health note problem: ${status.last_health_receipt_failure_reason ?? "none"}`);
+    writeLine(io.stdout, `Old sessions: ${backfillCursorLine(backfillCursor)}`);
+    writeLine(io.stdout, `Stuck files: ${stuckEvidenceLine(status)}`);
     for (const detail of status.details)
         writeLine(io.stdout, `- ${detail}`);
     return 0;
@@ -122,11 +126,46 @@ function summarizeBackfillSource(source) {
 function backfillCursorLine(status) {
     switch (status.state) {
         case "done":
-            return `done (${status.completed_at ?? "completion marker present"})`;
+            return `done (${status.completed_at ?? "finished, no date recorded"})`;
         case "never_run":
-            return "never run";
+            return "not started yet";
         case "remaining":
-            return `${status.remaining_count} remaining`;
+            return `${status.remaining_count} still to catch up on`;
+    }
+}
+/** Plain words for the four session states; `--json` still gets the raw value. */
+function signedInLine(sessionState) {
+    switch (sessionState) {
+        case "valid":
+            return "yes";
+        case "expired":
+            return "no — the sign-in expired, run `cockpit login`";
+        case "missing":
+            return "no — run `cockpit login`";
+        case "unknown":
+            return "cannot tell";
+    }
+}
+function lastCollectedLine(freshness) {
+    switch (freshness) {
+        case "fresh":
+            return "recently";
+        case "stale":
+            return "a while ago";
+        case "missing":
+            return "never";
+    }
+}
+function uploadsLine(uploadState) {
+    switch (uploadState) {
+        case "ready":
+            return "ready";
+        case "retry_pending":
+            return "waiting to retry";
+        case "local_only_missing_auth":
+            return "staying on this machine — not signed in";
+        case "not_installed":
+            return "not set up yet — run `cockpit onboard`";
     }
 }
 async function countRemainingBackfillSessionFiles(homeDir, cursor) {

package/dist/raw-evidence-gc.js

@@ -68,7 +68,7 @@ export async function runRawEvidenceLocalGc(paths, env = process.env, now = new
     };
 }
 export function rawEvidenceGcSummary(result) {
-    return `raw-evidence GC: removed ${result.removed_dirs} dirs, freed ~${formatMb(result.freed_bytes)} MB`;
+    return `Cleaned up: removed ${result.removed_dirs} old folders, freed ~${formatMb(result.freed_bytes)} MB`;
 }
 /**
  * Collapse byte-identical staged packs down to one survivor.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.29",
+  "version": "0.2.30",
   "private": false,
   "type": "module",
   "bin": {