@bli-cockpit/cli 0.2.173 → 0.2.179

package/dist/commands/doctor-pipeline.js

@@ -1,7 +1,4 @@
-import { withDoctorLockWait } from "./doctor-lock-wait.js";
-import { doctorBackfillBudgetSeconds, doctorLockWaitSeconds } from "./doctor-budget.js";
-import { inspectBackfillLock } from "../backfill-lock.js";
-import { readBackfillCompletionMarker, readBackfillCursor, } from "../cursors/backfill-cursor.js";
+import { withCollectionGate } from "./doctor-collection-lock.js";
 import { savedDiscoveryLimitArgs } from "../discovery-limits.js";
 import { runStagingPrune } from "../disk-prune.js";
 import { retentionOptionsFromEnv } from "../disk-retention.js";
@@ -10,11 +7,11 @@ import { readDiskFootprint } from "../disk-usage.js";
 import { runEvidenceRedelivery } from "../evidence-redelivery.js";
 import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths } from "../local-state.js";
 import { runRawEvidenceLocalGc, rawEvidenceGcSummary } from "../raw-evidence-gc.js";
-import { runBackfillCommand } from "./backfill.js";
 import { FOOTPRINT_NEEDS_FIX_BYTES, stagingPausedWords, diskRowMessage, footprintHolder, footprintTotalBytes, mib, redeliveryLine, } from "./doctor-disk-words.js";
 import { doctorRoots } from "./doctor-access.js";
-import { backfillCompletionStepState, backfillFixVerdict, jsonField, parseDoctorBackfillJson, parseDoctorSyncJson, syncFailureMessage, syncBacklogDrainingVerdict, syncStandAsideVerdict, } from "./doctor-pipeline-verdicts.js";
-import { asRecord, fail, needsFix, ok, skipped } from "./doctor-report.js";
+import { startProgress, waitingLine } from "./doctor-progress.js";
+import { jsonField, parseDoctorSyncJson, syncFailureMessage, syncBacklogDrainingVerdict, syncStandAsideVerdict, } from "./doctor-pipeline-verdicts.js";
+import { fail, needsFix, ok, skipped } from "./doctor-report.js";
 /**
  * The `backfill-complete`, `gc-checked`, `disk-bounded`, and `sync-fresh`
  * check family: does the collection pipeline itself have everything it
@@ -29,108 +26,9 @@ import { asRecord, fail, needsFix, ok, skipped } from "./doctor-report.js";
  * completion marker proves, what a stand-aside receipt means, when an
  * unfinished backfill is busy rather than broken — are pure functions in
  * `doctor-pipeline-verdicts.ts`, and every one of them is re-exported from
- * here so callers keep one address.
+ * here so callers keep one address. The catch-up row itself moved to
+ * `doctor-backfill.ts` (BLI-12872) and is re-exported below as well.
  */
