@bli-cockpit/cli 0.2.98 → 0.2.100

package/dist/cursors/backfill-completion-marker.js

@@ -0,0 +1,135 @@
+/**
+ * The all-history completion marker: the one document that says an `--all`
+ * backfill finished, and the only proof `cockpit doctor` accepts for its
+ * `backfill-complete` row.
+ *
+ * It lives beside the cursor and not inside it because it answers a different
+ * question. The cursor is where the sweep GOT TO and is rewritten constantly;
+ * the marker is a claim about a finished scope, with its own schema version,
+ * its own 24-hour revalidation, and its own rule about which leftovers are
+ * allowed to ride along on a run that still counts as complete (a file over
+ * the upload cap, BLI-2727; helper transcripts over the per-session sidecar
+ * cap, BLI-4303). Both of those are recorded here, never silently dropped.
+ *
+ * Every name is re-exported from `./backfill-cursor.js`, the address its
+ * callers already know.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { describeError, isMissingFileFailure } from "../health-detail.js";
+import { backfillCollectionScopeId, parseBackfillCursor, writePrivateBackfillJson, } from "./backfill-cursor.js";
+export const BACKFILL_COMPLETION_MARKER_FILENAME = "backfill-complete.json";
+export const BACKFILL_COVERAGE_VERSION = "redacted-session-backfill.v3";
+export const BACKFILL_COMPLETION_RECHECK_MS = 24 * 60 * 60 * 1_000;
+export async function writeBackfillCompletionMarker(paths, marker) {
+    await writePrivateBackfillJson(backfillCompletionMarkerPath(paths), marker);
+}
+export async function readBackfillCompletionMarker(paths) {
+    try {
+        const raw = JSON.parse(await fs.readFile(backfillCompletionMarkerPath(paths), "utf8"));
+        return parseBackfillCompletionMarker(raw);
+    }
+    catch (error) {
+        // No marker means backfill has not finished, which is the ordinary state.
+        // A marker that cannot be read means a finished backfill will be re-run,
+        // and the machine should say so rather than quietly redo a day of work.
+        if (!isMissingFileFailure(error)) {
+            console.error("[backfill-cursor] completion marker unreadable, treating backfill as unfinished", JSON.stringify({
+                reason: "backfill_marker_unreadable",
+                marker_file: BACKFILL_COMPLETION_MARKER_FILENAME,
+                ...describeError(error),
+            }));
+        }
+        return null;
+    }
+}
+export function backfillCompletionCovers(marker, collectionRoots, requiredSources, now = new Date()) {
+    if (!marker)
+        return false;
+    if (marker.coverage_version !== BACKFILL_COVERAGE_VERSION)
+        return false;
+    if (marker.collection_scope_id !== backfillCollectionScopeId(collectionRoots)) {
+        return false;
+    }
+    const revalidateAfter = Date.parse(marker.revalidate_after);
+    if (!Number.isFinite(revalidateAfter) || now.getTime() >= revalidateAfter) {
+        return false;
+    }
+    const completedSources = new Set(marker.sources);
+    return requiredSources.every((source) => completedSources.has(source));
+}
+export function backfillCompletionMarkerPath(paths) {
+    return path.join(paths.cursors_dir, BACKFILL_COMPLETION_MARKER_FILENAME);
+}
+function parseBackfillCompletionMarker(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (record["schema_version"] !== "cockpit-backfill-complete.v2" ||
+        record["coverage_version"] !== BACKFILL_COVERAGE_VERSION) {
+        return null;
+    }
+    const collectionScopeId = optionalString(record["collection_scope_id"]);
+    const completedAt = optionalString(record["completed_at"]);
+    const revalidateAfter = optionalString(record["revalidate_after"]);
+    const rawSources = record["sources"];
+    if (!collectionScopeId ||
+        !completedAt ||
+        !revalidateAfter ||
+        !Number.isFinite(Date.parse(revalidateAfter)) ||
+        !Array.isArray(rawSources)) {
+        return null;
+    }
+    const sources = [
+        ...new Set(rawSources.filter((source) => source === "codex" || source === "claude_code")),
+    ];
+    if (sources.length === 0)
+        return null;
+    return {
+        schema_version: "cockpit-backfill-complete.v2",
+        coverage_version: BACKFILL_COVERAGE_VERSION,
+        collection_scope_id: collectionScopeId,
+        sources,
+        completed_at: completedAt,
+        revalidate_after: revalidateAfter,
+        cursor: parseBackfillCursor(record["cursor"]),
+        ...(parseOversizedSkips(record["oversized_skips"])
+            ? { oversized_skips: parseOversizedSkips(record["oversized_skips"]) }
+            : {}),
+        ...(parseSidecarCapSkips(record["sidecar_cap_skips"])
+            ? { sidecar_cap_skips: parseSidecarCapSkips(record["sidecar_cap_skips"]) }
+            : {}),
+    };
+}
+function parseSidecarCapSkips(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (record["reason"] !== "claude_sidecar_limit_applied")
+        return null;
+    const count = optionalNumber(record["count"]);
+    if (count === null || count <= 0)
+        return null;
+    return { reason: "claude_sidecar_limit_applied", count };
+}
+function parseOversizedSkips(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (record["reason"] !== "file_too_large")
+        return null;
+    const count = optionalNumber(record["count"]);
+    if (count === null || count <= 0)
+        return null;
+    const rawByteSizes = record["byte_sizes"];
+    const byteSizes = Array.isArray(rawByteSizes)
+        ? rawByteSizes.filter((entry) => typeof entry === "number" && Number.isFinite(entry) && entry >= 0)
+        : [];
+    return { reason: "file_too_large", count, byte_sizes: byteSizes };
+}
+function optionalString(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function optionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}

package/dist/cursors/backfill-cursor.js

@@ -1,11 +1,19 @@
+/**
+ * Where the historical sweep got to, per source: the backfill cursor.
+ *
+ * Two things live in this folder and they are deliberately separate. This one
+ * is a moving position — a newest/oldest watermark, the identities sitting
+ * exactly on each boundary, and the census of what was seen — rewritten by
+ * every run. Its sibling `backfill-completion-marker.ts` is the claim that a
+ * whole scope is FINISHED, with its own schema and its own rules; every name
+ * it owns is re-exported at the bottom of this file, so callers keep one
+ * address.
+ */
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { describeError, isMissingFileFailure } from "../health-detail.js";
 export const BACKFILL_CURSOR_FILENAME = "backfill.json";
