@bli-cockpit/cli 0.2.30 → 0.2.32

package/dist/autostart.js

@@ -131,6 +131,9 @@ export async function uninstallAutostartAgent(options) {
     if (!(await fileExists(plistPath))) {
         return { status: "absent", label: AUTOSTART_LABEL, plist_path: plistPath };
     }
+    // Same reasoning as the install path above: an agent that was never loaded
+    // makes unload fail harmlessly, and the plist is removed either way, so the
+    // error is deliberately ignored (BLI-3238).
     await options.exec("launchctl", ["unload", plistPath]).catch(() => undefined);
     await rm(plistPath, { force: true });
     return { status: "uninstalled", label: AUTOSTART_LABEL, plist_path: plistPath };

package/dist/backfill-lock.js

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { describeError } from "./health-detail.js";
 const BACKFILL_LOCK_FILENAME = "backfill.lock";
 const HEARTBEAT_INTERVAL_MS = 30_000;
 export const BACKFILL_LOCK_STALE_TAKEOVER_MS = 5 * 60_000;
@@ -65,10 +66,26 @@ async function tryExclusiveCreate(lockPath, token, now) {
         await handle.close();
         return true;
     }
-    catch {
+    catch (error) {
+        // Same trap as sync-lock: EEXIST means another backfill holds it, and
+        // anything else (permissions, full disk, read-only volume) is reported as
+        // the identical "already running" and would keep the historical sweep from
+        // ever starting, permanently and silently (BLI-3238).
+        if (!isBackfillLockHeldError(error)) {
+            console.error("[backfill-lock] could not create the lock file; reporting the lock as held", JSON.stringify({
+                reason: "backfill_lock_create_failed",
+                ...describeError(error),
+            }));
+        }
         return false;
     }
 }
+/** `wx` refusing because the lock exists — the ordinary contended case. */
+function isBackfillLockHeldError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        error.code === "EEXIST");
+}
 async function writeBackfillLock(lockPath, token, now) {
     await fs.writeFile(lockPath, serializeBackfillLock(token, now), {
         mode: 0o600,
@@ -103,6 +120,10 @@ async function readBackfillLockRecord(lockPath) {
         };
     }
     catch {
+        // Deliberately silent (BLI-3238), same reasoning as sync-lock's reader:
+        // this is the "is anyone holding it?" probe, and every way it can fail
+        // means "not held", which is the answer the caller acts on. The failing
+        // ACQUIRE above owns the reporting.
         return null;
     }
 }

package/dist/commands/backfill.js

@@ -1,8 +1,9 @@
-import { NO_UPLOAD_ATTEMPT_RECORDED, RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES } from "@bli-cockpit/telemetry-core";
+import { NO_UPLOAD_ATTEMPT_RECORDED, RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, notUploadableAttributionStateReason } from "@bli-cockpit/telemetry-core";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { describeError } from "../health-detail.js";
 import { scanAndAttributeClaudeSessions } from "../adapters/claude-attribution.js";
 import { defaultCodexSessionDirs, scanAndAttributeCodexSessions } from "../adapters/codex-attribution.js";
 import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET } from "../adapters/raw-evidence.js";
