@bli-cockpit/cli 0.1.29 → 0.1.31

package/README.md

@@ -50,6 +50,9 @@ installs the latest public CLI from npm, then reruns onboarding checks to
 refresh pairing, agent rules, autostart, and an initial sync against saved
 roots. `cockpit upgrade` is a compatibility alias. `--repo <path>` remains
 supported for older prompts and the agent ticket-binding guardrail.
+When onboarding reports archived local sessions without a completed backfill,
+follow [`docs/runbooks/cockpit-backfill.md`](../../docs/runbooks/cockpit-backfill.md):
+run `cockpit update`, then run `cockpit backfill --all` as a separate command.
 
 On machines where Codex or Claude agents will do ticketed work, `cockpit
 onboard` refreshes `~/.codex/AGENTS.md` and `~/.claude/CLAUDE.md` after harvest
@@ -176,6 +179,8 @@ Local files:
 - `~/.local/state/bli-cockpit/cursors/raw-evidence.json`: hashes and labels of
   already-durable evidence so repeated syncs skip re-uploading the same
   content (no raw content is stored in the cursor).
+- `~/.local/state/bli-cockpit/cursors/backfill.json`: high-water progress for
+  the explicit `cockpit backfill` command.
 - `.codex-autorunner/contextspace/active_context.md` in the work repo when a
   work context is active.
 