-export const BACKFILL_COMPLETION_MARKER_FILENAME = "backfill-complete.json";
-export const BACKFILL_COVERAGE_VERSION = "redacted-session-backfill.v3";
-export const BACKFILL_COMPLETION_RECHECK_MS = 24 * 60 * 60 * 1_000;
 export function emptyBackfillCursorState() {
     return {
         schema_version: "cockpit-backfill-cursor.v1",
@@ -37,29 +45,7 @@ export async function readBackfillCursor(paths) {
 }
 export async function writeBackfillCursor(paths, state) {
     const filePath = backfillCursorPath(paths);
-    await writePrivateJson(filePath, state);
-}
-export async function writeBackfillCompletionMarker(paths, marker) {
-    await writePrivateJson(backfillCompletionMarkerPath(paths), marker);
-}
-export async function readBackfillCompletionMarker(paths) {
-    try {
-        const raw = JSON.parse(await fs.readFile(backfillCompletionMarkerPath(paths), "utf8"));
-        return parseBackfillCompletionMarker(raw);
-    }
-    catch (error) {
-        // No marker means backfill has not finished, which is the ordinary state.
-        // A marker that cannot be read means a finished backfill will be re-run,
-        // and the machine should say so rather than quietly redo a day of work.
-        if (!isMissingFileFailure(error)) {
-            console.error("[backfill-cursor] completion marker unreadable, treating backfill as unfinished", JSON.stringify({
-                reason: "backfill_marker_unreadable",
-                marker_file: BACKFILL_COMPLETION_MARKER_FILENAME,
-                ...describeError(error),
-            }));
-        }
-        return null;
-    }
+    await writePrivateBackfillJson(filePath, state);
 }
 /**
  * The cursor is only reusable inside the exact approved-root scope that
@@ -83,21 +69,6 @@ export function prepareBackfillCursorForScope(cursor, collectionRoots, sources)
         reset,
     };
 }
-export function backfillCompletionCovers(marker, collectionRoots, requiredSources, now = new Date()) {
-    if (!marker)
-        return false;
-    if (marker.coverage_version !== BACKFILL_COVERAGE_VERSION)
-        return false;
-    if (marker.collection_scope_id !== backfillCollectionScopeId(collectionRoots)) {
-        return false;
-    }
-    const revalidateAfter = Date.parse(marker.revalidate_after);
-    if (!Number.isFinite(revalidateAfter) || now.getTime() >= revalidateAfter) {
-        return false;
-    }
-    const completedSources = new Set(marker.sources);
-    return requiredSources.every((source) => completedSources.has(source));
-}
 export function backfillCollectionScopeId(collectionRoots) {
     const normalized = [...new Set(collectionRoots.map(normalizeScopeRoot))].sort();
     return `scope-${crypto
@@ -178,9 +149,6 @@ export function recordBackfillScanCoverage(cursor, sources, coveredThrough, now)
 export function backfillCursorPath(paths) {
     return path.join(paths.cursors_dir, BACKFILL_CURSOR_FILENAME);
 }
-export function backfillCompletionMarkerPath(paths) {
-    return path.join(paths.cursors_dir, BACKFILL_COMPLETION_MARKER_FILENAME);
-}
 function emptySourceCursor(collectionScopeId = null) {
     return {
         collection_scope_id: collectionScopeId,
@@ -194,7 +162,7 @@ function emptySourceCursor(collectionScopeId = null) {
         reason_counts: {},
     };
 }
-function parseBackfillCursor(value) {
+export function parseBackfillCursor(value) {
     if (!value || typeof value !== "object")
         return emptyBackfillCursorState();
     const record = value;
@@ -228,58 +196,6 @@ function parseSourceCursor(value) {
         reason_counts: parseNumberRecord(record["reason_counts"]),
     };
 }
-function parseBackfillCompletionMarker(value) {
-    if (!value || typeof value !== "object")
-        return null;
-    const record = value;
-    if (record["schema_version"] !== "cockpit-backfill-complete.v2" ||
-        record["coverage_version"] !== BACKFILL_COVERAGE_VERSION) {
-        return null;
-    }
-    const collectionScopeId = optionalString(record["collection_scope_id"]);
-    const completedAt = optionalString(record["completed_at"]);
-    const revalidateAfter = optionalString(record["revalidate_after"]);
-    const rawSources = record["sources"];
-    if (!collectionScopeId ||
-        !completedAt ||
-        !revalidateAfter ||
-        !Number.isFinite(Date.parse(revalidateAfter)) ||
-        !Array.isArray(rawSources)) {
-        return null;
-    }
-    const sources = [
-        ...new Set(rawSources.filter((source) => source === "codex" || source === "claude_code")),
-    ];
-    if (sources.length === 0)
-        return null;
-    return {
-        schema_version: "cockpit-backfill-complete.v2",
-        coverage_version: BACKFILL_COVERAGE_VERSION,
-        collection_scope_id: collectionScopeId,
-        sources,
-        completed_at: completedAt,
-        revalidate_after: revalidateAfter,
-        cursor: parseBackfillCursor(record["cursor"]),
-        ...(parseOversizedSkips(record["oversized_skips"])
-            ? { oversized_skips: parseOversizedSkips(record["oversized_skips"]) }
-            : {}),
-    };
-}
-function parseOversizedSkips(value) {
-    if (!value || typeof value !== "object")
-        return null;
-    const record = value;
-    if (record["reason"] !== "file_too_large")
-        return null;
-    const count = optionalNumber(record["count"]);
-    if (count === null || count <= 0)
-        return null;
-    const rawByteSizes = record["byte_sizes"];
-    const byteSizes = Array.isArray(rawByteSizes)
-        ? rawByteSizes.filter((entry) => typeof entry === "number" && Number.isFinite(entry) && entry >= 0)
-        : [];
-    return { reason: "file_too_large", count, byte_sizes: byteSizes };
-}
 function normalizeScopeRoot(value) {
     const windowsStyle = path.win32.isAbsolute(value) && !path.posix.isAbsolute(value);
     if (windowsStyle)
@@ -305,7 +221,7 @@ function parseStringArray(value) {
         ...new Set(value.filter((entry) => typeof entry === "string" && entry.trim().length > 0)),
     ].sort();
 }
-async function writePrivateJson(filePath, value) {
+export async function writePrivateBackfillJson(filePath, value) {
     await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
     const tempPath = `${filePath}.tmp-${process.pid}-${crypto.randomUUID()}`;
     const serialized = `${JSON.stringify(value, null, 2)}\n`;
@@ -334,4 +250,7 @@ function optionalString(value) {
 }
 function optionalNumber(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
+}
+// Re-exported so every caller keeps importing the completion marker from
+// `./backfill-cursor.js`, the address it has always had.
+export { BACKFILL_COMPLETION_MARKER_FILENAME, BACKFILL_COMPLETION_RECHECK_MS, BACKFILL_COVERAGE_VERSION, backfillCompletionCovers, backfillCompletionMarkerPath, readBackfillCompletionMarker, writeBackfillCompletionMarker, } from "./backfill-completion-marker.js";

package/dist/process-runner.js

@@ -49,6 +49,34 @@ export function createCapturedExecRunner(options = {}) {
         });
     });
 }
+/**
+ * Which stdio a re-exec may inherit (BLI-4110).
+ *
+ * `stdio: "inherit"` hands the child all three of the parent's handles. Under
+ * the Windows Task Scheduler — and any other non-interactive host — the
+ * parent's stdin is not a console: it can be a pipe nobody is writing to, or a
+ * socket that was never connected, and reading it raises `read ENOTCONN` from
+ * inside `child_process.spawn`. That is the error `cockpit do-everything`
+ * printed on the founder's box on 2026-09-09, from `reexecDoctor`, in a
+ * non-interactive shell.
+ *
+ * **stdout and stderr are still inherited, always.** They are what makes a
+ * scheduled run's output land in the log a person later reads, and dropping
+ * them to fix stdin would trade a crash for a silence — which is the failure
+ * this whole ticket is about.
+ *
+ * **stdin is inherited only when there is a console to read from.** A
+ * re-execed `do-everything` under a scheduler has nothing to type at it; the
+ * handle was pure liability. `"ignore"` gives the child a real, closed stdin
+ * rather than a broken one, so a child that does read it gets EOF instead of
+ * an error.
+ *
+ * Pure and exported so both host families are testable without a real TTY,
+ * per the supported-fleet contract in AGENTS.md.
+ */
+export function interactiveStdio(input) {
+    return [input.stdinIsTty === true ? "inherit" : "ignore", "inherit", "inherit"];
+}
 export function createInteractiveExecRunner(options = {}) {
     return (command, args, runOptions) => new Promise((resolve) => {
         const env = runOptions?.env ?? options.env ?? process.env;
@@ -56,8 +84,9 @@ export function createInteractiveExecRunner(options = {}) {
             platform: options.platform,
             env,
         });
+        const stdio = interactiveStdio({ stdinIsTty: process.stdin.isTTY });
         const child = spawn(invocation.command, invocation.args, {
-            stdio: "inherit",
+            stdio,
             env,
             windowsVerbatimArguments: invocation.windowsVerbatimArguments,
         });
@@ -66,6 +95,15 @@ export function createInteractiveExecRunner(options = {}) {
             if (settled)
                 return;
             settled = true;
+            // Named, because a spawn that never started and a child that ran and
+            // failed both used to arrive here as a bare code 1. Metadata only.
+            const record = error;
+            console.error("[process-runner] spawn failed", JSON.stringify({
+                reason: "spawn_failed",
+                error_code: record.code ?? null,
+                error_syscall: record.syscall ?? null,
+                stdin: stdio[0],
+            }));
             resolve({ code: 1, stdout: "", stderr: error.message });
         });
         child.on("close", (code) => {

package/dist/sync-lock.js

@@ -15,7 +15,16 @@ import { describeError } from "./health-detail.js";
  */
 const LOCK_FILENAME = "sync.lock";
 const HEARTBEAT_INTERVAL_MS = 30_000;
-const STALE_TAKEOVER_MS = 2 * 60_000;
+/**
+ * How long a lock may go without a heartbeat before the next sync takes it
+ * over. Exported because it is also what "the owner is still alive" MEANS on
+ * this machine: a receipt that says `sync_already_running` and carries a
+ * heartbeat inside this window was refused by a process that is still running
+ * (BLI-4303). Doctor reads it that way instead of calling a contended lock a
+ * failure.
+ */
+export const SYNC_LOCK_STALE_TAKEOVER_MS = 2 * 60_000;
+const STALE_TAKEOVER_MS = SYNC_LOCK_STALE_TAKEOVER_MS;
 export async function acquireSyncLock(paths, now = new Date()) {
     const lockPath = path.join(paths.state_dir, LOCK_FILENAME);
     await fs.mkdir(paths.state_dir, { recursive: true, mode: 0o700 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.98",
+  "version": "0.2.100",
   "private": false,
   "type": "module",
   "bin": {
@@ -24,11 +24,11 @@
     "pretypecheck": "node ../../scripts/build-workspace-dep.mjs @bli-cockpit/cli",
     "typecheck": "node -e \"await import('./dist/commands/public-root.js')\"",
     "pretest": "node ../../scripts/build-workspace-dep.mjs @bli-cockpit/cli",
-    "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-runtime-files.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
+    "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-runtime-files.mjs && node ../../scripts/assert-public-cli-exit-contract.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.25",
-    "@bli-cockpit/mcp": "0.1.29",
-    "@bli-cockpit/telemetry-core": "0.1.42"
+    "@bli-cockpit/memory-mcp": "0.1.26",
+    "@bli-cockpit/mcp": "0.1.31",
+    "@bli-cockpit/telemetry-core": "0.1.43"
   }
 }