@@ -984,6 +985,10 @@ function isMissingFsError(error) {
 async function countReadOnlyGuards(candidates) {
     const counts = new Map();
     const retryableCandidateKeys = new Set();
+    // Aggregated: this runs over the whole archived history, so a per-candidate
+    // line could be thousands. The count already travels; the reason did not
+    // (BLI-3238).
+    let firstReadFailure = null;
     for (const candidate of candidates) {
         if (candidate.reason === "repo_not_on_disk") {
             increment(counts, "repo_not_on_disk");
@@ -1004,11 +1009,21 @@ async function countReadOnlyGuards(candidates) {
         try {
             await fs.readFile(candidate.file_path);
         }
-        catch {
+        catch (error) {
             increment(counts, "file_read_failed");
+            firstReadFailure ??= describeError(error);
             retryableCandidateKeys.add(candidateCursorKey(candidate));
         }
     }
+    const readFailedCount = counts.get("file_read_failed") ?? 0;
+    if (readFailedCount > 0) {
+        console.error("[cockpit-backfill] archived sessions could not be read", JSON.stringify({
+            reason: "file_read_failed",
+            read_failed_count: readFailedCount,
+            candidate_count: candidates.length,
+            ...firstReadFailure,
+        }));
+    }
     return {
         counts,
         retryable_candidate_keys: retryableCandidateKeys,
@@ -1128,13 +1143,23 @@ async function ensureBackfillReportContext(options) {
         await readLocalWorkContextForRepo(options.paths, repoRoot);
     }
     catch {
-        // Context creation is best-effort here. postCodexSessionReport converts a
-        // remaining local-context failure into a retryable report reason.
+        // Reading it can legitimately fail — there is no context yet, which is
+        // precisely why the next line creates one. That read is a probe and stays
+        // silent; the CREATE is the branch that has to speak (BLI-3238).
         await startLocalWorkContext({
             homeDir: options.homeDir,
             repoRoot,
             branch: representative?.branch,
-        }).catch(() => undefined);
+        }).catch((error) => {
+            // Context creation is best-effort here: postCodexSessionReport converts
+            // a remaining local-context failure into a retryable report reason. But
+            // that reason is `collector_not_ready`, which points the operator at
+            // setup rather than at whatever actually failed here.
+            console.error("[cockpit-backfill] could not start a local work context for the batch", JSON.stringify({
+                reason: "work_context_start_failed",
+                ...describeError(error),
+            }));
+        });
     }
     return { repoRoot };
 }
@@ -1188,7 +1213,8 @@ async function syncBackfillBatch(options) {
         throw error;
     }
 }
-function buildBackfillSessionReport(options) {
+/** Exported for the BLI-3272 regression test; not part of the CLI surface. */
+export function buildBackfillSessionReport(options) {
     const uploadByKey = new Map();
     // BLI-2107: an outcome that names a failure but has no pointer used to be
     // dropped on the floor here, taking its reason with it.
@@ -1275,7 +1301,15 @@ function buildBackfillSessionReport(options) {
                         upload_reason: noUploadReasonBySessionId.get(candidate.session_id) ??
                             NO_UPLOAD_ATTEMPT_RECORDED,
                     }
-                    : {}),
+                    : {
+                        // BLI-3272: and the refused-attribution branch says why too. Same
+                        // NULL/NULL hole as live sync, same fix — backfill is the path
+                        // that revisits old sessions, so leaving it silent would keep
+                        // rewriting the very rows this ticket found.
+                        upload_state: "not_uploaded",
+                        upload_reason: noUploadReasonBySessionId.get(candidate.session_id) ??
+                            notUploadableAttributionStateReason(candidate.reason),
+                    }),
         };
     });
 }

package/dist/commands/cli-io.js

@@ -67,6 +67,9 @@ export function parseCapturedJson(chunks) {
         return JSON.parse(text);
     }
     catch {
+        // Deliberately silent (BLI-3238). The parse IS the question this function
+        // asks — "did the nested command print JSON or human text?" — and both
+        // answers are valid; the caller replays the raw text when it is not JSON.
         return text;
     }
 }

package/dist/commands/doctor.js

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { autostartStatus, installAutostartAgent } from "../autostart.js";
 import { savedDiscoveryLimitArgs } from "../discovery-limits.js";
-import { redactedHealthDetail } from "../health-detail.js";
+import { describeError, redactedHealthDetail } from "../health-detail.js";
 import { inspectBackfillLock } from "../backfill-lock.js";
 import { backfillCompletionCovers, readBackfillCompletionMarker, readBackfillCursor, } from "../cursors/backfill-cursor.js";
 import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, LOCAL_COLLECTOR_VERSION, readLocalCollectorConfig, readLocalCollectorSessionFile, } from "../local-state.js";