-export async function checkBackfillState(context) {
-    const paths = getCollectorRuntimePaths(context.command.homeDir);
-    const roots = await doctorRoots(context);
-    const marker = await readBackfillCompletionMarker(paths);
-    const covered = backfillCompletionStepState(marker, roots);
-    if (covered)
-        return covered;
-    const lock = await inspectBackfillLock(paths);
-    if (lock.held) {
-        return needsFix("backfill-complete", "backfill_already_running", `another catch-up run is still going, and this one has not finished yet (running since ${lock.held_since ?? "unknown"})`);
-    }
-    const cursor = await readBackfillCursor(paths);
-    return needsFix("backfill-complete", cursor.updated_at ? "partial" : "never_run", "the catch-up over your old sessions has not finished");
-}
-export async function fixBackfillState(context) {
-    const started = Date.now();
-    const deadline = started + doctorBackfillBudgetSeconds(context, started) * 1000;
-    let caughtUp = 0;
-    let chunks = 0;
-    let live = null;
-    const elapsed = () => {
-        const seconds = Math.floor((Date.now() - started) / 1000);
-        return `${Math.floor(seconds / 60)}m${String(seconds % 60).padStart(2, "0")}s`;
-    };
-    const receipt = () => `caught up on ${caughtUp} old sessions in ${chunks} chunk${chunks === 1 ? "" : "s"} over ${elapsed()}`;
-    let remaining = null;
-    const unfinished = (code, reason) => ({
-        ...needsFix("backfill-complete", code, `${receipt()}, ${remaining ?? "unknown"} still to go; ${reason}; run \`cockpit doctor\` again to continue`),
-        nextAction: "cockpit doctor",
-    });
-    const progress = setInterval(() => {
-        const seconds = Math.floor((Date.now() - started) / 1000);
-        const uploaded = live === null ? null : caughtUp + live.uploaded;
-        context.io.stderr.write(live === null
-            ? `backfill: starting, ${elapsed()}\n`
-            : `backfill: ${uploaded} caught up, ${live.processed} processed in this chunk, ${live.remaining} to go, ${elapsed()}\n`);
-        console.error("[doctor] backfill-complete progress", JSON.stringify({
-            status: live === null ? "starting" : "running", processed: live?.processed ?? null,
-            uploaded, caught_up: uploaded, remaining: live?.remaining ?? null,
-            chunks, elapsed_seconds: seconds,
-        }));
-    }, 30_000);
-    try {
-        while (Date.now() < deadline) {
-            // Every chunk reacquires the collector's locks. Bound lock waiting by
-            // the overall budget too; never abandon an in-flight cursor write.
-            const chunkContext = { ...context, command: { ...context.command,
-                    lockWaitSeconds: Math.min(doctorLockWaitSeconds(context), (deadline - Date.now()) / 1000),
-                } };
-            const row = await withDoctorLockWait(chunkContext, async () => {
-                if (Date.now() >= deadline)
-                    return unfinished("backfill_budget_timeout", "backfill time budget reached");
-                const capture = capturedIo(context.io, false);
-                live = null;
-                chunks += 1;
-                const code = await runBackfillCommand({
-                    homeDir: context.command.homeDir, repoRoot: context.command.repoRoot,
-                    all: true, dryRun: false, yes: true, json: true,
-                    deadlineMs: deadline,
-                    // Doctor's own `withDoctorLockWait` owns the waiting (BLI-11091).
-                    syncLockWaitMs: 0,
-                    onProgress: (progress) => { live = progress; },
-                }, capture.io);
-                const parsed = parseDoctorBackfillJson(capture.stdout());
-                const counts = asRecord(parsed?.counts);
-                const count = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
-                caughtUp += count(counts?.["backfilled"]) ?? 0;
-                remaining = count(counts?.["remaining"]) ?? remaining;
-                live = null;
-                if (code === 0 && parsed?.status === "complete") {
-                    // Reporting totals include permanent caps. Preserve their marker
-                    // note instead of retrying history the collector says is complete.
-                    const checked = await checkBackfillState(context);
-                    return ok("backfill-complete", checked.status === "ok" ? checked.code : "complete", receipt() + (checked.status === "ok" ? `; ${checked.message}` : ""));
-                }
-                const verdict = backfillFixVerdict(parsed, jsonField(capture.stderr(), "failure_reason"));
-                if (parsed?.status === "partial" &&
-                    (parsed.failure_reason === "deferred_budget_exhausted" || !parsed.failure_reason)) {
-                    return needsFix("backfill-complete", "backfill_chunk_pending", "more history remains");
-                }
-                return { ...verdict, message: typeof parsed?.failure_reason === "string" ? parsed.failure_reason : "backfill failed without a valid completion receipt" };
-            });
-            if (row.status === "ok") {
-                console.error("[doctor] backfill-complete finished", JSON.stringify({ caught_up: caughtUp, remaining, chunks, elapsed_seconds: Math.floor((Date.now() - started) / 1000) }));
-                return row;
-            }
-            if (row.code !== "backfill_chunk_pending") {
-                return unfinished(row.code === "lock_wait_timeout" && Date.now() >= deadline ? "backfill_budget_timeout" : row.code, row.message);
-            }
-        }
-        return unfinished("backfill_budget_timeout", "backfill time budget reached");
-    }
-    catch (error) {
-        console.error("[doctor] backfill-complete failed", JSON.stringify({ reason: "backfill_threw", error_name: error instanceof Error ? error.name : "unknown" }));
-        return unfinished("backfill_threw", "backfill failed");
-    }
-    finally {
-        clearInterval(progress);
-    }
-}
 export async function checkGcState(context) {
     if (context.io.env["COCKPIT_DISABLE_GC"] === "1") {
         return skipped("gc-checked", "skipped_disabled", "cleanup is switched off");
@@ -253,42 +151,6 @@ export async function fixDiskState(context) {
     // Unaccepted evidence still occupies the cap. Keep the disk row actionable.
     return needsFix("disk-bounded", "staging_cap_blocked_by_uncommitted", `freed ${mib(pruned.deleted_bytes)} MB; ${message}; ${pruned.cap_blocked_count} object(s) the upload ledger cannot vouch for are holding the rest; ${redelivered}; or \`cockpit clean --all-committed\` to drop every accepted copy now`);
 }
-function capturedIo(io, forward) {
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    return {
-        io: {
-            ...io,
-            stdout: captureStream(io.stdout, stdoutChunks, forward),
-            stderr: captureStream(io.stderr, stderrChunks, forward),
-        },
-        stdout: () => stdoutChunks.join(""),
-        stderr: () => stderrChunks.join(""),
-    };
-}
-function captureStream(target, chunks, forward) {
-    return {
-        write(chunk, encoding, callback) {
-            const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
-            chunks.push(text);
-            if (forward) {
-                if (typeof encoding === "function") {
-                    target.write(chunk, encoding);
-                }
-                else {
-                    target.write(chunk, encoding, callback);
-                }
-            }
-            else if (typeof encoding === "function") {
-                encoding();
-            }
-            else {
-                callback?.();
-            }
-            return true;
-        },
-    };
-}
 export async function checkSyncState(context) {
     const roots = await doctorRoots(context);
     if (roots.length === 0) {
@@ -299,8 +161,13 @@ export async function checkSyncState(context) {
     // and only turns green from those command receipts.
     return needsFix("sync-fresh", "per_root_verification_required", `fresh upload proof is required for ${roots.length} saved root${roots.length === 1 ? "" : "s"}`);
 }
+/**
+ * The `sync-fresh` repair. Looks at the collection lock first and never waits
+ * for it (BLI-12872): a running background sync is reported as exactly that,
+ * and a stuck one is ended before doctor's own sync runs.
+ */
 export async function fixSyncState(context) {
-    return withDoctorLockWait(context, () => runSyncRepair(context));
+    return withCollectionGate(context, "sync-fresh", () => runSyncRepair(context));
 }
 async function runSyncRepair(context) {
     const exec = context.io.exec;
@@ -321,7 +188,10 @@ async function runSyncRepair(context) {
         if (context.command.dashboardUrl !== DEFAULT_DASHBOARD_URL) {
             args.push("--dashboard-url", context.command.dashboardUrl);
         }
-        const result = await exec("cockpit", args);
+        // One line every 30 s while doctor's own sync runs; the exec has nothing
+        // to count, so the line says it is still working and for how long.
+        const stopProgress = startProgress((text) => context.io.stderr.write(text), (elapsedMs) => waitingLine("sync", elapsedMs));
+        const result = await Promise.resolve(exec("cockpit", args)).finally(stopProgress);
         const parsed = parseDoctorSyncJson(result.stdout);
         const output = `${result.stdout}\n${result.stderr}`;
         const status = jsonField(output, "status");
@@ -335,10 +205,12 @@ async function runSyncRepair(context) {
                 owner_alive: standAside.ownerAlive,
                 held_since: standAside.heldSince,
             }));
-            return needsFix("sync-fresh", standAside.code, "waiting for the collection lock");
+            // The gate (`withCollectionGate`) reads the lock again and turns this
+            // into "background sync is running"; the code only travels to it.
+            return needsFix("sync-fresh", standAside.code, "the sync stood aside for the collection lock");
         }
         if (status === "live_sync_paused_during_backfill") {
-            return needsFix("sync-fresh", status, "waiting for historical catch-up");
+            return needsFix("sync-fresh", status, "the sync paused for the historical catch-up");
         }
         if (result.code !== 0) {
             const draining = syncBacklogDrainingVerdict(parsed);
@@ -347,7 +219,7 @@ async function runSyncRepair(context) {
                     `file${draining.remainingObjects === 1 ? "" : "s"} left for later this run); ` +
                     "rerun `cockpit sync` to continue");
             }
-            return fail("sync-fresh", status ?? "sync_failed", `${repoRoot}: ${syncFailureMessage(parsed)}`);
+            return fail("sync-fresh", status ?? "sync_failed", `${repoRoot}: ${syncFailureMessage(parsed, result.code)}`);
         }
         if (parsed?.collection_complete === false && typeof parsed.discovery_notice === "string") {
             console.error("[doctor] partial discovery", JSON.stringify({ reason: "discovery_partial" }));
@@ -364,4 +236,5 @@ async function runSyncRepair(context) {
 // Re-exported so `doctor.ts`, the doctor tests and every other caller keep
 // importing these from `./doctor-pipeline.js` regardless of which sibling
 // computes them.
+export { checkBackfillState, fixBackfillState } from "./doctor-backfill.js";
 export { backfillCompletionStepState, backfillFixVerdict, isCollectionBusyReason, syncBacklogDrainingVerdict, syncStandAsideVerdict, } from "./doctor-pipeline-verdicts.js";

package/dist/commands/doctor-progress.js

@@ -0,0 +1,54 @@
+/**
+ * The one progress line `cockpit doctor` prints while a long repair runs
+ * (BLI-12872).
+ *
+ * Until now two writers shared stderr: the lock wait's "waiting for the
+ * background sync to finish" and the catch-up's "backfill: starting", and a
+ * 13-minute run printed that pair alternately about 40 times, which says
+ * nothing. Doctor no longer waits on a lock, so one writer is left, and its
+ * rule is: at most one line every 30 seconds, and each line says what CHANGED
+ * since the last one, or that nothing did.
+ *
+ * Counts and elapsed time only; never a path, an id or a session name.
+ */
+export const PROGRESS_EVERY_MS = 30_000;
+/** "5m00s" for a progress line: seconds matter here, unlike a lock's age. */
+export function clock(ms) {
+    const seconds = Math.floor(ms / 1000);
+    return `${Math.floor(seconds / 60)}m${String(seconds % 60).padStart(2, "0")}s`;
+}
+/**
+ * The line for this tick. `last` is what the previous line reported (null for
+ * the first line), so the sentence is always a difference, never a repeat.
+ */
+export function backfillProgressLine(now, last, elapsedMs) {
+    if (now.remaining === null) {
+        return `backfill: reading your old sessions, ${clock(elapsedMs)}`;
+    }
+    const counts = `${now.caughtUp} caught up, ${now.remaining} to go`;
+    if (last === null || last.remaining === null) {
+        return `backfill: ${counts}, ${clock(elapsedMs)}`;
+    }
+    const gained = now.caughtUp - last.caughtUp;
+    if (gained <= 0 && now.remaining === last.remaining) {
+        return `backfill: no change in the last 30s (${counts}), ${clock(elapsedMs)}`;
+    }
+    return `backfill: +${Math.max(0, gained)} caught up in the last 30s (${counts}), ${clock(elapsedMs)}`;
+}
+/** The line for a repair that is one long command with nothing to count (`sync`). */
+export function waitingLine(what, elapsedMs) {
+    return `${what}: still working, ${clock(elapsedMs)} so far`;
+}
+/**
+ * Print `describe(elapsedMs)` every 30 seconds until stopped. The timer never
+ * keeps the process alive. Returns the stop function.
+ */
+export function startProgress(write, describe, options = {}) {
+    const now = options.now ?? (() => Date.now());
+    const started = now();
+    const timer = (options.setIntervalImpl ?? setInterval)(() => {
+        write(`${describe(now() - started)}\n`);
+    }, PROGRESS_EVERY_MS);
+    timer.unref?.();
+    return () => (options.clearIntervalImpl ?? clearInterval)(timer);
+}

package/dist/commands/doctor-report.js

@@ -157,7 +157,8 @@ export function repairReceiptLines(repairs) {
         return [];
     return [
         "Repairs (before -> after):",
-        ...ran.map((repair) => `  ${repair.after?.startsWith("ok:") ? "fixed" : "still needs you"} ${repair.step}: ${repair.before_message ?? ""} -> ${repair.after_message ?? ""}`.replaceAll("—", ";")),
+        // BLI-12872: a row left "skipped" is a background sync doing the work; it is in progress, not waiting on a person.
+        ...ran.map((repair) => `  ${repair.after?.startsWith("ok:") ? "fixed" : repair.after?.startsWith("skipped:") ? "in progress" : "still needs you"} ${repair.step}: ${repair.before_message ?? ""} -> ${repair.after_message ?? ""}`.replaceAll("—", ";")),
     ];
 }
 export function doctorNeedsPerson(rows, receipt) {

package/dist/commands/doctor.js

@@ -4,6 +4,7 @@ import { describeError } from "../health-detail.js";
 import { withStage } from "../crash-guard.js";
 import { checkSingleInstallState, readRootsCoverWork, fixAuthState, fixRootState, readAuthState, readRootState, } from "./doctor-access.js";
 import { backfillCompletionStepState, backfillFixVerdict, checkBackfillState, checkDiskState, checkGcState, checkSyncState, fixBackfillState, fixDiskState, fixGcState, fixSyncState, syncBacklogDrainingVerdict, syncStandAsideVerdict, } from "./doctor-pipeline.js";
+import { gateRow, readCollectionGate } from "./doctor-collection-lock.js";
 import { checkMcpAnswersState, fixMcpAnswersState } from "./doctor-mcp.js";
 import { budgetSpentRow, doctorRunDeadline, DOCTOR_JSON_BUDGET_SECONDS } from "./doctor-budget.js";
 import { checkMemoryDaemonState } from "./doctor-memory-daemon.js";
@@ -49,15 +50,22 @@ export async function runDoctorWithDeps(command, io, deps) {
             const prerequisitesReady = !needsCollection || rows.filter((prior) => prior.id === "authed" || prior.id === "roots-ok").every((prior) => prior.status === "ok");
             const canFix = !diagnoseOnly && prerequisitesReady && invariant.fix &&
                 (!invariant.requiresInteractiveFix || isInteractiveDoctorFix(context) || Boolean(command.collectionRoots?.length));
-            const spent = row.status !== "ok" && row.status !== "skipped" && canFix ? budgetSpentRow(context, row) : null;
+            let spent = row.status !== "ok" && row.status !== "skipped" && canFix ? budgetSpentRow(context, row) : null;
+            if (spent && needsCollection) {
+                // BLI-12872: a running sync is the answer even when the budget is spent; looking costs nothing.
+                const gate = await readCollectionGate(context, undefined, { mayEnd: false });
+                if (gate.kind === "running")
+                    spent = gateRow(invariant.id, gate);
+            }
             if (spent) {
                 row = spent;
-                repairs.push({ step: invariant.id, outcome: "needs_person", reason: row.code });
+                repairs.push({ step: invariant.id, outcome: row.status === "skipped" ? "not_needed" : "needs_person", reason: row.code });
             }
             else if (row.status !== "ok" && row.status !== "skipped" && canFix && invariant.fix) {
                 attempted.add(invariant.id);
                 row = await withStage(`doctor:fix:${invariant.id}`, () => invariant.fix(context, row));
-                repairs.push({ step: invariant.id, outcome: row.status === "ok" ? "repaired" : "needs_person", reason: row.code });
+                // BLI-12872: a skipped row after a fix is a sync already doing the work, not a person's job.
+                repairs.push({ step: invariant.id, outcome: row.status === "ok" ? "repaired" : row.status === "skipped" ? "not_needed" : "needs_person", reason: row.code });
                 // The replacement process owns the one final receipt, including JSON.
                 if (row.reexecExitCode !== undefined)
                     return row.reexecExitCode;

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

@@ -3,28 +3,44 @@
  *
  *   cockpit logs <source> [--since 15m|1h|2d|<iso>] [--raw <template-id>] [--limit <n>]
  *                [--all-levels] [--table <file>] [--json]
+ *   cockpit logs <project> [--since 24h] [--json]          (BLI-12855: stored digests)
+ *   cockpit logs dashboard|railway --stored [--since 1h]   (Tower's stored digests)
+ *   cockpit logs --list                                     (the projects Tower digests)
  *
  * <source> is `collector`, `dashboard`, `railway`, `railway:<service>` or `-`
- * (lines on stdin). Read-only: the digest is computed on this machine from the
- * source's own CLI or files; nothing is sent to Tower and no dashboard is
- * called, so there is no `--dashboard-url`.
+ * (lines on stdin): read-only, computed on this machine from the source's own CLI
+ * or files, nothing sent to Tower. Or <source> is a registry project id (`kolm`,
+ * `tower`...): then the digest is the one Tower's own cron stored, read through
+ * the dashboard's `/api/logs` door with this machine's device token, so it works
+ * with no `vercel` or `railway` login at all.
  */
-import { optionalNonEmpty, optionalPositiveInteger, parseNamedArgs } from "./local-arg-values.js";
+import { LOG_PROJECT_PATTERN } from "@bli-cockpit/telemetry-core/log-digest";
+import { optionalNonEmpty, optionalPositiveInteger, optionalUrl, parseNamedArgs } from "./local-arg-values.js";
 /** The source spellings, for the usage line and the refusal. `railway:<service>` takes any service name. */
-export const LOGS_SOURCES = ["collector", "dashboard", "railway", "railway:<service>", "-"];
-const SOURCE_PATTERN = /^(collector|dashboard|railway|railway:[A-Za-z0-9][A-Za-z0-9._-]{0,63}|-)$/;
+export const LOGS_SOURCES = ["collector", "dashboard", "railway", "railway:<service>", "-", "<project>"];
+/** The spellings that read a local log; every other name is a registry project (stored digests). */
+const LOCAL_SOURCE_PATTERN = /^(collector|dashboard|railway|railway:[A-Za-z0-9][A-Za-z0-9._-]{0,63}|-)$/;
 const SINCE_PATTERN = /^(\d{1,4}[smhd]|\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d{1,9})?)?(Z|[+-]\d{2}:\d{2})?)?)$/;
 export function parseLogsArgs(args) {
     const values = parseNamedArgs(args, {
-        allowedFlags: ["--home", "--since", "--raw", "--limit", "--table", "--all-levels", "--json"],
-        valueFlags: ["--home", "--since", "--raw", "--limit", "--table"],
+        allowedFlags: ["--home", "--since", "--raw", "--limit", "--table", "--all-levels", "--stored", "--list", "--dashboard-url", "--json"],
+        valueFlags: ["--home", "--since", "--raw", "--limit", "--table", "--dashboard-url"],
     });
-    const source = values.positionals[0];
-    if (!source || !SOURCE_PATTERN.test(source)) {
-        throw new Error(`logs needs a source: ${LOGS_SOURCES.join(", ")}. Example: \`cockpit logs dashboard --since 1h\`.`);
+    const list = values.booleans.has("--list");
+    const source = values.positionals[0] ?? (list ? "tower" : undefined);
+    if (!source || (!LOCAL_SOURCE_PATTERN.test(source) && !LOG_PROJECT_PATTERN.test(source))) {
+        throw new Error(`logs needs a source: ${LOGS_SOURCES.join(", ")}. Example: \`cockpit logs dashboard --since 1h\` or \`cockpit logs kolm --since 24h\`.`);
     }
     if (values.positionals.length > 1)
         throw new Error("logs takes one source; put the window in --since.");
+    const isProject = !LOCAL_SOURCE_PATTERN.test(source);
+    const stored = isProject || values.booleans.has("--stored");
+    if (values.booleans.has("--stored") && !["dashboard", "railway"].includes(source) && !isProject) {
+        throw new Error("--stored reads Tower's stored digests: use it with dashboard or railway, or name a project (`cockpit logs kolm`).");
+    }
+    if (stored && (values.flags.get("--raw") || values.flags.get("--table") || values.booleans.has("--all-levels"))) {
+        throw new Error("a stored digest keeps no raw line, and its classes were set when it was stored: --raw, --table and --all-levels read a local log.");
+    }
     const since = optionalNonEmpty(values.flags.get("--since"));
     if (since && !SINCE_PATTERN.test(since)) {
         throw new Error(`--since wants 15m, 1h, 2d or an ISO time like 2026-10-07T03:00Z; got ${JSON.stringify(since.slice(0, 40))}.`);
@@ -47,6 +63,9 @@ export function parseLogsArgs(args) {
         ...(rawLimit === undefined ? {} : { rawLimit }),
         ...(values.flags.get("--table") ? { tableFile: values.flags.get("--table") } : {}),
         allLevels: values.booleans.has("--all-levels"),
+        stored,
+        list,
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
         homeDir: optionalNonEmpty(values.flags.get("--home")),
         json: values.booleans.has("--json"),
     };

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

@@ -13,9 +13,9 @@ export const TOWER_OPS_COMMAND_HELP = [
     [
         "logs",
         [
-            "Usage: cockpit logs <collector|dashboard|railway|railway:<service>|-> [--since 15m|1h|2d|<iso>] [--raw <template-id> [--limit <n>]] [--all-levels] [--table <file>] [--json]",
+            "Usage: cockpit logs <collector|dashboard|railway|railway:<service>|-|project> [--since 15m|1h|2d|<iso>] [--raw <template-id> [--limit <n>]] [--all-levels] [--table <file>] [--stored] [--list] [--json]",
             "",
-            "A token-cheap digest of Tower's own logs, read on THIS machine (nothing is uploaded). Variable parts of",
+            "A token-cheap digest of Tower's own logs, read on THIS machine (nothing is uploaded) unless a project is named. Variable parts of",
             "each line are masked into a template, equal templates are counted, routine runs become counts, and every",
             "template is classified: our_bug and unknown first, then capacity, config_drift, rate_pushback, hiccup,",
             "and one COUNTED line for dead_source and benign (counted, never alerted). About 2 KB.",
@@ -27,10 +27,18 @@ export const TOWER_OPS_COMMAND_HELP = [
             "  railway:<service>   one service (ladder, runner, linear-sync, ...). Project and environment are always passed",
             "                      explicitly: this repo's `railway link` points at the runner service.",
             "  -                   lines on stdin: plain text, `journalctl -o json`, `railway logs --json` or `vercel logs --json`.",
+            "  <project>           a BLI project (tower, kolm, portpal, pearl-portal, triage-crm, ...; `--list` names them): the digest Tower's",
+            "                      own 15-minute cron STORED from that project's Vercel, Railway and Supabase logs, merged over --since",
+            "                      (default 24h, at most 30d), real bugs first. Needs only this machine's Tower login: no vercel or railway",
+            "                      login. It keeps no raw line, so --raw, --table and --all-levels do not apply.",
+            "--stored              dashboard or railway read Tower's stored digest of project `tower` (this also happens by itself, and says so,",
+            "                      when the local vercel or railway CLI is missing or logged out).",
+            "--list                every project, every source, and which are wired or not_wired (with the reason).",
             "--raw <template-id>   the original lines behind one template id from a digest (redacted, newest last; --limit n, default 20).",
             "--table <file>        a class table JSON (same shape as the packaged one) to try a new pattern before committing it.",
             "A source that cannot be read is a named refusal, never a stack trace: vercel_cli_missing, vercel_not_logged_in,",
-            "railway_cli_missing, railway_not_logged_in, railway_service_unknown, collector_logs_missing, stdin_is_terminal, ...",
+            "railway_cli_missing, railway_not_logged_in, railway_service_unknown, collector_logs_missing, stdin_is_terminal, and for a",
+            "project unknown_project, since_exceeds_retention, stored_read_failed, not_paired, ...",
             "--json writes one object to stdout: { ok, kind, source, window, lines, templates[], routine, notes, text, measure };",
             "a refusal is { ok: false, error, detail } and exits 1. Run list and teaching: docs/runbooks/tower-logs.md.",
             "The bli-tower MCP server has the twin: logs_digest.",

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

@@ -94,7 +94,7 @@ export function localSubcommandHelp(command) {
                 "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.",
                 "--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.",
-                "--lock-wait defaults to 600 seconds; progress prints 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.",
                 "--json without either flag answers within 45 seconds; a repair that does not fit reads doctor_budget_spent.",
                 "--json includes steps, repairs, and needs_person. Exit 0 means nothing needs you.",
                 "Maintainers: --update-tag next keeps self-update on the prerelease candidate.",

package/dist/commands/logs-stored.js

@@ -0,0 +1,56 @@
+import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+const TAG = "[logs cli]";
+const READ_DEADLINE_MS = 55_000;
+/** The project a stored read is for: the named project, or `tower` for `dashboard` and `railway`. */
+export function storedProject(command) {
+    if (!command.stored)
+        return null;
+    return command.source === "dashboard" || command.source === "railway" ? "tower" : command.source;
+}
+export async function runStoredLogs(command, io, options) {
+    let door;
+    try {
+        door = await openAgentDoor("logs", command, io);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : "this machine is not paired with Tower";
+        if (options.onNotPaired)
+            return options.onNotPaired(detail);
+        writeLine(io.stderr, `${TAG} refused ${JSON.stringify({ reason: "not_paired" })}`);
+        if (command.json)
+            writeLine(io.stdout, JSON.stringify({ ok: false, error: "not_paired", detail }));
+        else
+            writeLine(io.stderr, detail);
+        return 1;
+    }
+    if (command.list) {
+        const answer = await askAgentDoor(door, { path: "/api/logs?list=1", method: "GET", label: "logs list", timeoutMs: READ_DEADLINE_MS });
+        if (!answer.ok)
+            return failAgentDoor(door, TAG, answer.reason, answer.detail);
+        const body = answer.body;
+        if (command.json)
+            return emitAgentDoor(door, body);
+        for (const project of body.projects) {
+            writeLine(io.stdout, `${project.id}  ${project.name}`);
+            for (const source of project.sources) {
+                writeLine(io.stdout, `  ${source.status === "wired" ? "wired    " : "not_wired"} ${source.source}${source.reason ? `: ${source.reason}` : ""}`);
+            }
+        }
+        return 0;
+    }
+    const query = new URLSearchParams({ project: options.project });
+    if (command.since)
+        query.set("since", command.since);
+    const answer = await askAgentDoor(door, { path: `/api/logs?${query.toString()}`, method: "GET", label: "logs", timeoutMs: READ_DEADLINE_MS });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const body = answer.body;
+    writeLine(io.stderr, `${TAG} stored digest read ${JSON.stringify({ project: body.project, windows: body.windows, windows_ok: body.windows_ok, refusals: body.refusals.length, still_refusing: body.still_refusing?.length ?? null, not_wired: body.not_wired?.length ?? null, fallback: Boolean(options.fallbackReason) })}`);
+    if (command.json)
+        return emitAgentDoor(door, options.fallbackReason ? { ...body, fallback_from: options.fallbackReason } : body);
+    if (options.fallbackReason)
+        writeLine(io.stdout, `(no local ${command.source} access: ${options.fallbackReason}; this is the digest Tower stored)`);
+    writeLine(io.stdout, body.text);
+    return 0;
+}

package/dist/commands/logs.js

@@ -4,7 +4,8 @@
  * Read-only and local: the source's own CLI or files are read on THIS machine,
  * masked into templates, counted and classified by `@bli-cockpit/telemetry-core/log-digest`,
  * and printed in about 2 KB with real bugs (`our_bug`, `unknown`) first. Nothing
- * is uploaded and no Tower door is called. The MCP server's `logs_digest` tool
+ * is uploaded and no Tower door is called (the stored half, `logs-stored.ts`,
+ * is the one exception: a project name reads what Tower's cron stored). The MCP server's `logs_digest` tool
  * calls the same `digestSource`, so the two print the same thing.
  *
  * A source that cannot be read is a NAMED refusal (`vercel_cli_missing`,
@@ -12,9 +13,10 @@
  * detail }` on stdout under `--json`, exit 1. Never a stack trace.
  */
 import { readFile } from "node:fs/promises";
-import { ClassTable, digestSource } from "@bli-cockpit/telemetry-core/log-digest";
+import { ClassTable, LOCAL_ACCESS_REFUSALS, digestSource } from "@bli-cockpit/telemetry-core/log-digest";
 import { getCollectorRuntimePaths } from "../local-state-paths.js";
 import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
+import { runStoredLogs, storedProject } from "./logs-stored.js";
 const TAG = "[logs cli]";
 const MAX_STDIN_CHARS = 64 * 1024 * 1024;
 function refuse(io, json, reason, detail) {
@@ -26,6 +28,10 @@ function refuse(io, json, reason, detail) {
     return 1;
 }
 export async function runLogs(command, io, deps = {}) {
+    // BLI-12855: a project name (or --stored, or --list) reads the digests Tower's cron stored, not a local log.
+    const stored = storedProject(command);
+    if (command.list || stored)
+        return runStoredLogs(command, io, { project: stored ?? "tower" });
     const paths = getCollectorRuntimePaths(command.homeDir);
     let table;
     if (command.tableFile) {
@@ -61,6 +67,16 @@ export async function runLogs(command, io, deps = {}) {
         nowMs: deps.nowMs,
         log: (message, fields) => writeLine(io.stderr, `${message} ${JSON.stringify(fields)}`),
     });
+    if (!outcome.ok && LOCAL_ACCESS_REFUSALS.has(outcome.reason) && (command.source === "dashboard" || command.source === "railway") && !command.raw) {
+        // No local access to the platform: say so, then answer from what the cron stored (a refusal of its own if this machine is not paired).
+        writeLine(io.stderr, `${TAG} local source unreadable, reading the stored digest ${JSON.stringify({ reason: outcome.reason })}`);
+        return runStoredLogs(command, io, {
+            project: "tower",
+            fallbackReason: outcome.reason,
+            // The person asked for a local read: if the stored digest is out of reach too, the local refusal is the answer.
+            onNotPaired: () => refuse(io, command.json, outcome.reason, `${outcome.detail} This machine is not paired with Tower (cockpit login), so the stored digest could not be read either.`),
+        });
+    }
     if (!outcome.ok)
         return refuse(io, command.json, outcome.reason, outcome.detail);
     writeLine(io.stdout, command.json ? JSON.stringify(outcome) : outcome.text);

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

package/dist/commands/sync-run.js

@@ -7,6 +7,7 @@ import { healStubsDuringTick } from "./sync-stub-heal.js";
 import { backfillWaitingCheck } from "./sync-yield.js";
 import { getCollectorRuntimePaths } from "../local-state.js";
 import { rawEvidenceDedupSummary, sweepDuplicateStagedRawEvidence, } from "../raw-evidence-gc.js";
+import { noteSyncProgress } from "../sync-lock.js";
 /**
  * Collect everything this tick may collect, then report it.
  *
@@ -25,6 +26,7 @@ export async function runSyncLocked(command, io) {
     if (!dedup.skipped && dedup.removed_dirs > 0) {
         writeLine(io.stdout, rawEvidenceDedupSummary(dedup));
     }
+    noteSyncProgress(); // BLI-12872: the sweep finished; the lock's progress mark
     let discoveryNotice = null;
     const worktrees = await discoverCommandWorktrees(collectionRoots, {
         maxDepth: command.maxDepth,
@@ -33,6 +35,7 @@ export async function runSyncLocked(command, io) {
         allowEmpty: true,
         onPartial: (notice) => { discoveryNotice = notice; },
     }, io);
+    noteSyncProgress(); // BLI-12872: discovery finished
     const run = await runAttributedWorktreeSync({
         homeDir: command.homeDir,
         dashboardUrl: command.dashboardUrl,

package/dist/commands/sync-yield.js

@@ -15,6 +15,7 @@
  * worktree's upload, which is why each one logs its own elapsed time.
  */
 import { inspectBackfillLock } from "../backfill-lock.js";
+import { noteSyncProgress } from "../sync-lock.js";
 /** The waiter's flag: the backfill lock is held while its owner waits for ours. */
 export function backfillWaitingCheck(paths, inspect = inspectBackfillLock) {
     return async () => {
@@ -50,6 +51,9 @@ export async function runYieldingAtBoundaries(options) {
         const itemStarted = now();
         const result = await options.runOne(item);
         results.push(result);
+        // BLI-12872: a finished worktree is the lock's progress mark, what keeps a
+        // long tick from being called stuck while it keeps working.
+        noteSyncProgress();
         console.error("[session-sync] worktree synced", JSON.stringify({
             index: index + 1,
             total: options.items.length,