@bli-cockpit/cli 0.2.196 → 0.2.198

package/dist/commands/brain.js

@@ -16,6 +16,18 @@ export async function runBrain(command, io) {
             writeLine(io.stderr, detail);
         return 1;
     }
+    if (command.action === "retry") {
+        const answer = await askAgentDoor(door, { path: "/api/brain/incidents/retry", method: "POST", label: "brain retry", timeoutMs: READ_DEADLINE_MS,
+            body: { ids: command.ids, all_needs_human: command.allNeedsHuman, project: command.project, reason: command.reason } });
+        if (!answer.ok)
+            return failAgentDoor(door, TAG, answer.reason, answer.detail);
+        const body = answer.body;
+        writeLine(io.stderr, `${TAG} retry answered ${JSON.stringify({ reason: body.reason, retried: body.retried.length, skipped: body.skipped.length, missing: body.missing.length, failures: body.failures.length })}`);
+        if (command.json)
+            return emitAgentDoor(door, body, body.ok ? 0 : 1);
+        writeLine(io.stdout, body.text);
+        return body.ok ? 0 : 1;
+    }
     const query = new URLSearchParams();
     if (command.project)
         query.set("project", command.project);

package/dist/commands/cal.js

@@ -25,7 +25,7 @@ import { runCalAddIcal, runCalDetach, runCalShare, runCalSync } from "./cal-cale
 import { runCalDelete } from "./cal-delete.js";
 import { runCalSyncStatus } from "./cal-sync-status.js";
 import { writeLine } from "./cli-io.js";
-import { cacheAgeLabel, readThroughCache } from "./read-cache.js";
+import { cacheAgeLabel, cacheCoverage, readThroughCache } from "./read-cache.js";
 const TAG = "[cal cli]";
 const READ_DEADLINE_MS = 30_000;
 const WRITE_DEADLINE_MS = 60_000;