@@ -146,14 +146,32 @@ async function fixCliLatest(context, state) {
     };
 }
 async function fixAuthState(context, state) {
-    const code = await context.deps.runLogin(context).catch(() => 1);
+    const code = await context.deps.runLogin(context).catch((error) => {
+        // Exit code 1 with no reason at all is what an operator saw when doctor
+        // tried and failed to repair their auth — the same output as a login that
+        // ran and was declined (BLI-3238).
+        console.error("[cockpit-doctor] login repair threw", JSON.stringify({
+            reason: "auth_repair_failed",
+            ...describeError(error),
+        }));
+        return 1;
+    });
     if (code !== 0)
         return state;
     const checked = await context.deps.readAuth(context);
     return checked.status === "ok" ? checked : state;
 }
 async function fixRootState(context, state) {
-    await context.deps.resolveAndSaveRoots(context).catch(() => undefined);
+    await context.deps.resolveAndSaveRoots(context).catch((error) => {
+        // Roots ARE the collection boundary. If saving them throws and nothing
+        // says so, the machine converges to "no approved root" and collects
+        // nothing — a green-looking doctor run over an empty boundary, which is
+        // the failure mode this whole ticket exists for.
+        console.error("[cockpit-doctor] collection roots could not be resolved or saved", JSON.stringify({
+            reason: "roots_repair_failed",
+            ...describeError(error),
+        }));
+    });
     const checked = await context.deps.readRoots(context);
     return checked.status === "ok" ? checked : state;
 }
@@ -350,7 +368,16 @@ function parseDoctorSyncJson(stdout) {
         const parsed = JSON.parse(stdout.trim());
         return parsed && typeof parsed === "object" ? parsed : null;
     }
-    catch {
+    catch (error) {
+        // `null` sends doctor back to its regex field-scrape, quietly losing the
+        // BLI-2728 disambiguation. Something wrote to stdout that was not the one
+        // JSON document the contract promises — a stray console.log in the
+        // collector would do exactly this and look like nothing at all.
+        console.error("[cockpit-doctor] sync --json stdout was not one JSON document", JSON.stringify({
+            reason: "sync_json_unparseable",
+            byte_size: stdout.length,
+            ...describeError(error),
+        }));
         return null;
     }
 }
@@ -547,6 +574,10 @@ function parseNpmVersion(stdout) {
         return typeof parsed === "string" && parsed.trim() ? parsed.trim() : null;
     }
     catch {
+        // Deliberately silent (BLI-3238). `npm view ... version` prints a bare
+        // `1.2.3` without `--json` and a quoted `"1.2.3"` with it; the parse is
+        // the test for which one this npm produced, and the unquoted fallback is
+        // the intended handling of the other form, not a failure.
         return trimmed.replace(/^"|"$/gu, "") || null;
     }
 }

package/dist/commands/install-receipts.js

@@ -11,7 +11,7 @@
  */
 import os from "node:os";
 import { errorMessage, writeLine } from "./cli-io.js";
-import { maskLocalIdentifiers, redactedHealthDetail, } from "../health-detail.js";
+import { describeError, maskLocalIdentifiers, redactedHealthDetail, } from "../health-detail.js";
 import { getCollectorRuntimePaths, readLocalCollectorSessionFile, LOCAL_COLLECTOR_VERSION, } from "../local-state.js";
 import { redactSecretLikeContent } from "@bli-cockpit/telemetry-core";
 import { COLLECTION_ROOT_REQUIRED } from "../onboarding-roots.js";
@@ -74,7 +74,17 @@ export async function reportInstallEventsBestEffort(options) {
             })),
         });
     }