@@ -220,7 +225,8 @@ cockpit sessions --workspace "$PWD" --json
 ```
 
 This preview includes both active and archived Codex sessions in the bounded
-backfill window, plus Claude Code sessions when Claude collection is enabled.
+scan window, plus Claude Code sessions when Claude collection is enabled. Use
+`--since-days N` or `--all` when debugging older local history.
 
 Remote metadata path:
 

package/dist/adapters/attribution-core.js

@@ -19,6 +19,7 @@ export const SCORE_BRANCH_MATCH = 0.15;
 export const SCORE_HEAD_SHA_MATCH = 0.05;
 export const ATTRIBUTION_MIN_SCORE = 0.4;
 export const ATTRIBUTION_MIN_MARGIN = 0.15;
+export const ATTRIBUTED_FALLBACK_MAX_SCORE = 0.39;
 export const SESSION_FILE_UUID_PATTERN = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
 export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
     const originLabel = options.originLabel ?? "origin_url_match";
@@ -71,6 +72,9 @@ export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
     const best = scored[0];
     const secondBestScore = scored[1]?.score ?? 0;
     if (!best || best.score === 0) {
+        if (repoPathAbsentFromDisk([...signals.cwds, ...signals.workspaceRoots], options.collectionRoots ?? [])) {
+            return skipped("repo_not_on_disk");
+        }
         const reason = signals.cwds.length > 0 || signals.workspaceRoots.length > 0
             ? "cwd_outside_scanned_worktrees"
             : "no_matching_worktree_signals";
@@ -78,7 +82,8 @@ export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
     }
     const score = clampScore(best.score);
     const pathScore = clampScore(best.pathScore);
-    if (best.score >= ATTRIBUTION_MIN_SCORE &&
+    if (best.pathScore > 0 &&
+        best.score >= ATTRIBUTION_MIN_SCORE &&
         best.score - secondBestScore >= ATTRIBUTION_MIN_MARGIN) {
         return {
             state: "attributed",
@@ -89,6 +94,16 @@ export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
             worktree: best.worktree,
         };
     }
+    if (best.pathScore === 0) {
+        const fallback = fallbackToKnownRepoPrimaryWorkContext({
+            originLabel,
+            scored,
+            signals,
+            worktrees,
+        });
+        if (fallback)
+            return fallback;
+    }
     return {
         state: "ambiguous",
         reason: best.score - secondBestScore < ATTRIBUTION_MIN_MARGIN
@@ -110,6 +125,54 @@ function unattributed(reason) {
         worktree: null,
     };
 }
+function skipped(reason) {
+    return {
+        state: "skipped",
+        reason,
+        signals: [],
+        attribution_score: 0,
+        path_score: 0,
+        worktree: null,
+    };
+}
+function fallbackToKnownRepoPrimaryWorkContext(options) {
+    const originCandidates = options.worktrees.filter((worktree) => worktree.repo_origin_url &&
+        options.signals.originUrls.includes(worktree.repo_origin_url));
+    if (originCandidates.length === 0)
+        return null;
+    const primaryByClone = originCandidates.filter((worktree) => worktree.worktree_is_primary);
+    const cloneCandidates = primaryByClone.length > 0 ? primaryByClone : originCandidates;
+    const cloneRoots = new Set(cloneCandidates.map((worktree) => path.resolve(worktree.repo_root)));
+    if (cloneRoots.size > 1) {
+        return {
+            state: "ambiguous",
+            reason: "multiple_repos_share_origin",
+            signals: [options.originLabel],
+            attribution_score: ATTRIBUTED_FALLBACK_MAX_SCORE,
+            path_score: 0,
+            worktree: null,
+        };
+    }
+    const primary = primaryByClone[0] ??
+        originCandidates.find((worktree) => worktree.worktree_is_primary) ??
+        originCandidates[0] ??
+        null;
+    if (!primary)
+        return null;
+    const primaryScore = options.scored.find((entry) => entry.worktree.worktree_fingerprint === primary.worktree_fingerprint);
+    const signals = new Set([
+        ...(primaryScore?.matched ?? [options.originLabel]),
+        "repo_primary_fallback",
+    ]);
+    return {
+        state: "attributed_fallback",
+        reason: "known_repo_primary_fallback",
+        signals: [...signals],
+        attribution_score: clampScore(Math.min(primaryScore?.score ?? SCORE_ORIGIN_MATCH, ATTRIBUTED_FALLBACK_MAX_SCORE)),
+        path_score: 0,
+        worktree: primary,
+    };
+}
 /**
  * For each path signal, the single worktree whose root most specifically
  * contains it (the longest containing root). Returns the set of worktree
@@ -141,6 +204,12 @@ export function isPathWithin(candidate, root) {
     return (normalizedCandidate === normalizedRoot ||
         normalizedCandidate.startsWith(normalizedRoot + path.sep));
 }
+function repoPathAbsentFromDisk(paths, collectionRoots) {
+    if (paths.length === 0 || collectionRoots.length === 0)
+        return false;
+    const roots = collectionRoots.map((root) => path.resolve(root));
+    return paths.some((value) => roots.some((root) => isPathWithin(value, root)));
+}
 export function clampScore(value) {
     return Math.min(1, Math.max(0, Number(value.toFixed(4))));
 }

package/dist/adapters/claude-attribution.js

@@ -1,4 +1,4 @@
-import { SECRET_FILE_SEGMENT_PATTERN, containsSecretLikeContent, } from "@bli-cockpit/telemetry-core";
+import { RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, SECRET_FILE_SEGMENT_PATTERN, containsSecretLikeContent, } from "@bli-cockpit/telemetry-core";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import { createReadStream } from "node:fs";
@@ -24,7 +24,7 @@ export const CLAUDE_ATTRIBUTION_DEFAULT_SINCE_MINUTES = 24 * 60;
 export const CLAUDE_ATTRIBUTION_DEFAULT_SESSION_LIMIT = 50;
 // Upload cap, NOT an attribution cap (D7): an oversized main file is still
 // scored and attributed via a streamed read; only the file's bytes stay local.
-export const CLAUDE_SESSION_MAX_FILE_BYTES = 10 * 1024 * 1024;
+export const CLAUDE_SESSION_MAX_FILE_BYTES = RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES;
 export const CLAUDE_SESSION_MAX_SIDECAR_FILES = 40;
 // JSONL lines holding a large tool result can be multi-MiB; a streamed read of
 // an oversized main caps the per-line buffer so one giant line cannot blow
@@ -48,7 +48,7 @@ export async function scanAndAttributeClaudeSessions(options) {
         .slice(0, limit);
     const results = [];
     for (const session of sessions) {
-        results.push(await attributeOneSession(session, options.worktrees));
+        results.push(await attributeOneSession(session, options.worktrees, options.collectionRoots ?? []));
     }
     const sumBy = (pick) => results.reduce((total, result) => total + pick(result), 0);
     const countState = (state) => results.filter((result) => result.state === state).length;
@@ -69,6 +69,7 @@ export async function scanAndAttributeClaudeSessions(options) {
         sidecar_stat_failed_count: discovery.sidecarStatFailedCount,
         counts: {
             attributed: countState("attributed"),
+            attributed_fallback: countState("attributed_fallback"),
             ambiguous: countState("ambiguous"),
             unattributed: countState("unattributed"),
             skipped: countState("skipped"),
@@ -211,7 +212,7 @@ async function discoverSidecars(subagentsDir) {
         statFailedCount,
     };
 }
-async function attributeOneSession(session, worktrees) {
+async function attributeOneSession(session, worktrees, collectionRoots) {
     const fileName = path.basename(session.mainFile);
     const base = {
         file_path: session.mainFile,
@@ -303,7 +304,7 @@ async function attributeOneSession(session, worktrees) {
         originUrls: signals.repository_urls,
         branches: signals.branches,
         headShas: [],
-    }, worktrees, { originLabel: "pr_repo_match" });
+    }, worktrees, { collectionRoots, originLabel: "pr_repo_match" });
     const extraSignals = [];
     if (base.main_file_oversized)
         extraSignals.push("main_file_oversized");

package/dist/adapters/codex-attribution.js

@@ -21,8 +21,8 @@ import { sanitizeSessionId, scoreSignalsAgainstWorktrees, sessionIdFromFileName,
 export { sanitizeSessionId, sessionIdFromFileName };
 export const CODEX_ATTRIBUTION_DEFAULT_SINCE_MINUTES = 24 * 60;
 export const CODEX_ATTRIBUTION_DEFAULT_SESSION_LIMIT = 50;
-export const CODEX_ATTRIBUTION_BACKFILL_SINCE_MINUTES = 14 * 24 * 60;
-export const CODEX_ATTRIBUTION_BACKFILL_SESSION_LIMIT = 500;
+export const CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES = 14 * 24 * 60;
+export const CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT = 500;
 // Compatibility export only. Codex attribution streams full files for metadata
 // and no longer rejects sessions by file size; raw evidence collection enforces
 // upload budgets and content guards later.
@@ -42,7 +42,7 @@ export async function scanAndAttributeCodexSessions(options) {
     const files = discovery.files.slice(0, limit);
     const results = [];
     for (const file of files) {
-        results.push(await attributeOneSession(file, options.worktrees));
+        results.push(await attributeOneSession(file, options.worktrees, options.collectionRoots ?? []));
     }
     return {
         results,
@@ -57,6 +57,7 @@ export async function scanAndAttributeCodexSessions(options) {
         secret_path_skipped_count: discovery.secretPathSkippedCount,
         counts: {
             attributed: results.filter((entry) => entry.state === "attributed").length,
+            attributed_fallback: results.filter((entry) => entry.state === "attributed_fallback").length,
             ambiguous: results.filter((entry) => entry.state === "ambiguous").length,
             unattributed: results.filter((entry) => entry.state === "unattributed")
                 .length,
@@ -148,7 +149,7 @@ function dedupePaths(values) {
     }
     return out;
 }
-async function attributeOneSession(file, worktrees) {
+async function attributeOneSession(file, worktrees, collectionRoots) {
     const fileName = path.basename(file.file);
     const base = {
         file_path: file.file,
@@ -200,7 +201,7 @@ async function attributeOneSession(file, worktrees) {
         originUrls: signals.repository_urls,
         branches: signals.branches,
         headShas: signals.commit_hashes,
-    }, worktrees);
+    }, worktrees, { collectionRoots });
     return { ...base, ...outcome };
 }
 async function readCodexMetadataSignals(filePath) {

package/dist/adapters/common.js

@@ -1,4 +1,4 @@
-import { SourceScanResultSchema, } from "@bli-cockpit/telemetry-core";
+import { SourceScanResultSchema, parseTicketIdFromText, } from "@bli-cockpit/telemetry-core";
 import { LOCAL_COLLECTOR_VERSION } from "../local-state.js";
 export function makeSourceAdapterIdentity(captureSource, adapterName) {
     return {
@@ -34,7 +34,4 @@ export function makeSourceScan(context, captureSource, adapterName, status, reas
         diagnostic_labels: [reasonLabel],
     });
 }
-export function parseTicketIdFromText(value) {
-    const match = value.match(/\b[A-Z][A-Z0-9]{1,12}-\d+\b/);
-    return match?.[0] ?? null;
-}
+export { parseTicketIdFromText };

package/dist/adapters/raw-evidence.js

@@ -1,4 +1,4 @@
-import { EvidenceCompletenessPayloadSchema, SECRET_FILE_SEGMENT_PATTERN, SourceScanResultSchema, containsSecretLikeContent, redactSecretLikeContent, } from "@bli-cockpit/telemetry-core";
+import { EvidenceCompletenessPayloadSchema, RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, SECRET_FILE_SEGMENT_PATTERN, SourceScanResultSchema, containsSecretLikeContent, redactSecretLikeContent, } from "@bli-cockpit/telemetry-core";
 import { spawn } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
@@ -13,14 +13,12 @@ const MAX_GIT_DIFF_BYTES = 2 * 1024 * 1024;
 const GIT_DIFF_TIMEOUT_MS = 3_000;
 export const RAW_EVIDENCE_BUCKET = "ambient-raw-evidence";
 export const RAW_EVIDENCE_RETENTION_MODE = "remote_durable";
-// Per-sync upload budgets enforced at COLLECTION time (D7b). With sidecars a
-// worst-case sync could buffer hundreds of MiB and fire thousands of chunk
-// POSTs; the byte budget bounds buffered bytes and the object budget bounds
-// request count. Overflow becomes a deferred-skip entry, picked up next sync
-// (content addressing makes this convergent).
-export const RAW_EVIDENCE_DEFAULT_BYTE_BUDGET = 512 * 1024 * 1024;
+// Per-sync upload budgets enforced at COLLECTION time (D7b). A single marathon
+// transcript can now approach 512 MiB, so 2 GiB leaves room for several files
+// without starving the sync; overflow still defers and converges next run.
+export const RAW_EVIDENCE_DEFAULT_BYTE_BUDGET = 2 * 1024 * 1024 * 1024;
 export const RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET = 300;
-const CLAUDE_MAX_COLLECT_FILE_BYTES = 10 * 1024 * 1024;
+const CLAUDE_MAX_COLLECT_FILE_BYTES = RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES;
 export async function collectRawEvidencePack(context, options) {
     const startedAt = context.now.toISOString();
     const packId = rawEvidencePackId(context);
@@ -587,6 +585,29 @@ async function collectOneEvidenceFile(collection, options) {
         });
         return false;
     }
+    if (options.maxFileBytes) {
+        let stat;
+        try {
+            stat = await fs.stat(options.filePath);
+        }
+        catch {
+            collection.skipped.push({
+                kind: options.kind,
+                label: fileName,
+                reason: "file_read_failed",
+            });
+            return false;
+        }
+        if (stat.size > options.maxFileBytes) {
+            markCapApplied(collection, options.kind, "max_file_bytes");
+            collection.skipped.push({
+                kind: options.kind,
+                label: fileName,
+                reason: "file_too_large",
+            });
+            return false;
+        }
+    }
     let raw;
     try {
         raw = await fs.readFile(options.filePath);

package/dist/backfill-lock.js

@@ -0,0 +1,108 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+const BACKFILL_LOCK_FILENAME = "backfill.lock";
+const HEARTBEAT_INTERVAL_MS = 30_000;
+export const BACKFILL_LOCK_STALE_TAKEOVER_MS = 5 * 60_000;
+export async function acquireBackfillLock(paths, now = new Date()) {
+    const lockPath = backfillLockPath(paths);
+    await fs.mkdir(paths.cursors_dir, { recursive: true, mode: 0o700 });
+    const token = crypto.randomUUID();
+    const existing = await readBackfillLockRecord(lockPath);
+    if (existing &&
+        now.getTime() - existing.heartbeat_ms <= BACKFILL_LOCK_STALE_TAKEOVER_MS) {
+        return { acquired: false, held_since: existing.heartbeat_at };
+    }
+    let owned = await tryExclusiveCreate(lockPath, token, now);
+    if (!owned) {
+        const current = await readBackfillLockRecord(lockPath);
+        if (current &&
+            now.getTime() - current.heartbeat_ms <= BACKFILL_LOCK_STALE_TAKEOVER_MS) {
+            return { acquired: false, held_since: current.heartbeat_at };
+        }
+        await writeBackfillLock(lockPath, token, now);
+        owned = true;
+    }
+    const heartbeat = async () => {
+        const current = await readBackfillLockRecord(lockPath);
+        if (current && current.token === token) {
+            await writeBackfillLock(lockPath, token, new Date());
+        }
+    };
+    const timer = setInterval(() => {
+        void heartbeat().catch(() => undefined);
+    }, HEARTBEAT_INTERVAL_MS);
+    timer.unref?.();
+    return {
+        acquired: true,
+        handle: {
+            heartbeat,
+            release: async () => {
+                clearInterval(timer);
+                const current = await readBackfillLockRecord(lockPath);
+                if (current && current.token === token) {
+                    await fs.rm(lockPath, { force: true }).catch(() => undefined);
+                }
+            },
+        },
+    };
+}
+export async function inspectBackfillLock(paths, now = new Date()) {
+    const record = await readBackfillLockRecord(backfillLockPath(paths));
+    if (!record ||
+        now.getTime() - record.heartbeat_ms > BACKFILL_LOCK_STALE_TAKEOVER_MS) {
+        return { held: false, held_since: null };
+    }
+    return { held: true, held_since: record.heartbeat_at };
+}
+export function backfillLockPath(paths) {
+    return path.join(paths.cursors_dir, BACKFILL_LOCK_FILENAME);
+}
+async function tryExclusiveCreate(lockPath, token, now) {
+    try {
+        const handle = await fs.open(lockPath, "wx", 0o600);
+        await handle.writeFile(serializeBackfillLock(token, now));
+        await handle.close();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function writeBackfillLock(lockPath, token, now) {
+    await fs.writeFile(lockPath, serializeBackfillLock(token, now), {
+        mode: 0o600,
+    });
+}
+function serializeBackfillLock(token, now) {
+    const record = {
+        pid: process.pid,
+        token,
+        heartbeat_at: now.toISOString(),
+        heartbeat_ms: now.getTime(),
+    };
+    return `${JSON.stringify(record)}\n`;
+}
+async function readBackfillLockRecord(lockPath) {
+    try {
+        const raw = JSON.parse(await fs.readFile(lockPath, "utf8"));
+        if (!raw || typeof raw !== "object")
+            return null;
+        const record = raw;
+        const heartbeatMs = record["heartbeat_ms"];
+        if (typeof heartbeatMs !== "number" || !Number.isFinite(heartbeatMs)) {
+            return null;
+        }
+        return {
+            pid: typeof record["pid"] === "number" ? record["pid"] : -1,
+            token: typeof record["token"] === "string" ? record["token"] : "",
+            heartbeat_at: typeof record["heartbeat_at"] === "string"
+                ? record["heartbeat_at"]
+                : new Date(heartbeatMs).toISOString(),
+            heartbeat_ms: heartbeatMs,
+        };
+    }
+    catch {
+        return null;
+    }
+}