@@ -118,7 +118,7 @@ async function window(command, door) {
         return failAgentDoor(door, TAG, answer.reason, answer.detail);
     const body = answer.body;
     if (door.json)
-        return emitAgentDoor(door, { ok: true, ...body });
+        return emitAgentDoor(door, { ok: true, ...body, ...cacheCoverage(answer) });
     if (answer.fromCache) {
         writeLine(door.io.stderr, `(${cacheAgeLabel(answer.ageMs ?? 0)}, refreshing in the background)`);
     }

package/dist/commands/docs-notion.js

@@ -47,8 +47,8 @@ export async function syncStatusDocs(command, door) {
     const body = answer.body;
     if (door.json) {
         return emitAgentDoor(door, {
+            ...answer.body,
             ok: true,
-            counts: body.counts,
             documents: body.documents ?? [],
             last_run: body.last_run ?? { push: null, pull: null },
         });
@@ -57,6 +57,8 @@ export async function syncStatusDocs(command, door) {
     for (const doc of documents) {
         writeLine(door.io.stdout, `${doc.id}  ${doc.state.padEnd(13)}  ${(doc.notion_synced_at ?? "never").padEnd(25)}  ${doc.slug ?? "(no slug)"}  ${doc.title}`);
     }
+    if (body.coverage)
+        writeLine(door.io.stdout, body.coverage);
     const byState = body.counts?.by_state ?? {};
     writeLine(door.io.stdout, "");
     writeLine(door.io.stdout, `${body.counts?.linked ?? documents.length} linked: ${Object.entries(byState)

package/dist/commands/docs.js

@@ -32,7 +32,7 @@ import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
 import { readDoc } from "./docs-read.js";
 import { linkDoc, syncStatusDocs } from "./docs-notion.js";
 import { readNoteFile } from "./notes-file.js";
-import { cacheAgeLabel, readThroughCache } from "./read-cache.js";
+import { cacheAgeLabel, cacheCoverage, readThroughCache } from "./read-cache.js";
 const TAG = "[docs cli]";
 const READ_DEADLINE_MS = 30_000;
 const WRITE_DEADLINE_MS = 60_000;
@@ -97,10 +97,13 @@ async function listDocs(command, door) {
         return failAgentDoor(door, TAG, answer.reason, answer.detail);
     const documents = (answer.body.documents ?? []);
     if (door.json)
-        return emitAgentDoor(door, { ok: true, documents });
+        return emitAgentDoor(door, { ok: true, ...answer.body, documents, ...cacheCoverage(answer) });
     if (answer.fromCache) {
         writeLine(door.io.stderr, `(${cacheAgeLabel(answer.ageMs ?? 0)}, refreshing in the background)`);
     }
+    const counts = answer.body.counts;
+    if (counts)
+        writeLine(door.io.stdout, `${counts.total} documents match in all. ${counts.coverage}`);
     if (documents.length === 0) {
         writeLine(door.io.stdout, command.query ? `No document matches "${command.query}".` : "No documents.");
         return 0;

package/dist/commands/doctor-report.js

@@ -53,6 +53,7 @@ setupReceipt, repairs = []) {
             repairs,
             needs_person: needsPerson,
             setup_receipt: setupReceipt?.receipt ?? null,
+            setup_receipt_coverage: setupReceipt ? setupReceiptBlock(setupReceipt).join("; ") : "no data yet: no cached receipt",
             memory_install: setupReceipt?.memory ?? null,
         }, null, 2));
         return;
@@ -169,6 +170,7 @@ export function doctorNeedsPerson(rows, receipt) {
         "roots-cover-work": "cockpit doctor",
         "single-install": "Run npm uninstall -g @bli-cockpit/cli with the Node installation that owns the extra CLI listed above.",
         "autostart-alive": "cockpit doctor",
+        "usage-telemetry": "cockpit doctor",
         "memory-registered": "cockpit doctor",
         "agent-rules": "cockpit doctor",
         "mcp-answers": "cockpit doctor",

package/dist/commands/doctor-update.js

@@ -73,6 +73,8 @@ function parseNpmVersion(stdout) {
 }
 export function reexecDoctor(command, io) {
     const args = ["doctor"];
+    if (command.noUsageTelemetry)
+        args.push("--no-usage-telemetry");
     if (command.homeDir)
         args.push("--home", command.homeDir);
     if (command.backfillBudgetSeconds)

package/dist/commands/doctor-usage-telemetry.js

@@ -0,0 +1,96 @@
+import os from "node:os";
+import path from "node:path";
+import { getCollectorRuntimePaths, readLocalCollectorSessionFile } from "../local-state.js";
+import { claudeSettingsFile } from "./memory-install-claude.js";
+import { codexConfigFile } from "./tower-mcp-codex.js";
+import { defaultMemoryFileIo } from "./memory-install-files.js";
+import { mergeUsageToml } from "./usage-telemetry-toml.js";
+import { fail, needsFix, ok } from "./doctor-report.js";
+export function mergeClaudeUsageSettings(raw, origin, token, off) {
+    const root = JSON.parse(raw || "{}");
+    if (!root || typeof root !== "object" || Array.isArray(root) || (root.env !== undefined && (!root.env || typeof root.env !== "object" || Array.isArray(root.env))))
+        throw new Error("config_unreadable");
+    root.env = { ...root.env, CLAUDE_CODE_ENABLE_TELEMETRY: off ? "0" : "1",
+        OTEL_METRICS_EXPORTER: off ? "none" : "otlp", OTEL_LOGS_EXPORTER: off ? "none" : "otlp",
+        OTEL_EXPORTER_OTLP_PROTOCOL: "http/json", OTEL_EXPORTER_OTLP_ENDPOINT: `${new URL(origin).origin}/api/otel`,
+        OTEL_EXPORTER_OTLP_HEADERS: `Authorization=Bearer ${token}` };
+    // OTEL_LOG_USER_PROMPTS is never added or changed. Existing person keys survive.
+    return `${JSON.stringify(root, null, 2)}\n`;
+}
+export function mergeCodexUsageSettings(raw, origin, token, off) {
+    // Disabled exporter options remain as comments, including person-set TLS and
+    // headers. Restore them before enabling, rather than discard configuration.
+    const prefix = "# TOWER usage telemetry opt-out: ";
+    let table = "";
+    raw = raw.split("\n").flatMap(line => {
+        if (!off && line.startsWith(prefix))
+            line = line.slice(prefix.length);
+        const header = /^\s*\[([^\]]+)\]/.exec(line);
+        if (header)
+            table = header[1].replace(/["']/g, "").replace(/\s/g, "");
+        const exporterTable = /^otel\.(?:exporter|metrics_exporter)(?:\.|$)/.test(table);
+        const exporterAssignment = table === "otel" && /^\s*(?:exporter|metrics_exporter)\s*=/.test(line);
+        if (off && (exporterTable || exporterAssignment) && !/^\s*(?:exporter|metrics_exporter)\s*=\s*["']none["']/.test(line))
+            return [prefix + line];
+        if (!off && exporterAssignment && /^\s*(?:exporter|metrics_exporter)\s*=\s*["']none["']/.test(line))
+            return [];
+        return [line];
+    }).join("\n");
+    const exporter = off ? '"none"' : { "otlp-http": {
+            endpoint: JSON.stringify(`${new URL(origin).origin}/api/otel/v1/logs`), protocol: '"json"', headers: { Authorization: JSON.stringify(`Bearer ${token}`) },
+        } };
+    const metrics = off ? '"none"' : { "otlp-http": {
+            endpoint: JSON.stringify(`${new URL(origin).origin}/api/otel/v1/metrics`), protocol: '"json"', headers: { Authorization: JSON.stringify(`Bearer ${token}`) },
+        } };
+    return mergeUsageToml(raw, ["otel"], { log_user_prompt: "false", exporter, metrics_exporter: metrics });
+}
+export async function configureUsageTelemetry(options) {
+    const marker = path.join(getCollectorRuntimePaths(options.homeDir).state_dir, "usage-telemetry-opt-out.json");
+    const persisted = await options.io.readText(marker) !== null;
+    const off = persisted || Boolean(options.optOut);
+    let changed = Boolean(options.optOut && !persisted);
+    const files = [
+        [claudeSettingsFile(options.homeDir), mergeClaudeUsageSettings],
+        [codexConfigFile(options.homeDir), mergeCodexUsageSettings],
+    ];
+    const updates = [];
+    for (const [file, merge] of files) {
+        const raw = await options.io.readText(file) ?? "";
+        const next = merge(raw, options.origin, options.token, off);
+        updates.push({ file, merge, raw, next });
+    }
+    if (options.optOut && !persisted && !options.checkOnly)
+        await options.io.writeText(marker, '{"opt_out":true}\n');
+    for (const { file, merge, raw, next } of updates) {
+        if (raw === next)
+            continue;
+        changed = true;
+        if (options.checkOnly)
+            continue;
+        await options.io.writeText(file, next);
+        const stored = await options.io.readText(file);
+        if (stored === null || merge(stored, options.origin, options.token, off) !== stored)
+            throw new Error("read_back_mismatch");
+    }
+    console.error("[usage telemetry] configured", JSON.stringify({ reason: off ? "explicit_opt_out" : changed ? "settings_changed" : "already_current", check_only: Boolean(options.checkOnly) }));
+    return { off, changed };
+}
+async function usageTelemetryStep(context, checkOnly) {
+    try {
+        const home = context.command.homeDir ?? os.homedir();
+        const session = await readLocalCollectorSessionFile(getCollectorRuntimePaths(home));
+        if (!session?.device_token)
+            return needsFix("usage-telemetry", "device_token_missing", "usage telemetry: needs Tower sign-in");
+        const result = await configureUsageTelemetry({ homeDir: home, origin: context.command.dashboardUrl, token: session.device_token,
+            optOut: context.command.noUsageTelemetry, checkOnly, io: defaultMemoryFileIo({ mode: 0o600 }) });
+        const message = result.off ? "usage telemetry: off (explicit opt-out)" : "usage telemetry: on (claude code, codex)";
+        return checkOnly && result.changed ? needsFix("usage-telemetry", "settings_differ", message) : ok("usage-telemetry", result.off ? "explicit_opt_out" : "already_current", message);
+    }
+    catch (error) {
+        const reason = error instanceof SyntaxError ? "config_unreadable" : error instanceof Error && ["config_unreadable", "read_back_mismatch"].includes(error.message) ? error.message : "settings_io_failed";
+        console.error("[usage telemetry] refused", JSON.stringify({ reason }));
+        return fail("usage-telemetry", reason, "usage telemetry: settings could not be safely merged");
+    }
+}
+export const checkUsageTelemetry = (context) => usageTelemetryStep(context, true);
+export const fixUsageTelemetry = (context) => usageTelemetryStep(context, false);

package/dist/commands/doctor.js

@@ -1,3 +1,4 @@
+import { checkUsageTelemetry, fixUsageTelemetry } from "./doctor-usage-telemetry.js";
 import { LOCAL_COLLECTOR_VERSION } from "../local-state.js";
 import { isSemverBelow } from "../scheduled-self-update.js";
 import { describeError } from "../health-detail.js";
@@ -184,6 +185,7 @@ function doctorInvariants() {
             check: (context) => context.deps.checkMemory(context),
             fix: (context, _state) => context.deps.fixMemory(context),
         },
+        { id: "usage-telemetry", check: context => context.deps.checkUsageTelemetry(context), fix: context => context.deps.fixUsageTelemetry(context) },
         { id: "agent-rules", check: (context) => context.deps.checkAgentRules(context), fix: (context) => context.deps.fixAgentRules(context) },
         // BLI-3804. Right after the registration row, because it asks the second
         // half of the same question: `memory-registered` proves the entry exists
@@ -248,6 +250,8 @@ function defaultDoctorDeps(hooks) {
         checkSingleInstall: checkSingleInstallState,
         checkAutostart: checkAutostartState,
         fixAutostart: fixAutostartState,
+        checkUsageTelemetry,
+        fixUsageTelemetry,
         checkMemory: checkMemoryState,
         fixMemory: fixMemoryState,
         checkMcpAnswers: (context) => checkMcpAnswersState(context),

package/dist/commands/heartbeat.js

@@ -270,7 +270,7 @@ export async function sendCollectorHeartbeatBestEffort(options) {
     const heartbeat = buildCollectorHeartbeat({
         roots: options.roots,
         facts: options.facts,
-        setupReceipt: { ...(setupReceipt ?? { schema_version: "setup-receipt.v1", checked_at: new Date().toISOString(), browser: { status: "unknown" }, device: { status: "unknown" }, collector: { autostart: { status: "unknown" } } }), agent_setup: await collectAgentSetup(options.homeDir ?? os.homedir()) },
+        setupReceipt: setupReceipt ? { ...setupReceipt, agent_setup: await collectAgentSetup(options.homeDir ?? os.homedir()) } : null,
         ...(options.now ? { now: options.now } : {}),
         memoryInstall: memory.receipt,
     });

package/dist/commands/issue.js

@@ -28,7 +28,7 @@
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
 import { writeLine } from "./cli-io.js";
 import { assigneeLabel, beginAssigneeDirectoryFetch, finishAssigneeDirectory, withAssigneeIdentity } from "./issue-directory.js";
-import { cacheAgeLabel, readThroughCache } from "./read-cache.js";
+import { cacheAgeLabel, cacheCoverage, readThroughCache } from "./read-cache.js";
 import { showIssue } from "./issue-show.js";
 import { READ_DEADLINE_MS, TAG, resolveProjectId, sizeForEstimate, withSizeLabel, } from "./issue-contracts.js";
 import { commentIssue, createIssue, moveIssue, updateIssue } from "./issue-write.js";
@@ -154,11 +154,15 @@ async function listIssues(command, door) {
     if (door.json) {
         return emitAgentDoor(door, {
             ok: true,
+            ...(body.counts ? { counts: body.counts } : {}),
+            ...cacheCoverage(answer),
             issues: issues.map((issue) => withSizeLabel(withAssigneeIdentity(issue, directory))),
             ...(body.completeness ? { completeness: body.completeness } : {}),
             ...(body.outside_project ? { outside_project: body.outside_project } : {}),
         });
     }
+    if (body.counts)
+        writeLine(door.io.stdout, `${body.counts.total} match in all. ${body.counts.coverage}`);
     if (issues.length === 0) {
         writeLine(door.io.stdout, "No issues match that.");
         return 0;

package/dist/commands/local-args-collector-setup.js

@@ -100,6 +100,7 @@ export function parseDoctorArgs(alias, args) {
             "--dry-run",
             "--check",
             "--no-repair",
+            "--no-usage-telemetry",
             "--lock-wait",
             "--backfill-budget",
             "--json",
@@ -141,6 +142,7 @@ export function parseDoctorArgs(alias, args) {
     }
     return {
         kind: "doctor",
+        noUsageTelemetry: values.booleans.has("--no-usage-telemetry"),
         checkOnly: values.booleans.has("--check") || values.booleans.has("--no-repair"),
         // Absent stays absent (BLI-11101): `doctor-budget.ts` owns the defaults,
         // and `--json` without either flag runs under one bounded budget.

package/dist/commands/local-args-tower-brain.js

@@ -13,12 +13,12 @@ import { optionalNonEmpty, optionalUrl, parseNamedArgs } from "./local-arg-value
 export const BRAIN_SHOW_STATUSES = ["open", "running", "needs_human", "fixed", "not_actionable", "cleared"];
 export function parseBrainArgs(args) {
     const values = parseNamedArgs(args, {
-        allowedFlags: ["--project", "--show", "--home", "--dashboard-url", "--json"],
-        valueFlags: ["--project", "--show", "--home", "--dashboard-url"],
+        allowedFlags: ["--project", "--show", "--home", "--dashboard-url", "--json", "--all-needs-human", "--reason"],
+        valueFlags: ["--project", "--show", "--home", "--dashboard-url", "--reason"],
     });
     const action = values.positionals[0];
-    if (action !== "status" || values.positionals.length > 1) {
-        throw new Error("brain takes one verb: `status`. Example: `cockpit brain status` or `cockpit brain status --project pearl-portal`.");
+    if ((action !== "status" && action !== "retry") || (action === "status" && values.positionals.length > 1)) {
+        throw new Error("brain takes one verb: `status` or `retry`. Example: `cockpit brain status` or `cockpit brain status --project pearl-portal`.");
     }
     const project = optionalNonEmpty(values.flags.get("--project"));
     if (project && !LOG_PROJECT_PATTERN.test(project))
@@ -26,9 +26,25 @@ export function parseBrainArgs(args) {
     const show = optionalNonEmpty(values.flags.get("--show"));
     if (show && !BRAIN_SHOW_STATUSES.includes(show))
         throw new Error(`--show wants one of ${BRAIN_SHOW_STATUSES.join(", ")}.`);
+    const ids = values.positionals.slice(1);
+    const reason = optionalNonEmpty(values.flags.get("--reason"))?.trim();
+    const allNeedsHuman = values.booleans.has("--all-needs-human");
+    if (action === "retry") {
+        if (!reason || reason.length > 4000)
+            throw new Error("--reason requires text (at most 4000 characters).");
+        if (!ids.length && !allNeedsHuman)
+            throw new Error("retry requires incident ids or --all-needs-human.");
+        if (ids.length > 100 || ids.some(id => !/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|BLI-[0-9]+)$/i.test(id)))
+            throw new Error("retry wants incident UUIDs or BLI issue identifiers (at most 100).");
+        if (show)
+            throw new Error("--show belongs to brain status.");
+    }
+    else if (reason || allNeedsHuman)
+        throw new Error("--reason and --all-needs-human belong to brain retry.");
     return {
         kind: "brain",
-        action: "status",
+        action,
+        ...(action === "retry" ? { ids, reason, allNeedsHuman } : {}),
         ...(project ? { project } : {}),
         ...(show ? { show } : {}),
         dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),

package/dist/commands/local-help-commands-tower-ops.js

@@ -49,6 +49,10 @@ export const TOWER_OPS_COMMAND_HELP = [
         [
             "Usage: cockpit brain status [--project <id>] [--show open|running|needs_human|fixed|not_actionable|cleared] [--dashboard-url <url>] [--json]",
             "",
+            "Retry: cockpit brain retry <id...> [--all-needs-human] [--project <p>] --reason <text> [--json]",
+            "Ids are incident UUIDs or BLI issue identifiers. Retry reopens needs_human or not_actionable rows, resets attempts and claims,",
+            "and records who, why and when. --all-needs-human selects only needs_human; --project narrows every selection. Other states are skipped.",
+            "Only members and super admins can retry. One comment is posted per incident issue. MCP twin: brain_retry.",
             "Tower's incident queue. Every 15 minutes the log-digest cron turns each recurring problem in a project's logs (classes",
             "our_bug, config_drift, capacity, unknown) into ONE incident with ONE Tower issue; a repeat adds to its count, never a twin.",
             "A template quiet for 24 hours is marked cleared. This prints, per project, how many incidents are open, being worked,",

package/dist/commands/local-help-commands.js

@@ -89,11 +89,12 @@ export function localSubcommandHelp(command) {
         [
             "doctor",
             [
-                "Usage: cockpit doctor [--workspace <path>] [--check | --no-repair] [--lock-wait <seconds>] [--backfill-budget <seconds>] [--json]",
+                "Usage: cockpit doctor [--workspace <path>] [--check | --no-repair] [--no-usage-telemetry] [--lock-wait <seconds>] [--backfill-budget <seconds>] [--json]",
                 "",
                 "Diagnose, repair, and verify this machine.",
                 "Repairs CLI, background sync, sign-in, roots, memory and hooks, agent rules, catch-up, uploads, and cleanup.",
                 "roots-cover-work is informational: it names how many sessions are inside vs. outside saved roots (all already uploaded, outside ones labelled) and gives cockpit roots add commands for widening a root's redacted transcript content. It never needs a fix.",
+                "--no-usage-telemetry switches off Claude Code and Codex usage export, including later doctor runs.",
                 "--check or --no-repair diagnoses without repairs. --dry-run previews repairs.",
                 "--backfill-budget defaults to 900 seconds; catch-up repeats chunks until complete, with progress every 30 seconds.",
                 "Doctor never waits for the background sync: a running sync is reported as running (with how long ago it started) and doctor finishes; a sync that stopped responding or made no progress for 15 minutes is ended and doctor carries on. --lock-wait is accepted and changes nothing. Progress prints at most every 30 seconds and says what changed.",

package/dist/commands/mail.js

@@ -26,7 +26,7 @@ import { writeFile } from "node:fs/promises";
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
 import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
 import { composeMessage, failAttachmentsUnconfirmed, readMailBody, runMailDraft, unconfirmedAttachments, } from "./mail-compose.js";
-import { cacheAgeLabel, readThroughCache } from "./read-cache.js";
+import { cacheAgeLabel, cacheCoverage, readThroughCache } from "./read-cache.js";
 import { towerRequest } from "../tower-client.js";
 const TAG = "[mail cli]";
 const READ_DEADLINE_MS = 30_000;
@@ -177,7 +177,7 @@ async function inbox(command, door) {
         return failAgentDoor(door, TAG, answer.reason, answer.detail);
     const body = answer.body;
     if (door.json)
-        return emitAgentDoor(door, { ok: true, ...body });
+        return emitAgentDoor(door, { ok: true, ...body, ...cacheCoverage(answer) });
     if (answer.fromCache) {
         writeLine(door.io.stderr, `(${cacheAgeLabel(answer.ageMs ?? 0)}, refreshing in the background)`);
     }

package/dist/commands/memory-install-files.js

@@ -16,7 +16,7 @@ import { chmod, mkdir, readFile, rename, stat, unlink, writeFile, } from "node:f
 import path from "node:path";
 import { randomBytes } from "node:crypto";
 import { describeError, isMissingFileFailure } from "../health-detail.js";
-export function defaultMemoryFileIo() {
+export function defaultMemoryFileIo(options = {}) {
     return {
         async readText(file) {
             try {
@@ -40,9 +40,10 @@ export function defaultMemoryFileIo() {
                 .then((info) => info.mode & 0o777)
                 .catch(() => null);
             try {
-                await writeFile(staged, contents, "utf8");
-                if (existingMode !== null)
-                    await chmod(staged, existingMode);
+                await writeFile(staged, contents, { encoding: "utf8", ...(options.mode !== undefined ? { mode: options.mode } : {}) });
+                const targetMode = options.mode ?? existingMode;
+                if (targetMode !== null)
+                    await chmod(staged, targetMode);
                 await rename(staged, file);
             }
             catch (error) {
@@ -53,10 +54,12 @@ export function defaultMemoryFileIo() {
                 console.error("[memory-install] staged write could not be renamed; writing in place", JSON.stringify({
                     reason: "staged_rename_failed",
                     byte_size: contents.length,
-                    ...describeError(error),
+                    ...(options.mode !== undefined ? { error_name: error instanceof Error ? error.name : "unknown" } : describeError(error)),
                 }));
                 await unlink(staged).catch(() => undefined);
-                await writeFile(file, contents, "utf8");
+                await writeFile(file, contents, { encoding: "utf8", ...(options.mode !== undefined ? { mode: options.mode } : {}) });
+                if (options.mode !== undefined)
+                    await chmod(file, options.mode);
             }
         },
     };

package/dist/commands/memory-install-receipt.js

@@ -208,11 +208,9 @@ export async function readMemoryReceiptFile(options) {
     if (!receipt)
         return { receipt: null, reason: "receipt_unparseable" };
     const age = (options.now ?? new Date()).getTime() - Date.parse(receipt.checked_at);
-    // A reading a week old is not a reading. Better to send nothing and let the
-    // board say "not reported" than to publish a claim about a machine that has
-    // not been looked at since.
+    // Keep last-known host facts, with the original checked_at and reason.
     if (Number.isFinite(age) && age > MEMORY_RECEIPT_MAX_AGE_MS) {
-        return { receipt: null, reason: "receipt_expired" };
+        return { receipt, reason: "receipt_expired" };
     }
     return { receipt, reason: "receipt_read" };
 }

package/dist/commands/memory-store.js

@@ -49,7 +49,7 @@ import { resolveContainerTag } from "@bli-cockpit/memory-mcp/dist/container-tag.
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
 import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
 import { runMemoryConsolidation } from "./memory-consolidation.js";
-import { cacheAgeLabel, readThroughCache } from "./read-cache.js";
+import { cacheAgeLabel, cacheCoverage, readThroughCache } from "./read-cache.js";
 import { runMemoryRequeue } from "./memory-requeue.js";
 import { runMemoryVisibility } from "./memory-visibility.js";
 import { readNoteFile } from "./notes-file.js";
@@ -194,7 +194,7 @@ async function searchMemory(command, door) {
         degraded: body.degraded ?? null,
     })}`);
     if (door.json)
-        return emitAgentDoor(door, answer.body);
+        return emitAgentDoor(door, { ...answer.body, ...cacheCoverage(answer) });
     if (answer.fromCache) {
         writeLine(door.io.stderr, `(${cacheAgeLabel(answer.ageMs ?? 0)}, refreshing in the background)`);
     }

package/dist/commands/msg.js

@@ -17,7 +17,7 @@
  */
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
 import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
-import { cacheAgeLabel, readThroughCache } from "./read-cache.js";
+import { cacheAgeLabel, cacheCoverage, readThroughCache } from "./read-cache.js";
 const TAG = "[msg cli]";
 const READ_DEADLINE_MS = 30_000;
 const WRITE_DEADLINE_MS = 30_000;
@@ -64,6 +64,7 @@ async function fetchChannels(door) {
         channels: answer.body.channels ?? [],
         fromCache: answer.fromCache,
         ageMs: answer.ageMs,
+        coverage: answer.coverage,
     };
 }
 async function listChannels(door) {
@@ -71,7 +72,7 @@ async function listChannels(door) {
     if (!fetched.ok)
         return failAgentDoor(door, TAG, fetched.reason, fetched.detail);
     if (door.json)
-        return emitAgentDoor(door, { ok: true, channels: fetched.channels });
+        return emitAgentDoor(door, { ok: true, channels: fetched.channels, ...cacheCoverage(fetched) });
     if (fetched.fromCache) {
         writeLine(door.io.stderr, `(${cacheAgeLabel(fetched.ageMs ?? 0)}, refreshing in the background)`);
     }

package/dist/commands/notes-folders.js

@@ -31,5 +31,7 @@ export async function runFolderCommand(command, door) {
             const label = command.tree ? `${"  ".repeat(folder.path.split("/").length - 1)}${folder.name}` : folder.path;
             writeLine(door.io.stdout, `${label} (${folder.note_count})`);
         }
+    if (body.coverage)
+        writeLine(door.io.stdout, body.coverage);
     return 0;
 }

package/dist/commands/public-root.js

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

package/dist/commands/read-cache.js

@@ -6,7 +6,7 @@
  * Text mode: a cache hit prints INSTANTLY (its age travels with it), then a
  * background refresh is spawned so the next call is live — never blocking
  * this process on a network round trip it already has a recent answer for.
- * `--json` (an agent, not a person) trusts cache only under
+ * `--json` attempts live first when the cache is older than
  * `JSON_FRESH_BOUND_MS`, unless `--allow-stale` says otherwise; older than
  * that runs the live request inline, same as a miss. `--fresh` skips the
  * read entirely — both flags are process-wide (BLI-10450's `--quiet`
@@ -73,7 +73,7 @@ export async function readThroughCache(options) {
                 else {
                     log(`[read-cache] refresh skipped ${JSON.stringify({ reason: "too_recent", age_ms: ageMs })}`);
                 }
-                return { ok: true, httpStatus: cached.status, body: cached.body, fromCache: true, ageMs };
+                return { ok: true, httpStatus: cached.status, body: cached.body, fromCache: true, ageMs, coverage: cacheAgeLabel(ageMs) };
             }
             log(`[read-cache] too stale for --json ${JSON.stringify({ surface: options.surface, label: options.label, age_ms: ageMs })}`);
         }
@@ -86,6 +86,18 @@ export async function readThroughCache(options) {
         writeReadCacheEntryAtomic(entryPath, { status: live.httpStatus, body: live.body });
         log(`[read-cache] refreshed ${JSON.stringify({ surface: options.surface, label: options.label })}`);
     }
+    else if (!fresh && live.httpStatus !== 401 && live.httpStatus !== 403) {
+        const cached = readReadCacheEntry(entryPath);
+        if (cached) {
+            const ageMs = Date.now() - cached.storedAt;
+            const coverage = `served stale: ${cacheAgeLabel(ageMs)}, live failed: ${live.reason}`;
+            log(`[read-cache] ${coverage} ${JSON.stringify({ reason: live.reason, age_ms: ageMs })}`);
+            const body = cached.body && typeof cached.body === "object" && !Array.isArray(cached.body)
+                ? { ...cached.body, cache_coverage: coverage, cache_age_ms: ageMs, live_failure_reason: live.reason }
+                : cached.body;
+            return { ok: true, httpStatus: cached.status, body, fromCache: true, ageMs, coverage };
+        }
+    }
     return { ...live, fromCache: false, ageMs: null };
 }
 /**
@@ -112,4 +124,8 @@ export function spawnBackgroundRefresh(io, log, spawnImpl = spawn) {
     catch (error) {
         log(`[read-cache] background refresh failed to spawn ${JSON.stringify({ reason: error instanceof Error ? error.name : "unknown" })}`);
     }
+}
+/** JSON readers carry the same age sentence as the terminal. */
+export function cacheCoverage(answer) {
+    return answer.fromCache ? { fromCache: true, ageMs: answer.ageMs, cache_coverage: answer.coverage ?? cacheAgeLabel(answer.ageMs ?? 0) } : {};
 }

package/dist/commands/settings.js

@@ -20,7 +20,7 @@
  * being written to stdout, stderr, or an argument vector.
  */
 import { isInteractiveStdin, readLine, settleYesNo, writeLine } from "./cli-io.js";
-import { cacheAgeLabel, readThroughCache } from "./read-cache.js";
+import { cacheAgeLabel, cacheCoverage, readThroughCache } from "./read-cache.js";
 import { asList, asRecord, callTower, isForbidden, openTower, parseModelKey, readAllStdin, writeCommandFailure, } from "./tower-command.js";
 import { showOverview } from "./settings-overview.js";
 import { renderCliFloor, renderEnvBlobs, renderModelRouting, renderPersonal, renderSwitches, } from "./settings-render.js";
@@ -75,7 +75,7 @@ async function showPersonal(command, tower, io) {
     if (result.fromCache && !command.json) {
         writeLine(io.stderr, `(${cacheAgeLabel(result.ageMs ?? 0)}, refreshing in the background)`);
     }
-    return writeBody(io, command.json, result.body, () => renderPersonal(asRecord(result.body)));
+    return writeBody(io, command.json, { ...asRecord(result.body), ...cacheCoverage(result) }, () => renderPersonal(asRecord(result.body)));
 }
 async function setPersonal(command, tower, io) {
     const result = await callTower(tower, {

package/dist/commands/setup-receipt-lines.js

@@ -10,6 +10,8 @@
  * gets ONE command or ONE click, never a paragraph and never "see the docs".
  */
 import { setupPieceMark, setupReceiptLine, setupReceiptPieces, } from "@bli-cockpit/telemetry-core";
+/** Cached host facts are old after the same seven-day window as their readers. */
+const OLD_READING_MS = 7 * 24 * 60 * 60 * 1000;
 /** The one fix for each piece, by key. Present for every key the block prints. */
 const FIXES = {
     browser: "Run `cockpit login` and open the link it prints.",
@@ -57,8 +59,18 @@ export function setupReceiptBlock(reading, options = {}) {
             continue;
         lines.push(`${indent}  ${label} ${setupPieceMark(piece.status)}${reasonSuffix(piece)} — ${fixFor(key, piece)}`);
     }
-    if (options.showCheckedAt) {
-        lines.push(`${indent}Last read: ${receipt.checked_at}`);
+    const now = reading.readAt ? Date.parse(reading.readAt) : Date.now();
+    const ageMs = now - Date.parse(receipt.checked_at);
+    if (options.showCheckedAt || reading.refreshFailure || !Number.isFinite(ageMs) || ageMs > OLD_READING_MS) {
+        const age = Number.isFinite(ageMs) ? `${Math.max(0, Math.floor(ageMs / 3_600_000))}h ago` : "age unavailable";
+        lines.push(`${indent}As of ${receipt.checked_at} (${age})${reading.refreshFailure ? `; this run could not re-read the machine: ${reading.refreshFailure}` : ""}`);
+    }
+    if (memory) {
+        const memoryAgeMs = now - Date.parse(memory.checked_at);
+        if (!Number.isFinite(memoryAgeMs) || memoryAgeMs > OLD_READING_MS) {
+            const age = Number.isFinite(memoryAgeMs) ? `${Math.max(0, Math.floor(memoryAgeMs / 3_600_000))}h ago` : "age unavailable";
+            lines.push(`${indent}Agent hosts as of ${memory.checked_at} (${age})`);
+        }
     }
     return lines;
 }

package/dist/commands/setup-receipt.js

@@ -39,7 +39,7 @@
  * owns the target vocabulary this translates from.
  */
 import os from "node:os";
-import { SETUP_RECEIPT_SCHEMA_VERSION, setupReceiptGaps, setupReceiptLine, } from "@bli-cockpit/telemetry-core";
+import { SETUP_RECEIPT_SCHEMA_VERSION, SetupReceiptSchema, setupReceiptGaps, setupReceiptLine, } from "@bli-cockpit/telemetry-core";
 import { readHeartbeatMemoryReceipt } from "./heartbeat.js";
 import { autostartSetupPiece, readAutostartRegistration, } from "./autostart-reading.js";
 import { readLocalSessionReference } from "../local-state.js";
@@ -89,7 +89,7 @@ export async function buildSetupReceipt(io, options = {}) {
         gaps,
         memory_receipt: memory ? "read" : "absent",
     }));
-    return { receipt, memory };
+    return { receipt, memory, readAt: checkedAt };
 }
 function withDefaultProbes(io, homeDir, options) {
     return {
@@ -167,8 +167,8 @@ export async function cacheSetupReceipt(receipt, homeDir) {
 }
 /**
  * The cached receipt, or null with a named reason. A receipt older than
- * `SETUP_RECEIPT_MAX_AGE_MS` is refused rather than sent: a stale word is
- * worse than an absent one, because absence asks and staleness answers.
+ * `SETUP_RECEIPT_MAX_AGE_MS` is logged as stale and sent with its original
+ * checked_at; readers show its age rather than discarding the last reading.
  */
 export async function readCachedSetupReceipt(homeDir, now = new Date()) {
     let raw;
@@ -187,8 +187,7 @@ export async function readCachedSetupReceipt(homeDir, now = new Date()) {
     }
     const age = now.getTime() - Date.parse(parsed.checked_at);
     if (!Number.isFinite(age) || age > SETUP_RECEIPT_MAX_AGE_MS) {
-        console.error(`${TAG} cache too old to send`, JSON.stringify({ reason: "cache_stale", age_days: Math.round(age / 86_400_000) }));
-        return null;
+        console.error(`${TAG} serving old cache`, JSON.stringify({ reason: "cache_stale", age_days: Math.round(age / 86_400_000) }));
     }
     return parsed;
 }
@@ -196,7 +195,8 @@ function safeParseReceipt(raw) {
     const record = raw;
     if (!record || record.schema_version !== SETUP_RECEIPT_SCHEMA_VERSION)
         return null;
-    return raw;
+    const parsed = SetupReceiptSchema.safeParse(raw);
+    return parsed.success ? parsed.data : null;
 }
 /** The one line, plus the one fix per gap. Rendering lives in `setup-receipt-lines.ts`. */
 export { setupReceiptLine };
@@ -212,11 +212,23 @@ export { setupReceiptLine };
 export async function refreshSetupReceipt(io, options = {}) {
     try {
         const reading = await buildSetupReceipt(io, options);
+        const probeFailed = [reading.receipt.browser, reading.receipt.device, reading.receipt.collector.autostart].some(piece => piece.reason?.endsWith("probe_failed"));
+        if (probeFailed) {
+            const cached = await readCachedSetupReceipt(options.homeDir, options.now);
+            if (cached) {
+                console.error(`${TAG} could not be computed`, JSON.stringify({ reason: "receipt_build_failed" }));
+                return { receipt: cached, memory: reading.memory, readAt: reading.readAt, refreshFailure: "receipt_build_failed" };
+            }
+        }
         await cacheSetupReceipt(reading.receipt, options.homeDir);
         return reading;
     }
     catch (error) {
         console.error(`${TAG} could not be computed`, JSON.stringify({ reason: "receipt_build_failed", error_name: errorName(error) }));
-        return null;
+        const receipt = await readCachedSetupReceipt(options.homeDir, options.now);
+        if (!receipt)
+            return null;
+        const memory = await readHeartbeatMemoryReceipt({ homeDir: options.homeDir, now: options.now });
+        return { receipt, memory: memory.receipt, readAt: (options.now ?? new Date()).toISOString(), refreshFailure: "receipt_build_failed" };
     }
 }

package/dist/commands/setup.js

@@ -15,11 +15,16 @@ export async function runSetup(command, io) {
     if (door.json)
         return emitAgentDoor(door, answer.body);
     const body = answer.body;
-    const number = (value) => value === null ? "unknown" : value.toLocaleString(undefined, { maximumFractionDigits: 1 });
+    const number = (value) => value === null ? "n/a" : value.toLocaleString(undefined, { maximumFractionDigits: 1 });
+    // BLI-13066: the server writes what each number rests on (the share of sessions counted, the sessions judged), so the CLI, the web page and JARVIS say the same words. An older server sends none.
+    const coverage = (words) => words ? ` (${words})` : "";
     for (const person of body.people ?? []) {
-        writeLine(io.stdout, `${person.rank ? `#${person.rank} ` : "Unranked · "}${person.display_name ?? person.email ?? "Unknown person"}: ${number(person.prs_per_week)} merged PRs/week · ${number(person.tokens_per_pr)} tokens/merged PR · ${person.yield === null ? "unknown yield" : `${number(person.yield * 100)}% session yield`}`);
+        writeLine(io.stdout, `${person.rank ? `#${person.rank} ` : "Unranked · "}${person.display_name ?? person.email ?? "Unknown person"}: ${number(person.prs_per_week)} merged PRs/week · ${number(person.tokens_per_pr)} tokens/merged PR${coverage(person.coverage_words?.tokens)} · ${person.yield === null ? "no session judged yet" : `${number(person.yield * 100)}% session yield`}${coverage(person.coverage_words?.yield)}`);
         if (person.tokens_basis)
             writeLine(io.stdout, `  Token basis: ${person.tokens_basis === "total_fallback" ? "total (input/cache breakdown unavailable)" : "input + output, excluding cache reads"}`);
+        // What they really ran and used over the window (BLI-13067); a read that did not answer says so.
+        writeLine(io.stdout, `  Tokens by model: ${person.model_use?.words ?? "not available right now."}`);
+        writeLine(io.stdout, `  Skills used: ${person.skill_use?.words ?? "not available right now."}`);
         if (!person.machines.length)
             writeLine(io.stdout, "  No setup received.");
         for (const machine of person.machines) {
@@ -39,7 +44,12 @@ export async function runSetup(command, io) {
         writeLine(io.stdout, `${pair.first ?? "Unknown person"} / ${pair.second ?? "Unknown person"}`);
         for (const difference of command.details ? [...pair.differences, ...(pair.details ?? [])] : pair.differences)
             writeLine(io.stdout, `  ${difference}`);
+        for (const side of ["first", "second"])
+            if (pair.use?.[side])
+                writeLine(io.stdout, `  ${side === "first" ? pair.first : pair.second}: tokens by model: ${pair.use[side].models ?? "not available right now."} Skills used: ${pair.use[side].skills ?? "not available right now."}`);
     }
+    for (const line of body.read_coverage ?? [])
+        writeLine(io.stdout, line);
     if (body.note)
         writeLine(io.stdout, body.note);
     return 0;

package/dist/commands/status.js

@@ -1,11 +1,5 @@
 /**
- * `cockpit status` — what this machine believes about itself: install, pairing,
- * active work, upload state, retry backlog, and how far historical backfill
- * has got.
  *
- * 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.
  *
@@ -131,7 +125,7 @@ function writeSingleRepoLines(io, status, backfillCursor, setupReceipt, disk) {
     if (status.linear_ticket_id)
         writeLine(io.stdout, `Linear: ${status.linear_ticket_id}`);
     writeLine(io.stdout, `Work: ${displayWorkLabel(status)}`);
-    writeLine(io.stdout, `Last collected: ${lastCollectedLine(status.collector_freshness)}`);
+    writeLine(io.stdout, `Last collected: ${lastCollectedLine(status.collector_freshness, status.last_collected_at)}`);
     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"}`);
@@ -239,7 +233,14 @@ function signedInLine(sessionState) {
             return "cannot tell";
     }
 }
-function lastCollectedLine(freshness) {
+export function lastCollectedLine(freshness, timestamp) {
+    if (timestamp) {
+        const ageMs = Date.now() - Date.parse(timestamp);
+        const minutes = Math.max(0, Math.floor(ageMs / 60_000));
+        const age = minutes < 60 ? `${minutes}m` : minutes < 1440 ? `${Math.floor(minutes / 60)}h` : `${Math.floor(minutes / 1440)}d`;
+        const label = lastCollectedLine(freshness);
+        return `${label} (${timestamp}; ${age} ago)`;
+    }
     switch (freshness) {
         case "fresh":
             return "recently";

package/dist/commands/usage-format.js

@@ -41,6 +41,7 @@ export function githubWords(github, people) {
         `GitHub: ${noun(sum("pull_requests_opened"), "pull request")} opened, ${sum("pull_requests_merged")} merged, ${noun(sum("commits"), "commit")}, ` +
             `from ${noun((github.repositories ?? []).length, "mirrored repository", "mirrored repositories")}${range}.`,
     ];
+    lines.push(...(github.read_coverage ?? []));
     const unmatched = github.unattributed;
     if (unmatched && unmatched.pull_requests_opened + unmatched.pull_requests_merged + unmatched.commits > 0) {
         lines.push(`Not matched to a person: ${noun(unmatched.pull_requests_opened, "pull request")} opened, ${unmatched.pull_requests_merged} merged, ${noun(unmatched.commits, "commit")}.`);

package/dist/commands/usage-telemetry-toml.js

@@ -0,0 +1,116 @@
+import { findTomlTableSpan, upsertTomlTable } from "./memory-install-toml.js";
+const render = (value) => typeof value === "string" ? value : `{ ${Object.entries(value).map(([k, v]) => `${k} = ${render(v)}`).join(", ")} }`;
+/** Split inline TOML at commas outside strings/nested arrays/tables. Keep unknown values verbatim. */
+function splitEntries(text) {
+    const entries = [];
+    let start = 0, depth = 0, quote = "", escaped = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (quote) {
+            if (escaped)
+                escaped = false;
+            else if (c === "\\" && quote === '"')
+                escaped = true;
+            else if (c === quote)
+                quote = "";
+        }
+        else if (c === '"' || c === "'")
+            quote = c;
+        else if (c === "{" || c === "[")
+            depth++;
+        else if (c === "}" || c === "]")
+            depth--;
+        else if (c === "," && depth === 0) {
+            entries.push(text.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    if (quote || depth !== 0)
+        throw new Error("config_unreadable");
+    entries.push(text.slice(start).trim());
+    return entries.filter(Boolean);
+}
+function mergeInline(previous, values) {
+    const raw = previous.trim();
+    if (!raw.startsWith("{"))
+        return render(values);
+    if (!raw.endsWith("}"))
+        throw new Error("config_unreadable");
+    const remaining = { ...values };
+    const entries = splitEntries(raw.slice(1, -1)).map(entry => {
+        const match = /^\s*([\w-]+|"[^"\n]+"|'[^'\n]+')\s*=\s*([\s\S]*)$/.exec(entry);
+        if (!match)
+            throw new Error("config_unreadable");
+        const key = match[1].replace(/^["']|["']$/g, "");
+        const value = remaining[key];
+        if (value === undefined)
+            return entry;
+        delete remaining[key];
+        return `${match[1]} = ${typeof value === "string" ? value : mergeInline(match[2], value)}`;
+    });
+    for (const [key, value] of Object.entries(remaining))
+        entries.push(`${key} = ${render(value)}`);
+    return `{ ${entries.join(", ")} }`;
+}
+/** Update only managed assignments; recurse through existing explicit subtables. */
+export function mergeUsageToml(text, tablePath, values) {
+    let next = text;
+    const local = {};
+    for (const [key, value] of Object.entries(values)) {
+        const childPath = [...tablePath, key].join(".");
+        const childExists = next.split("\n").some(line => {
+            const header = /^\s*\[([^\]]+)\]/.exec(line)?.[1].replace(/["']/g, "").replace(/\s/g, "");
+            return header === childPath || header?.startsWith(childPath + ".");
+        });
+        if (typeof value !== "string" && childExists)
+            next = mergeUsageToml(next, [...tablePath, key], value);
+        else
+            local[key] = value;
+    }
+    const span = findTomlTableSpan(next, tablePath);
+    if (!span)
+        return Object.keys(local).length ? upsertTomlTable(next, tablePath, `[${tablePath.join(".")}]\n${Object.entries(local).map(([k, v]) => `${k} = ${render(v)}`).join("\n")}`) : next;
+    const lines = next.split("\n");
+    const remaining = { ...local };
+    const body = lines.slice(span.start_line + 1, span.end_line).map(line => {
+        const match = /^(\s*)([\w-]+|"[^"\n]+"|'[^'\n]+')\s*=\s*(.*)$/.exec(line);
+        if (!match)
+            return line;
+        const key = match[2].replace(/^["']|["']$/g, "");
+        const value = remaining[key];
+        if (value === undefined)
+            return line;
+        delete remaining[key];
+        // Strip a trailing comment only outside a string or inline table.
+        const raw = match[3];
+        let quote = "", depth = 0, comment = raw.length, escaped = false;
+        for (let i = 0; i < raw.length; i++) {
+            const c = raw[i];
+            if (quote) {
+                if (escaped)
+                    escaped = false;
+                else if (c === "\\" && quote === '"')
+                    escaped = true;
+                else if (c === quote)
+                    quote = "";
+            }
+            else if (c === '"' || c === "'")
+                quote = c;
+            else if (c === "{" || c === "[")
+                depth++;
+            else if (c === "}" || c === "]")
+                depth--;
+            else if (c === "#" && depth === 0) {
+                comment = i;
+                break;
+            }
+        }
+        if (quote || depth !== 0)
+            throw new Error("config_unreadable");
+        const updated = typeof value === "string" ? value : mergeInline(raw.slice(0, comment), value);
+        return `${match[1]}${match[2]} = ${updated}${comment < raw.length ? ` ${raw.slice(comment)}` : ""}`;
+    });
+    for (const [key, value] of Object.entries(remaining))
+        body.push(`${key} = ${render(value)}`);
+    return [...lines.slice(0, span.start_line + 1), ...body, ...lines.slice(span.end_line)].join("\n");
+}

package/dist/commands/usage.js

@@ -116,6 +116,8 @@ export async function runUsage(command, io) {
     // date it cannot know.
     writeLine(io.stdout, "");
     writeLine(io.stdout, body.api_list_price_equivalent_label ?? "API list-price equivalent, not actual spend (this dashboard sent no price-sheet version)");
+    for (const line of body.read_coverage ?? [])
+        writeLine(io.stdout, line);
     writeLine(io.stdout, `${body.coverage?.sessions_extracted ?? 0} of ${body.coverage?.sessions_observed ?? 0} sessions extracted`);
     // BLI-4356: the gap says why. A session observed with no tokens is either
     // waiting on a count that has not run yet, or an automated one this view

package/dist/local-state-status.js

@@ -43,6 +43,10 @@ export async function inspectLocalCollectorStatus(options = {}) {
         worktree_fingerprint: context?.worktree_fingerprint ?? identity.worktree_fingerprint,
         worktree_is_primary: context?.worktree_is_primary ?? identity.worktree_is_primary,
         collector_freshness: freshness,
+        last_collected_at: (() => {
+            const timestamp = context ? latestTimestamp([context.updated_at ?? context.started_at, uploadSpool.last_upload_success_at]) : null;
+            return timestamp === null ? null : new Date(timestamp).toISOString();
+        })(),
         upload_state: uploadState,
         last_upload_attempt_at: uploadSpool.last_upload_attempt_at,
         last_upload_success_at: uploadSpool.last_upload_success_at,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.196",
+  "version": "0.2.198",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,9 +27,9 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-cli-verb-help.mjs && node ../../scripts/assert-public-cli-surface-doors.mjs && node ../../scripts/assert-public-cli-runtime-files.mjs && node ../../scripts/assert-public-cli-exit-contract.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-cli-doctor-json.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.59",
-    "@bli-cockpit/mcp": "0.1.108",
-    "@bli-cockpit/telemetry-core": "0.1.68"
+    "@bli-cockpit/memory-mcp": "0.1.60",
+    "@bli-cockpit/mcp": "0.1.110",
+    "@bli-cockpit/telemetry-core": "0.1.69"
   },
   "repository": {
     "type": "git",