-    catch {
+    catch (error) {
+        // The existing operator line survives, and is `--json`-only. This one is
+        // unconditional and carries the reason: the machine has just dropped the
+        // health receipts for a whole command, and a `--json` gate meant the
+        // normal interactive run said nothing at all (BLI-3238).
+        console.error("[install-receipts] could not queue install events; the receipts are lost", JSON.stringify({
+            reason: "local_write_failed",
+            command: options.command,
+            event_count: options.events.length,
+            ...describeError(error),
+        }));
         if (options.json) {
             writeLine(options.io.stderr, "Install event outbox unavailable: local_write_failed");
         }
@@ -112,9 +122,18 @@ export async function reportInstallEventsBestEffort(options) {
                 if (!response.ok) {
                     throw new Error(`http_${response.status}`);
                 }
-                const receipt = (await response
-                    .json()
-                    .catch(() => null));
+                const receipt = (await response.json().catch((error) => {
+                    // This reply carries the server-published `min_cli_version` floor
+                    // (BLI-2678). A body that will not parse means the floor is not
+                    // observed on this tick and the forced-update path silently does
+                    // nothing — while the 2xx above says the receipt landed fine.
+                    console.error("[install-receipts] receipt body unreadable; no min_cli_version observed", JSON.stringify({
+                        reason: "receipt_body_unreadable",
+                        http_status: response.status,
+                        ...describeError(error),
+                    }));
+                    return null;
+                }));
                 if (typeof receipt?.min_cli_version === "string" &&
                     receipt.min_cli_version.trim()) {
                     observedMinCliVersion = receipt.min_cli_version.trim();
@@ -124,10 +143,28 @@ export async function reportInstallEventsBestEffort(options) {
             catch (error) {
                 const failureReason = classifyInstallTelemetryError(error);
                 failures.push(failureReason);
+                // The classified reason is the coarse bucket the outbox row keeps;
+                // beside it, what actually happened. `network_error` covers DNS,
+                // TLS, timeout and abort, and only one of those is worth waking up
+                // for (BLI-3238).
+                console.error("[install-receipts] install event delivery failed, entry kept for retry", JSON.stringify({
+                    reason: failureReason,
+                    outbox_id: entry.outbox_id,
+                    ...describeError(error),
+                }));
                 await recordInstallEventAttemptFailure(paths, entry, {
                     attemptedAt: new Date().toISOString(),
                     failureReason,
-                }).catch(() => undefined);
+                }).catch((writeError) => {
+                    // Double failure: delivery failed AND the retry bookkeeping did.
+                    // The entry stays queued, so nothing is lost, but the attempt
+                    // count stops advancing and the outbox looks stuck for no reason.
+                    console.error("[install-receipts] could not record the delivery failure against the entry", JSON.stringify({
+                        reason: "attempt_bookkeeping_failed",
+                        outbox_id: entry.outbox_id,
+                        ...describeError(writeError),
+                    }));
+                });
             }
             finally {
                 clearTimeout(timeout);

package/dist/commands/install-update.js

@@ -295,7 +295,9 @@ async function findPublicReleaseRoot(startDir) {
         }
         catch {
             // Keep walking: nested packages may be missing package.json or have one
-            // without the release script.
+            // without the release script. Deliberately silent (BLI-3238) — this is
+            // a search, every level that is not the answer fails here, and the
+            // caller reports `null` when the walk finds nothing.
         }
         const parent = path.dirname(current);
         if (parent === current)

package/dist/commands/jarvis.js

@@ -0,0 +1,136 @@
+/**
+ * Terminal adapter for the shared JARVIS conversation gateway.
+ *
+ * This file owns terminal input and output only. Identity comes from the
+ * existing paired device session, and every turn is executed by the dashboard
+ * through the same JARVIS runtime used by web chat and Slack.
+ */
+import { errorMessage, isInteractiveStdin, readLine, writeLine } from "./cli-io.js";
+import { getCollectorRuntimePaths, readLocalCollectorSessionFile, } from "../local-state.js";
+export async function runJarvis(command, io) {
+    const session = await loadPairedSession(command.homeDir);
+    const dashboardUrl = command.dashboardUrl ?? session.dashboard_url;
+    const oneShotPrompt = await resolveOneShotPrompt(command, io);
+    if (oneShotPrompt !== null) {
+        return sendOneTurn({ command, dashboardUrl, deviceToken: session.device_token }, oneShotPrompt, io);
+    }
+    if (command.json) {
+        throw new Error("cockpit jarvis --json needs --prompt, positional text, or piped stdin.");
+    }
+    writeLine(io.stdout, "JARVIS terminal chat. Type /exit to leave.");
+    while (true) {
+        const prompt = (await readLine(io, "you> ")).trim();
+        if (!prompt)
+            continue;
+        if (prompt === "/exit" || prompt === "/quit")
+            return 0;
+        const exitCode = await sendOneTurn({ command, dashboardUrl, deviceToken: session.device_token }, prompt, io);
+        if (exitCode !== 0)
+            return exitCode;
+    }
+}
+async function loadPairedSession(homeDir) {
+    const paths = getCollectorRuntimePaths(homeDir);
+    try {
+        const session = await readLocalCollectorSessionFile(paths);
+        if (session.session_state !== "valid") {
+            throw new Error(`session_${session.session_state}`);
+        }
+        return session;
+    }
+    catch (error) {
+        throw new Error(`JARVIS needs a valid paired Cockpit session. Run \`cockpit login\`, then try again (${errorMessage(error)}).`);
+    }
+}
+async function resolveOneShotPrompt(command, io) {
+    if (command.prompt)
+        return validatePrompt(command.prompt);
+    if (isInteractiveStdin(io))
+        return null;
+    const piped = await readAll(io.stdin);
+    return validatePrompt(piped);
+}
+async function sendOneTurn(context, prompt, io) {
+    const startedAt = Date.now();
+    let response;
+    try {
+        response = await io.fetch(`${context.dashboardUrl}/api/jarvis/cli`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${context.deviceToken}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ question: prompt, thread: context.command.thread }),
+        });
+    }
+    catch (error) {
+        writeFailure(context.command, io, "gateway_unreachable", errorMessage(error));
+        return 1;
+    }
+    const body = await readReply(response);
+    if (!response.ok || !body.ok || !body.reply) {
+        const reason = body.error ?? body.reply ?? `http_${response.status}`;
+        writeFailure(context.command, io, "turn_failed", reason);
+        return 1;
+    }
+    if (context.command.json) {
+        writeLine(io.stdout, JSON.stringify({
+            ok: true,
+            reply: body.reply,
+            thread: body.thread ?? context.command.thread,
+            model: body.model ?? null,
+        }));
+    }
+    else {
+        writeLine(io.stdout, `jarvis> ${body.reply}`);
+    }
+    writeLine(io.stderr, `[jarvis cli] answered ${JSON.stringify({
+        prompt_length: prompt.length,
+        reply_length: body.reply.length,
+        elapsed_ms: Date.now() - startedAt,
+        thread: context.command.thread === "main" ? "default" : "named",
+    })}`);
+    return 0;
+}
+async function readReply(response) {
+    const text = await response.text();
+    if (!text)
+        return { ok: false, error: "empty_response" };
+    try {
+        const value = JSON.parse(text);
+        if (!value || typeof value !== "object") {
+            return { ok: false, error: "response_body_not_object" };
+        }
+        return value;
+    }
+    catch {
+        return { ok: false, error: "response_body_not_json" };
+    }
+}
+function writeFailure(command, io, reason, detail) {
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: false, error: reason, detail }));
+        return;
+    }
+    writeLine(io.stderr, `JARVIS could not answer: ${detail}`);
+}
+function validatePrompt(raw) {
+    const prompt = raw.trim();
+    if (!prompt)
+        throw new Error("JARVIS needs a non-empty question.");
+    if (prompt.length > 4000) {
+        throw new Error("JARVIS questions are limited to 4000 characters.");
+    }
+    return prompt;
+}
+async function readAll(stream) {
+    stream.setEncoding("utf8");
+    let text = "";
+    for await (const chunk of stream) {
+        text += chunk;
+        if (text.length > 4000) {
+            throw new Error("JARVIS questions are limited to 4000 characters.");
+        }
+    }
+    return text;
+}

