@bli-cockpit/cli 0.2.179 → 0.2.183

package/dist/commands/notes-wisprflow-login.js

@@ -0,0 +1,219 @@
+/**
+ * `cockpit notes connect --provider wisprflow` — signing a person into Wispr
+ * Flow's MCP server from a terminal (BLI-12926).
+ *
+ * Wispr Flow has no API key for meetings. Its Notetaker is read through a
+ * remote MCP server behind OAuth (docs.wisprflow.ai, "Connect Claude, ChatGPT
+ * or another MCP client to Wispr Flow": "no API key or token is needed"). Its
+ * authorization server publishes, at
+ * `https://mcp-auth.wisprflow.com/.well-known/oauth-authorization-server`
+ * (read 2026-10-08), dynamic client registration, PKCE `S256`, a refresh-token
+ * grant and the RFC 8628 DEVICE grant. The device grant is the one a terminal
+ * can use: it prints an address and a short code, the person approves in their
+ * own browser (Google, Apple, Microsoft or company single sign-on; an
+ * email-and-password Wispr account cannot complete MCP authorization), and this
+ * file polls until Wispr hands back a refresh token.
+ *
+ * What leaves this machine: a client registration, then the device and token
+ * calls, all to Wispr's own authorization server. The refresh token goes into a
+ * bundle (`{ v, client_id, refresh_token }`) that `connect` posts to Tower's
+ * accounts door, which seals it. It is never printed, never written to a file
+ * and never put in a flag; `--json` shows the account, not the bundle.
+ *
+ * **No live call has been made from this code.** Every shape is the RFC's, and
+ * the first real sign-in is the proof. In particular it is NOT known whether
+ * Wispr's server accepts a dynamically registered client on the device grant
+ * (the document lists both, not that they combine); if it does not, the refusal
+ * below says what Wispr answered and `--key-stdin` accepts a bundle made by any
+ * other means.
+ *
+ * stdout carries nothing from here; every line is stderr commentary.
+ */
+import { writeLine } from "./cli-io.js";
+export const WISPRFLOW_AUTH_ISSUER = "https://mcp-auth.wisprflow.com";
+export const WISPRFLOW_MCP_RESOURCE = "https://api.wisprflow.ai/connect/mcp";
+const SCOPE = "openid offline_access";
+const DEVICE_GRANT = "urn:ietf:params:oauth:grant-type:device_code";
+const REQUEST_DEADLINE_MS = 30_000;
+/** RFC 8628: a client polls no faster than the server's interval, default 5 s. */
+const DEFAULT_INTERVAL_SECONDS = 5;
+/** Never wait on a person longer than this, whatever the server says. */
+const MAX_WAIT_SECONDS = 15 * 60;
+const TAG = "[notes wisprflow signin]";
+export async function signInToWisprflow(options) {
+    const { io } = options;
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const now = options.now ?? Date.now;
+    const metadata = await readMetadata(io);
+    if (!metadata.ok)
+        return metadata;
+    // 1. Register a client. A public client: no secret, only an id.
+    const registered = await postJson(io, metadata.value.registration_endpoint, {
+        client_name: "Tower (BLI) notes sync",
+        grant_types: [DEVICE_GRANT, "refresh_token"],
+        response_types: [],
+        token_endpoint_auth_method: "none",
+        scope: SCOPE,
+    });
+    if (!registered.ok)
+        return explain(io, "registration", registered);
+    const clientId = stringField(registered.body, "client_id");
+    if (!clientId) {
+        return { ok: false, reason: "wisprflow_registration_unusable", detail: "Wispr Flow accepted the registration but sent no client id." };
+    }
+    // 2. Ask for a code.
+    const device = await postForm(io, metadata.value.device_authorization_endpoint, {
+        client_id: clientId,
+        scope: SCOPE,
+        resource: WISPRFLOW_MCP_RESOURCE,
+    });
+    if (!device.ok)
+        return explain(io, "device code", device);
+    const deviceCode = stringField(device.body, "device_code");
+    const userCode = stringField(device.body, "user_code");
+    const address = stringField(device.body, "verification_uri_complete") ?? stringField(device.body, "verification_uri");
+    if (!deviceCode || !userCode || !address) {
+        return { ok: false, reason: "wisprflow_device_unusable", detail: "Wispr Flow's device answer was missing its code or its address." };
+    }
+    const waitSeconds = Math.min(numberField(device.body, "expires_in") ?? MAX_WAIT_SECONDS, MAX_WAIT_SECONDS);
+    let intervalMs = (numberField(device.body, "interval") ?? DEFAULT_INTERVAL_SECONDS) * 1000;
+    writeLine(io.stderr, "Sign in to Wispr Flow to let Tower read your meeting notes:");
+    writeLine(io.stderr, `  1. Open  ${address}`);
+    writeLine(io.stderr, `  2. If it asks, enter the code  ${userCode}`);
+    writeLine(io.stderr, "  Use the Wispr account that holds your notes, signed in with Google, Apple, Microsoft or company single sign-on.");
+    writeLine(io.stderr, `Waiting up to ${Math.round(waitSeconds / 60)} minutes for you to approve...`);
+    log(io, "waiting", { interval_s: intervalMs / 1000, wait_s: waitSeconds });
+    // 3. Poll.
+    const deadline = now() + waitSeconds * 1000;
+    while (now() < deadline) {
+        await sleep(intervalMs);
+        const polled = await postForm(io, metadata.value.token_endpoint, {
+            grant_type: DEVICE_GRANT,
+            device_code: deviceCode,
+            client_id: clientId,
+            resource: WISPRFLOW_MCP_RESOURCE,
+        });
+        if (polled.ok) {
+            const refreshToken = stringField(polled.body, "refresh_token");
+            if (!refreshToken) {
+                return {
+                    ok: false,
+                    reason: "wisprflow_no_offline_access",
+                    detail: "Wispr Flow signed you in but did not hand back a refresh token, so Tower could not read your meetings"
+                        + " every half hour without you. Nothing was connected.",
+                };
+            }
+            log(io, "signed in", { client_registered: true, refresh_token_received: true });
+            return {
+                ok: true,
+                bundle: JSON.stringify({ v: 1, client_id: clientId, refresh_token: refreshToken }),
+            };
+        }
+        const code = stringField(polled.body, "error");
+        if (code === "authorization_pending")
+            continue;
+        if (code === "slow_down") {
+            intervalMs += 5000;
+            continue;
+        }
+        if (code === "expired_token") {
+            return { ok: false, reason: "wisprflow_code_expired", detail: "The code expired before it was approved. Run the command again." };
+        }
+        if (code === "access_denied") {
+            return { ok: false, reason: "wisprflow_denied", detail: "Wispr Flow says the request was declined. Nothing was connected." };
+        }
+        return explain(io, "sign-in", polled);
+    }
+    return { ok: false, reason: "wisprflow_timed_out", detail: "Nobody approved the code in time. Run the command again." };
+}
+/** Metadata only: a step, a status and an OAuth error label. Never a code or a token. */
+function log(io, message, fields) {
+    writeLine(io.stderr, `${TAG} ${message} ${JSON.stringify(fields)}`);
+}
+async function readMetadata(io) {
+    const got = await send(io, `${WISPRFLOW_AUTH_ISSUER}/.well-known/oauth-authorization-server`, { method: "GET" });
+    if (!got.ok)
+        return explain(io, "discovery", got);
+    const registration = stringField(got.body, "registration_endpoint");
+    const device = stringField(got.body, "device_authorization_endpoint");
+    const token = stringField(got.body, "token_endpoint");
+    if (!registration || !device || !token) {
+        return {
+            ok: false,
+            reason: "wisprflow_discovery_changed",
+            detail: "Wispr Flow's sign-in no longer advertises client registration and the device flow. Tower cannot sign you in from a terminal until it does.",
+        };
+    }
+    // Every endpoint must stay on Wispr's own host: a discovery document that
+    // points the token call somewhere else is not one to send a code to.
+    for (const endpoint of [registration, device, token]) {
+        if (!endpoint.startsWith(`${WISPRFLOW_AUTH_ISSUER}/`)) {
+            return { ok: false, reason: "wisprflow_discovery_changed", detail: "Wispr Flow's sign-in points at a host Tower does not recognise, so nothing was sent." };
+        }
+    }
+    return { ok: true, value: { registration_endpoint: registration, device_authorization_endpoint: device, token_endpoint: token } };
+}
+async function postJson(io, url, body) {
+    return send(io, url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json" },
+        body: JSON.stringify(body),
+    });
+}
+async function postForm(io, url, body) {
+    return send(io, url, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
+        body: new URLSearchParams(body).toString(),
+    });
+}
+async function send(io, url, init) {
+    const call = io.fetch;
+    const controller = new AbortController();
+    const deadline = setTimeout(() => controller.abort(), REQUEST_DEADLINE_MS);
+    try {
+        const response = await call(url, { ...init, signal: controller.signal });
+        let body = null;
+        try {
+            body = await response.json();
+        }
+        catch {
+            body = null;
+        }
+        return response.ok ? { ok: true, body } : { ok: false, status: response.status, body, network: false };
+    }
+    catch {
+        return { ok: false, status: 0, body: null, network: true };
+    }
+    finally {
+        clearTimeout(deadline);
+    }
+}
+/** A refusal in the vendor's own words: its OAuth error label, never a body dump. */
+function explain(io, step, failure) {
+    if (failure.network) {
+        return { ok: false, reason: "wisprflow_unreachable", detail: `Could not reach Wispr Flow's sign-in during ${step}. Check the connection and try again.` };
+    }
+    const label = stringField(failure.body, "error");
+    const words = stringField(failure.body, "error_description");
+    log(io, "refused", { step, http_status: failure.status, oauth_error: label ?? "none" });
+    return {
+        ok: false,
+        reason: `wisprflow_${step.replace(/\s+/g, "_")}_refused`,
+        detail: `Wispr Flow refused the ${step} step (HTTP ${failure.status}${label ? `, ${label}` : ""}).`
+            + `${words ? ` It said: ${words.slice(0, 200)}` : ""}`
+            + " Nothing was connected.",
+    };
+}
+function stringField(body, name) {
+    if (typeof body !== "object" || body === null)
+        return null;
+    const value = body[name];
+    return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+function numberField(body, name) {
+    if (typeof body !== "object" || body === null)
+        return null;
+    const value = body[name];
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+}

package/dist/commands/notes.js

@@ -45,10 +45,12 @@ import { uploadNotes, pasteNote, shareNote, moveNote, placeNote } from "./notes-
 import { runFolderCommand } from "./notes-folders.js";
 import { armNotesWebhook, connectNotetaker, detachNotetaker, listNotesAccounts, showNotesWebhook, syncNotetaker, syncStatusNotetakers, } from "./notes-accounts.js";
 import { showGranolaStatus } from "./notes-granola-status.js";
+import { listRecordings, showRecording } from "./notes-recordings.js";
 export { listNotes, listShelves, showNote, showShelf } from "./notes-reads.js";
 export { uploadNotes, pasteNote, shareNote, moveNote, placeNote } from "./notes-writes.js";
 export { armNotesWebhook, connectNotetaker, detachNotetaker, listNotesAccounts, showNotesWebhook, syncNotetaker, syncStatusNotetakers, } from "./notes-accounts.js";
 export { showGranolaStatus } from "./notes-granola-status.js";
+export { listRecordings, showRecording } from "./notes-recordings.js";
 export { ask, emit, fail, sayUpload, sayScope, errorText, TAG, } from "./notes-door.js";
 export async function runNotes(command, io) {
     const session = await loadPairedSession("notes", command.homeDir);
@@ -98,6 +100,10 @@ export async function runNotes(command, io) {
             return syncNotetaker(command, door);
         case "sync-status":
             return syncStatusNotetakers(command, door);
+        case "recordings":
+            return listRecordings(command, door);
+        case "recording":
+            return showRecording(command, door);
         case "webhook":
             return armNotesWebhook(command, door);
         case "granola-status":

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

package/dist/commands/setup.js

@@ -0,0 +1,39 @@
+import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+export async function runSetup(command, io) {
+    const door = await openAgentDoor("setup", command, io);
+    const query = new URLSearchParams();
+    if (command.person)
+        query.set("person", command.person);
+    if (command.compare)
+        query.set("compare", command.compare);
+    const answer = await askAgentDoor(door, { method: "GET", path: `/api/setup?${query}`, label: "setup", timeoutMs: 30_000 });
+    if (!answer.ok)
+        return failAgentDoor(door, "[setup]", answer.reason, answer.detail);
+    if (door.json)
+        return emitAgentDoor(door, answer.body);
+    const body = answer.body;
+    const number = (value) => value === null ? "unknown" : value.toLocaleString(undefined, { maximumFractionDigits: 1 });
+    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`}`);
+        if (!person.machines.length)
+            writeLine(io.stdout, "  No setup received.");
+        for (const machine of person.machines) {
+            if (!machine.setup) {
+                writeLine(io.stdout, "  Setup is unknown.");
+                continue;
+            }
+            writeLine(io.stdout, `  ${machine.setup.os} · TOWER CLI ${machine.setup.cli_version}${machine.stale ? " · stale setup" : ""}`);
+            for (const tool of ["claude", "codex"])
+                writeLine(io.stdout, `  ${tool}: ${machine.setup[tool].model ?? "unknown model"}, ${machine.setup[tool].effort ?? "unknown effort"}`);
+        }
+    }
+    for (const pair of body.comparison ?? []) {
+        writeLine(io.stdout, `${pair.first ?? "Unknown person"} / ${pair.second ?? "Unknown person"}`);
+        for (const difference of pair.differences)
+            writeLine(io.stdout, `  ${difference}`);
+    }
+    if (body.note)
+        writeLine(io.stdout, body.note);
+    return 0;
+}

package/dist/commands/status.js

@@ -80,7 +80,7 @@ async function writeMultiRepoStatus(command, io, backfillCursor, setupReceipt, w
     writeLine(io.stdout, `Old sessions: ${backfillCursorLine(backfillCursor)}`);
     writeLine(io.stdout, await statusDiskLine(command.homeDir));
     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}`);
+        writeLine(io.stdout, `- ${status.repo_label ?? status.repo}/${status.worktree_label ?? "worktree"} · ${status.branch} · head:${shortSha(status.head_sha)} · ${uploadsLine(status.upload_state)}`);
     }
     writeConnectedBlock(io, setupReceipt);
     return 0;

package/dist/commands/sync-doctor-request.js

@@ -0,0 +1,13 @@
+/** Only a doctor request is accepted. Nothing from Tower is ever a command line. */
+let requestId = null;
+export function noteDoctorRequest(value) {
+    if (!value || typeof value !== "object")
+        return;
+    const request = value;
+    if (request.action === "doctor" && typeof request.request_id === "string" && /^[0-9a-f-]{36}$/u.test(request.request_id)) {
+        requestId = request.request_id;
+        console.error("[sync-doctor] request received", JSON.stringify({ reason: "doctor_requested", request_id: requestId }));
+    }
+}
+export function requestedDoctorId() { return requestId; }
+export function clearDoctorRequest() { requestId = null; }

package/dist/commands/sync-doctor.js

@@ -0,0 +1,145 @@
+/** Full, non-interactive doctor after collection, with a durable receipt retry. */
+import { shouldSuppressFleetReceipts } from "../dev-build.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Writable } from "node:stream";
+import { acquireBackfillLock } from "../backfill-lock.js";
+import { getCollectorRuntimePaths, readLocalCollectorSessionFile } from "../local-state.js";
+import { isAutostartOptedOut } from "../autostart-opt-out.js";
+import { runAutostartSelfHealAfterSync } from "./sync-followups-autostart.js";
+import { checkAutostartState } from "./doctor-registration.js";
+import { heartbeatRefusalStatus } from "./heartbeat-token.js";
+import { runDoctor } from "./doctor.js";
+import { doctorNeedsPerson, sanitizeEventCode } from "./doctor-report.js";
+import { runSelfUpdate } from "./install-update.js";
+import { reportInstallEventsBestEffort } from "./install-receipts.js";
+import { clearDoctorRequest, requestedDoctorId } from "./sync-doctor-request.js";
+export async function runDoctorAfterSync(command, io, dashboardUrl, overrides = {}, facts) {
+    if (shouldSuppressFleetReceipts({ dashboardUrl }).suppressed) {
+        console.error("[sync-doctor] checkout does not repair the fleet machine", JSON.stringify({ reason: "receipt_suppressed:dev_build" }));
+        return;
+    }
+    const paths = getCollectorRuntimePaths(command.homeDir);
+    // A separate namespace: holding this lock must not block doctor's backfill.
+    const lock = await acquireBackfillLock({ ...paths, cursors_dir: path.join(paths.state_dir, "doctor") }).catch(() => {
+        console.error("[sync-doctor] could not acquire its lock", JSON.stringify({ reason: "doctor_lock_failed" }));
+        return null;
+    });
+    if (!lock)
+        return;
+    if (!lock.acquired) {
+        console.error("[sync-doctor] another doctor is running", JSON.stringify({ reason: "doctor_running" }));
+        return;
+    }
+    const outbox = path.join(paths.state_dir, "doctor-receipt.json");
+    try {
+        const pending = await fs.readFile(outbox, "utf8").then((text) => JSON.parse(text)).catch((error) => {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        });
+        if (pending) {
+            if (!await postReceipt(pending, command, io, dashboardUrl))
+                return;
+            await fs.rm(outbox, { force: true });
+            if (pending.request_id === requestedDoctorId())
+                clearDoctorRequest();
+            // The completed requested run is never repeated just to resend its receipt.
+            if (pending.request_id)
+                return;
+        }
+        const requestId = requestedDoctorId();
+        const session = await readLocalCollectorSessionFile(paths).catch(() => null);
+        let receipt = null;
+        const quiet = new Writable({ write(_chunk, _encoding, done) { done(); } });
+        const doctorIo = { ...io, stdout: quiet };
+        await runDoctor({ kind: "doctor", alias: "doctor", automaticTick: true, homeDir: command.homeDir, dashboardUrl, json: true, dryRun: false }, doctorIo, {
+            selfUpdate: (updateIo, options) => runSelfUpdate({ ...updateIo, stdout: quiet }, options),
+            runLogin: async () => { throw new Error("automatic_doctor_cannot_prompt"); },
+            resolveAndSaveRoots: async () => { throw new Error("automatic_doctor_cannot_pick_folders"); },
+            reportInstallEvents: (options) => reportInstallEventsBestEffort({ ...options, homeDir: command.homeDir,
+                // Automatic receipts carry labels, never terminal instructions or paths.
+                events: options.events.map((event) => ({ step: event.step, status: event.status, ...(event.error_code ? { error_code: event.error_code } : {}) })),
+            }),
+            onReceipt: (rows, repairs, setup) => {
+                const actions = new Set();
+                for (const item of doctorNeedsPerson(rows, setup)) {
+                    if (item.step === "authed" && (!session?.device_token || [401, 403].includes(heartbeatRefusalStatus() ?? 0)))
+                        actions.add("browser_sign_in");
+                    if (item.step === "roots-ok")
+                        actions.add("folder_selection");
+                    if (item.step === "single-install")
+                        actions.add("duplicate_install");
+                    if (item.reason === "needs_trust" || item.action?.includes("/hooks"))
+                        actions.add("hook_trust");
+                    if (/permission|eacces|eperm|access_denied/u.test(item.reason))
+                        actions.add("os_permission");
+                }
+                receipt = {
+                    request_id: requestId, completed_at: new Date().toISOString(),
+                    status: rows.some((row) => row.status === "fail" || row.status === "needs_fix") || actions.size ? "attention" : "pass",
+                    repairs: repairs.map((repair) => ({ step: repair.step, before: safeVerdict(repair.before), after: safeVerdict(repair.after), fix_attempted: repair.fix_attempted ?? false })),
+                    person_actions: [...actions],
+                };
+            },
+        }, {
+            // The collection phase already ran. Never recurse through another sync.
+            checkSync: async () => ({ id: "sync-fresh", status: facts?.status === "fail" ? "needs_fix" : "skipped", code: facts?.status === "fail" ? "tick_collection_failed" : "tick_collection_reported", message: "This tick already reported its collection outcome; it retries on the next tick." }),
+            fixSync: async (context) => context.deps.checkSync(context),
+            checkAutostart: async (context) => await isAutostartOptedOut(paths)
+                ? { id: "autostart-alive", status: "skipped", code: "operator_uninstalled", message: "Background sync was deliberately turned off." }
+                : checkAutostartState(context),
+            fixAutostart: async (context) => {
+                // macOS uses the detached healer; Windows repairs in place. Neither
+                // overrides an explicit opt-out nor unloads this tick's macOS job.
+                await runAutostartSelfHealAfterSync(command, io, dashboardUrl);
+                return checkAutostartState(context);
+            },
+            ...overrides,
+        });
+        if (!receipt)
+            throw new Error("doctor_receipt_missing");
+        await fs.mkdir(paths.state_dir, { recursive: true, mode: 0o700 });
+        await fs.writeFile(`${outbox}.tmp`, JSON.stringify(receipt), { mode: 0o600 });
+        await fs.rename(`${outbox}.tmp`, outbox);
+        console.error("[sync-doctor] run complete", JSON.stringify({ reason: "receipt_saved", request_id: receipt.request_id, rows: receipt.repairs.length }));
+        if (await postReceipt(receipt, command, io, dashboardUrl)) {
+            await fs.rm(outbox, { force: true });
+            if (requestId === requestedDoctorId())
+                clearDoctorRequest();
+        }
+    }
+    catch (error) {
+        console.error("[sync-doctor] run will retry next tick", JSON.stringify({ reason: "doctor_followup_failed", error_name: error instanceof Error ? error.name : typeof error }));
+    }
+    finally {
+        await lock.handle.release();
+    }
+}
+function safeVerdict(value) {
+    const [status, code] = (value ?? "fail:receipt_missing").split(":");
+    return `${status}:${sanitizeEventCode(code ?? "receipt_missing")}`;
+}
+async function postReceipt(receipt, command, io, dashboardUrl) {
+    if (shouldSuppressFleetReceipts({ dashboardUrl }).suppressed) {
+        console.error("[sync-doctor] checkout receipt retained locally", JSON.stringify({ reason: "receipt_suppressed:dev_build" }));
+        return false;
+    }
+    const session = await readLocalCollectorSessionFile(getCollectorRuntimePaths(command.homeDir));
+    if (!session?.device_token || !session.device_id) {
+        console.error("[sync-doctor] receipt retained", JSON.stringify({ reason: "device_session_missing" }));
+        return false;
+    }
+    try {
+        const response = await io.fetch(`${dashboardUrl}/api/ambient/devices/${encodeURIComponent(session.device_id)}/doctor`, {
+            method: "PATCH", headers: { "Content-Type": "application/json", Authorization: `Bearer ${session.device_token}` },
+            body: JSON.stringify(receipt), signal: AbortSignal.timeout(5_000),
+        });
+        console.error("[sync-doctor] receipt delivery", JSON.stringify({ reason: response.ok ? "receipt_recorded" : "receipt_rejected", http_status: response.status, request_id: receipt.request_id }));
+        return response.ok;
+    }
+    catch {
+        console.error("[sync-doctor] receipt retained", JSON.stringify({ reason: "receipt_transport_failed", request_id: receipt.request_id }));
+        return false;
+    }
+}

package/dist/commands/sync.js

@@ -103,7 +103,7 @@ async function runSyncTick(command, io, tick) {
         // so it is what separates a quiet machine from a dead one.
         await tick.heartbeat(() => sendSyncHeartbeat(command, io, dashboardUrl, result.heartbeat));
         await tick.outcomeReport(() => reportTickOutcome(command, io, dashboardUrl, result.completion));
-        await tick.converge(() => convergeAfterTick(command, io, dashboardUrl));
+        await tick.converge(() => convergeAfterTick(command, io, dashboardUrl, result.heartbeat));
         // BLI-3619 / BLI-11106: every tick, the staged copies of whatever the
         // server just committed go; a follow-up never blocks or fails collection.
         await tick.prune(() => runStagingPruneAfterSync(command, io, dashboardUrl));
@@ -119,7 +119,7 @@ async function runSyncTick(command, io, tick) {
             reason: errorCode,
         }));
         await tick.outcomeReport(() => reportTickThrew(command, io, dashboardUrl, error, errorCode));
-        await tick.converge(() => convergeAfterTick(command, io, dashboardUrl));
+        await tick.converge(() => convergeAfterTick(command, io, dashboardUrl, { status: "fail", reason: errorCode }));
         await tick.prune(() => runStagingPruneAfterSync(command, io, dashboardUrl));
         throw error;
     }
@@ -186,11 +186,12 @@ async function reportTickThrew(command, io, dashboardUrl, error, errorCode) {
  * Memory's registration — each at most once a day, each with its own receipt,
  * and none of them able to block or fail collection (BLI-3580).
  */
-async function convergeAfterTick(command, io, dashboardUrl) {
+async function convergeAfterTick(command, io, dashboardUrl, facts) {
     await runAutostartSelfHealAfterSync(command, io, dashboardUrl);
     await runMemoryInstallAfterSync(command, io, dashboardUrl);
     // BLI-12828: the repairs `cockpit doctor` also makes (agent rules, a lapsed
     // sign-in), so nobody has to be told to run it.
     await runMachineHealAfterSync(command, io, dashboardUrl);
+    await io.runDoctorAfterSync?.(command, io, dashboardUrl, {}, facts);
     await runMemoryExperienceAfterSync({ ...command, dashboardUrl }, io);
 }

package/dist/commands/team.js

@@ -31,6 +31,8 @@ export async function runTeam(command, io) {
         return changeRole(command, tower, io);
     if (command.action === "device-list")
         return deviceList(command, tower, io);
+    if (command.action === "device-doctor")
+        return deviceDoctor(command, tower, io);
     return deviceRevoke(command, tower, io);
 }
 async function showMembers(command, tower, io) {
@@ -188,4 +190,21 @@ async function deviceRevoke(command, tower, io) {
     }
     writeLine(io.stdout, renderDeviceRevoked(body));
     return 0;
+}
+async function deviceDoctor(command, tower, io) {
+    const listed = await callTower(tower, { path: "/api/team/devices", label: "team device doctor lookup" });
+    if (!listed.ok)
+        return writeCommandFailure(io, command.json, listed);
+    const device = findDevice(devicesOf(asRecord(listed.body)), command.deviceRef ?? "");
+    if (!device)
+        return writeCommandFailure(io, command.json, { reason: "device_not_found", detail: "No unique device matches. Run cockpit team device list to see ids and names." });
+    const result = await callTower(tower, {
+        path: `/api/ambient/devices/${encodeURIComponent(device.device_id)}/doctor`,
+        method: "POST", label: "team device doctor", body: { action: "doctor" },
+    });
+    console.error("[team cli] device doctor", JSON.stringify({ device_id: device.device_id, reason: result.ok ? "requested" : result.reason }));
+    if (!result.ok)
+        return writeCommandFailure(io, command.json, result);
+    writeLine(io.stdout, command.json ? JSON.stringify({ ok: true, ...asRecord(result.body) }) : `Doctor requested for ${device.device_name ?? device.device_id}. Waiting for its next check-in.`);
+    return 0;
 }

package/dist/local-state-status.js

@@ -53,6 +53,7 @@ export async function inspectLocalCollectorStatus(options = {}) {
         oldest_pending_health_receipt_at: healthOutbox.oldest_created_at,
         last_health_receipt_failure_reason: healthOutbox.last_failure_reason,
         stuck_evidence_object_count: stuckEvidence.stuck_object_count,
+        stuck_evidence_ghost_record_count: stuckEvidence.ghost_record_count,
         stuck_evidence_held_count: stuckEvidence.held_object_count,
         stuck_evidence_max_attempts: stuckEvidence.max_attempts,
         stuck_evidence_oldest_failure_at: stuckEvidence.oldest_first_failed_at,
@@ -148,7 +149,7 @@ function describeCollectorStatus(reading) {
         details.push(`Last upload failure: ${uploadSpool.last_upload_failure_reason}.`);
     }
     if (uploadSpool.pending_upload_count > 0) {
-        details.push(`Upload retry pending: ${uploadSpool.pending_upload_count} safe metadata record(s) spooled. Run \`${uploadSpool.retry_command ?? "cockpit sync"}\` to retry.`);
+        details.push(`Upload retry pending: ${uploadSpool.pending_upload_count} safe metadata record(s) are saved on this machine and go out on the next background sync.`);
     }
     if (healthOutbox.pending_count > 0) {
         details.push(`Collector health retry pending: ${healthOutbox.pending_count} sanitized receipt(s) queued since ${healthOutbox.oldest_created_at ?? "unknown"}.`);
@@ -168,6 +169,9 @@ function describeCollectorStatus(reading) {
     if (stuckEvidence.stuck_object_count > 0) {
         details.push(`Raw evidence stuck: ${stuckEvidence.stuck_object_count} object(s) have never been accepted (${stuckEvidence.held_object_count} waiting on backoff, worst ${stuckEvidence.max_attempts} attempt(s) since ${stuckEvidence.oldest_first_failed_at ?? "unknown"}) — reasons: ${stuckEvidence.reasons.join(", ") || "unknown"}.`);
     }
+    if (stuckEvidence.ghost_record_count > 0) {
+        details.push(`${stuckEvidence.ghost_record_count} old delivery record(s) have nothing left to send; no action needed.`);
+    }
     return details;
 }
 /**

package/dist/raw-evidence-stuck-summary.js

@@ -20,7 +20,26 @@ import { deliveryRetryAtMs, terminalDeliveryReason } from "./raw-evidence-stagin
  * read green while an object has been failing for nine days.
  */
 export function summarizeStuckEvidence(state, now) {
-    const entries = Object.values(state.delivery_attempts).filter(entry => !terminalDeliveryReason(entry.last_reason));
+    const entries = [];
+    let ghostCount = 0;
+    for (const [hash, entry] of Object.entries(state.delivery_attempts)) {
+        if (terminalDeliveryReason(entry.last_reason))
+            continue;
+        // A row whose object left staging (pruned after commit, or reconciled by a
+        // committed 409) has nothing to offer; counting it as stuck was BLI-12910.
+        if (!state.staged[hash]) {
+            ghostCount += 1;
+            continue;
+        }
+        entries.push(entry);
+    }
+    if (ghostCount > 0) {
+        console.error("[raw-evidence-stuck] delivery records with no staged object left out of the stuck count", JSON.stringify({
+            ghost_record_count: ghostCount,
+            stuck_object_count: entries.length,
+            reason: "object_no_longer_staged",
+        }));
+    }
     const reasons = new Set();
     let heldCount = 0;
     let maxAttempts = 0;
@@ -52,6 +71,7 @@ export function summarizeStuckEvidence(state, now) {
     return {
         stuck_object_count: entries.length,
         held_object_count: heldCount,
+        ghost_record_count: ghostCount,
         max_attempts: maxAttempts,
         oldest_first_failed_at: oldest,
         reasons: [...reasons].sort(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.179",
+  "version": "0.2.183",
   "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.52",
-    "@bli-cockpit/mcp": "0.1.94",
-    "@bli-cockpit/telemetry-core": "0.1.64"
+    "@bli-cockpit/memory-mcp": "0.1.55",
+    "@bli-cockpit/mcp": "0.1.97",
+    "@bli-cockpit/telemetry-core": "0.1.66"
   },
   "repository": {
     "type": "git",