package/dist/commands/local-args.js

@@ -47,6 +47,8 @@ export function parseLocalArgs(argv) {
             return parseSyncArgs(argv.slice(1));
         case "analyze":
             return parseAnalyzeArgs(argv.slice(1));
+        case "jarvis":
+            return parseJarvisArgs(argv.slice(1));
         case "backfill":
             return parseBackfillArgs(argv.slice(1));
         case "status":
@@ -607,6 +609,29 @@ function parseAgentRulesHost(value) {
         return host;
     throw new Error("agent-rules --host must be codex, claude, or all.");
 }
+function parseJarvisArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: ["--home", "--dashboard-url", "--prompt", "--thread", "--json"],
+        valueFlags: ["--home", "--dashboard-url", "--prompt", "--thread"],
+    });
+    const flaggedPrompt = optionalNonEmpty(values.flags.get("--prompt"));
+    const positionalPrompt = optionalNonEmpty(values.positionals.join(" "));
+    if (flaggedPrompt && positionalPrompt) {
+        throw new Error("jarvis accepts either --prompt or positional text, not both.");
+    }
+    const thread = optionalNonEmpty(values.flags.get("--thread")) ?? "main";
+    if (!/^[A-Za-z0-9_-]{1,40}$/.test(thread)) {
+        throw new Error("jarvis --thread must use 1 to 40 letters, numbers, underscores, or hyphens.");
+    }
+    return {
+        kind: "jarvis",
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        prompt: flaggedPrompt ?? positionalPrompt,
+        thread,
+        json: values.booleans.has("--json"),
+    };
+}
 function parseNamedArgs(args, options) {
     const allowed = new Set(options.allowedFlags);
     const valueFlags = new Set(options.valueFlags);
@@ -739,6 +764,10 @@ function looksLikeServiceRoleSecret(value) {
         return serviceCredentialPayloadPattern().test(payload);
     }
     catch {
+        // Deliberately silent (BLI-3238), and it must stay silent: this is the
+        // "is this argument a service-role JWT?" test, so a value that will not
+        // decode is simply not one. Anything logged here would be a fragment of a
+        // credential.
         return false;
     }
 }

package/dist/commands/local-auth.js

@@ -185,6 +185,15 @@ async function readJsonResponse(response) {
         return JSON.parse(text);
     }
     catch {
+        // OTP path. The text is handed to the caller for the human-facing message
+        // but never logged — it is an unbounded page from whatever answered. The
+        // shape is what says "a proxy replied, not the dashboard" (BLI-3238).
+        console.error("[local-auth] auth reply was not JSON", JSON.stringify({
+            reason: "response_body_not_json",
+            http_status: response.status,
+            byte_size: text.length,
+            content_type: response.headers.get("content-type") ?? "none",
+        }));
         return text;
     }
 }
@@ -260,6 +269,11 @@ export async function readOnboardSessionReuseCandidate(homeDir) {
         return await readLocalCollectorSessionFile(paths);
     }
     catch {
+        // Deliberately silent (BLI-3238). This is the "can we reuse an existing
+        // login?" probe and the fallback below reads the same file through the
+        // looser schema — which reports its own reason when it also fails
+        // (`session_file_unusable` in local-state). Logging here would double
+        // every line for one read.
         return readLocalSessionReference(paths);
     }
 }

package/dist/commands/local-help.js

@@ -21,6 +21,7 @@ export const rootCommandNames = new Set([
     "start",
     "sync",
     "analyze",
+    "jarvis",
     "backfill",
     "status",
     "sessions",
@@ -45,6 +46,7 @@ export function localCommandHelp(command) {
         "  cockpit start [--ticket <id>|--clear-ticket] [--topic <label>] [--intent <intent>] [--phase <phase>] [--workspace <path>] [--branch <name>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit sync [--workspace <path>] [--dashboard-url <url>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit analyze [--workspace <path>] [--dashboard-url <url>] [--max-depth <n>] [--max-repos <n>] [--json]",
+        "  cockpit jarvis [question] [--prompt <question>] [--thread <name>] [--dashboard-url <url>] [--json]",
         "  cockpit backfill (--since-days <n>|--all) [--source codex|claude] [--dry-run] [--max-files <n>] [--max-depth <n>] [--max-repos <n>] [--yes] [--workspace <path>] [--json]",
         "  cockpit status [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit sessions [--source codex|claude] [--since-days <n>|--all] [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
@@ -185,6 +187,19 @@ function localSubcommandHelp(command) {
                 "`--repo <path>` remains supported as a backward-compatible alias.",
             ],
         ],
+        [
+            "jarvis",
+            [
+                "Usage: cockpit jarvis [question] [--prompt <question>] [--thread <name>] [--dashboard-url <url>] [--json]",
+                "",
+                "Chats with the same JARVIS used by Cockpit web chat and the BLI Slack DM.",
+                "Run with no question for an interactive terminal conversation.",
+                "Agents can pass --prompt, positional text, or pipe one question on stdin.",
+                "--json writes one machine-readable response to stdout; operational metadata stays on stderr.",
+                "The command uses the existing paired device identity. It cannot override the caller, team, role, or person scope.",
+                "Run `cockpit login` first if this machine is not paired.",
+            ],
+        ],
         [
             "backfill",
             [

package/dist/commands/local.js

@@ -16,6 +16,7 @@
  *   install-update.ts    install, update, self-update, release
  *   status.ts            `cockpit status`
  *   sessions.ts          `cockpit sessions`
+ *   jarvis.ts            terminal adapter for the shared JARVIS gateway
  *
  * What stays here is orchestration: onboard, login/logout/start, the sync tick,
  * analyze, serve, autostart and agent-rules.
@@ -23,6 +24,7 @@
 import path from "node:path";
 import { bufferedWritable, defaultExec, defaultIo, errorMessage, parseCapturedJson, replayCaptured, writeLine, } from "./cli-io.js";
 import { isLocalHelpRequest, localCommandHelp } from "./local-help.js";
+import { describeError, isMissingFileFailure } from "../health-detail.js";
 import { addInstallEvent, classifySyncHealthError, redactedSyncErrorDetail, reportInstallEventsBestEffort, } from "./install-receipts.js";
 import { canReuseOnboardSession, pairLocalCollectorWithAuthFallback, readOnboardSessionReuseCandidate, requestPairingAccessToken, requestPairingAccessTokenDetailed, resolveInteractiveLoginEmail, resolveOnboardEmail, } from "./local-auth.js";
 import { collectionRootConsentAliases, persistOnboardingRootConfig, resolveOnboardingRootsForCommand, } from "./collection-roots.js";
@@ -31,6 +33,7 @@ import { attributedSyncRunStatus, cursorStatusLine, displayTicketId, rawEvidence
 import { runInstall, runRelease, runSelfUpdate, runUpdate, SelfUpdateError, } from "./install-update.js";
 import { runStatus } from "./status.js";
 import { runSessions } from "./sessions.js";
+import { runJarvis } from "./jarvis.js";
 import { createCollectorServer } from "../server.js";
 import { inspectAgentRules, installAgentRules, uninstallAgentRules, } from "../agent-rules.js";
 import { backfillRetryCommand, runBackfill, runBackfillCommand, } from "./backfill.js";
@@ -97,6 +100,8 @@ export async function runLocalCockpitCli(argv, io = defaultIo()) {
                 return await runSync(command, io);
             case "analyze":
                 return await runAnalyze(command, io);
+            case "jarvis":
+                return await runJarvis(command, io);
             case "backfill":
                 return await runBackfillCommand(command, io);
             case "status":
@@ -1372,7 +1377,16 @@ async function runAnalyze(command, io) {
         return syncExitCode === 0 ? 1 : syncExitCode;
     }
     const paths = getCollectorRuntimePaths(command.homeDir);
-    const session = await readLocalCollectorSessionFile(paths).catch(() => {
+    const session = await readLocalCollectorSessionFile(paths).catch((error) => {
+        // "Not signed in" is the right sentence for an absent session file and the
+        // wrong one for a corrupt one, which `cockpit login` will not repair
+        // (BLI-3238).
+        if (!isMissingFileFailure(error)) {
+            console.error("[cockpit-analyze] session file present but unreadable, reporting as not signed in", JSON.stringify({
+                reason: "session_file_unusable",
+                ...describeError(error),
+            }));
+        }
         throw new Error("Cockpit is not signed in. Run `cockpit onboard` or `cockpit login` first.");
     });
     const dashboardUrl = normalizeUrl(command.dashboardUrl ?? session.dashboard_url ?? DEFAULT_DASHBOARD_URL);
@@ -1436,6 +1450,15 @@ async function readAnalyzeApiResponse(response) {
         return value && typeof value === "object" ? value : {};
     }
     catch {
+        // `{}` erases whatever the analyze endpoint said, including its error, and
+        // the operator is left with a job id of `undefined` and no reason. The
+        // body is never logged; its shape is what identifies a proxy reply.
+        console.error("[cockpit-analyze] reply was not JSON", JSON.stringify({
+            reason: "response_body_not_json",
+            http_status: response.status,
+            byte_size: text.length,
+            content_type: response.headers.get("content-type") ?? "none",
+        }));
         return {};
     }
 }

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.30");
+    writeLine(io?.stdout ?? process.stdout, "0.2.32");
     return 0;
   }