@bli-cockpit/cli 0.1.6 → 0.1.8

package/dist/cursors/raw-evidence-cursor.js

@@ -1,8 +1,32 @@
+import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
-const CURSOR_FILENAME = "raw-evidence.json";
-const MAX_TRACKED_OBJECTS = 500;
-const MAX_TRACKED_SESSIONS = 500;
+/**
+ * Durable local cursor for raw-evidence harvesting.
+ *
+ * - `objects` maps content hashes to durable remote objects so repeated syncs
+ *   acknowledge identical content instead of re-uploading it.
+ * - `sessions` tracks observed agent session files (hash, mtime, processed
+ *   byte offset, last attribution outcome, last durable upload) so repeated
+ *   syncs skip unchanged work, growth damping has its inputs, and stale
+ *   sessions are countable instead of silently forgotten.
+ *
+ * The cursor stores hashes, ids, sizes, and labels only — never content.
+ *
+ * Per-source sessions, ONE shared objects map (D4): each source keeps its own
+ * sessions file (`raw-evidence.json` for Codex, `claude-raw-evidence.json` for
+ * Claude) so session-id namespaces never collide and stale counts stay
+ * per-source. The committed-OBJECTS map lives ONLY in the primary cursor; the
+ * Claude cursor carries sessions only and its `objects` record is asserted
+ * empty on write.
+ */
+export const PRIMARY_CURSOR_FILENAME = "raw-evidence.json";
+export const CLAUDE_CURSOR_FILENAME = "claude-raw-evidence.json";
+// Sidecars can push a single sync past 500 objects; pruning at 500 would force
+// re-read + re-begin of durable objects every sync thereafter. Entries are
+// ~150 B, so 5,000 is ~750 KB on disk (D4).
+const MAX_TRACKED_OBJECTS = 5_000;
+const MAX_TRACKED_SESSIONS = 5_000;
 export function emptyRawEvidenceCursorState() {
     return {
         schema_version: "cockpit-raw-evidence-cursor.v1",
@@ -11,22 +35,44 @@ export function emptyRawEvidenceCursorState() {
         sessions: {},
     };
 }
-export async function readRawEvidenceCursor(paths) {
+export async function readRawEvidenceCursor(paths, options = {}) {
     try {
-        const raw = JSON.parse(await fs.readFile(rawEvidenceCursorPath(paths), "utf8"));
+        const raw = JSON.parse(await fs.readFile(rawEvidenceCursorPath(paths, options.filename), "utf8"));
         return parseCursorState(raw);
     }
     catch {
         return emptyRawEvidenceCursorState();
     }
 }
-export async function writeRawEvidenceCursor(paths, state) {
-    const filePath = rawEvidenceCursorPath(paths);
+export async function writeRawEvidenceCursor(paths, state, options = {}) {
+    const filePath = rawEvidenceCursorPath(paths, options.filename);
     await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
     const pruned = pruneCursorState(state);
-    await fs.writeFile(filePath, `${JSON.stringify(pruned, null, 2)}\n`, {
-        mode: 0o600,
-    });
+    if (options.sessionsOnly && Object.keys(pruned.objects).length > 0) {
+        // Invariant enforcement (D4): the Claude cursor never owns objects.
+        pruned.objects = {};
+    }
+    const serialized = `${JSON.stringify(pruned, null, 2)}\n`;
+    // Atomic write: a launchd sync and a manual sync can race the same cursor, so
+    // write a sibling temp file, fsync it, and rename over the target. A crash
+    // mid-write leaves either the old or the new state, never a truncated file.
+    const tempPath = `${filePath}.tmp-${process.pid}-${crypto.randomUUID()}`;
+    let handle = null;
+    try {
+        handle = await fs.open(tempPath, "w", 0o600);
+        await handle.writeFile(serialized);
+        await handle.sync();
+    }
+    finally {
+        await handle?.close();
+    }
+    try {
+        await fs.rename(tempPath, filePath);
+    }
+    catch (error) {
+        await fs.rm(tempPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
     if (process.platform !== "win32") {
         await fs.chmod(filePath, 0o600).catch(() => undefined);
     }
@@ -37,8 +83,8 @@ export function markObjectCommitted(state, contentHash, entry) {
 export function hasCommittedObject(state, contentHash) {
     return Boolean(contentHash && state.objects[contentHash]);
 }
-export function recordSessionObservation(state, codexSessionId, entry) {
-    state.sessions[codexSessionId] = entry;
+export function recordSessionObservation(state, sessionId, entry) {
+    state.sessions[sessionId] = entry;
 }
 /**
  * Sessions tracked by the cursor that no longer appear in the current scan
@@ -115,15 +161,20 @@ function parseSessionEntry(value) {
         reason: optionalString(record["reason"]) ?? "unknown",
         worktree_fingerprint: optionalString(record["worktree_fingerprint"]),
         uploaded_object_key: optionalString(record["uploaded_object_key"]),
+        uploaded_at: optionalString(record["uploaded_at"]),
+        uploaded_byte_size: optionalNumberOrNull(record["uploaded_byte_size"]),
         last_seen_at: lastSeenAt,
     };
 }
-function rawEvidenceCursorPath(paths) {
-    return path.join(paths.cursors_dir, CURSOR_FILENAME);
+function rawEvidenceCursorPath(paths, filename = PRIMARY_CURSOR_FILENAME) {
+    return path.join(paths.cursors_dir, filename);
 }
 function optionalString(value) {
     return typeof value === "string" && value.trim() ? value : null;
 }
 function optionalNumber(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function optionalNumberOrNull(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
 }

package/dist/local-state.js

@@ -5,8 +5,8 @@ import os from "node:os";
 import path from "node:path";
 import { resolveRepoWorktreeIdentity, } from "./repo-identity.js";
 import { summarizeLocalUploadSpool } from "./spool/local-spool.js";
-export const LOCAL_COLLECTOR_VERSION = "0.1.6";
-export const DEFAULT_DASHBOARD_URL = "http://127.0.0.1:3100";
+export const LOCAL_COLLECTOR_VERSION = "0.1.8";
+export const DEFAULT_DASHBOARD_URL = "https://bli-cockpit-dashboard.vercel.app";
 export function getCollectorRuntimePaths(homeDir = os.homedir()) {
     const paths = getUserLocalCockpitPaths(homeDir);
     return {

package/dist/repo-identity.js

@@ -58,14 +58,14 @@ export async function resolveRepoWorktreeIdentity(repoRoot) {
 }
 export async function discoverGitWorktrees(root, options = {}) {
     const resolvedRoot = path.resolve(root);
+    const maxWorktrees = options.maxWorktrees ?? 50;
     const direct = await resolveRepoWorktreeIdentity(resolvedRoot).catch(() => null);
     if (direct)
-        return [direct];
+        return expandLinkedWorktrees([direct], maxWorktrees);
     if (await hasGitMarker(resolvedRoot)) {
-        return [await fallbackFilesystemIdentity(resolvedRoot)];
+        return expandLinkedWorktrees([await fallbackFilesystemIdentity(resolvedRoot)], maxWorktrees);
     }
     const maxDepth = options.maxDepth ?? 2;
-    const maxWorktrees = options.maxWorktrees ?? 50;
     const discovered = new Map();
     const stack = [{ dir: resolvedRoot, depth: 0 }];
     const visited = new Set();
@@ -92,7 +92,53 @@ export async function discoverGitWorktrees(root, options = {}) {
             stack.push({ dir: path.join(current.dir, entry.name), depth: current.depth + 1 });
         }
     }
-    return [...discovered.values()].sort(compareIdentity);
+    return expandLinkedWorktrees([...discovered.values()].sort(compareIdentity), maxWorktrees);
+}
+/**
+ * Directory discovery skips dot-dirs, so Claude Code's isolation worktrees
+ * (`<repo>/.claude/worktrees/<name>`) and any other linked worktree are never
+ * found by walking the filesystem. A session whose cwd sits inside one would
+ * otherwise satisfy `isPathWithin(cwd, parentRoot)` and attribute confidently
+ * to the PARENT with the wrong branch and worktree fingerprint. Enumerating
+ * `git worktree list --porcelain` for each discovered repo adds the linked
+ * worktrees as first-class candidates with their own branch/fingerprint; the
+ * deepest-root tie-break (attribution-core D6) then attributes nested-worktree
+ * sessions to the correct linked worktree. Benefits Codex sessions identically.
+ */
+async function expandLinkedWorktrees(identities, maxWorktrees) {
+    const byFingerprint = new Map(identities.map((identity) => [identity.worktree_fingerprint, identity]));
+    const seenRoots = new Set(identities.map((identity) => path.resolve(identity.repo_root)));
+    for (const identity of identities) {
+        if (byFingerprint.size >= maxWorktrees)
+            break;
+        // One `git worktree list` from any worktree returns every worktree of that
+        // repo, so a single call per already-discovered repo covers its linked set.
+        for (const worktreePath of await listLinkedWorktreePaths(identity.repo_root)) {
+            if (byFingerprint.size >= maxWorktrees)
+                break;
+            const resolved = path.resolve(worktreePath);
+            if (seenRoots.has(resolved))
+                continue;
+            seenRoots.add(resolved);
+            const linked = await resolveRepoWorktreeIdentity(resolved).catch(() => null);
+            if (linked && !byFingerprint.has(linked.worktree_fingerprint)) {
+                byFingerprint.set(linked.worktree_fingerprint, linked);
+            }
+        }
+    }
+    return [...byFingerprint.values()].sort(compareIdentity);
+}
+async function listLinkedWorktreePaths(repoRoot) {
+    const porcelain = await runGit(["worktree", "list", "--porcelain"], repoRoot).catch(() => "");
+    const paths = [];
+    for (const line of porcelain.split("\n")) {
+        if (line.startsWith("worktree ")) {
+            const value = line.slice("worktree ".length).trim();
+            if (value)
+                paths.push(value);
+        }
+    }
+    return paths;
 }
 async function hasGitMarker(dir) {
     return fs.stat(path.join(dir, ".git")).then((stat) => stat.isDirectory() || stat.isFile(), () => false);

package/dist/sync-lock.js

@@ -0,0 +1,113 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+/**
+ * Single-flight lock for `cockpit sync`. A launchd timer and a manual sync can
+ * fire at the same time and interleave the cursor read-modify-write; this lock
+ * lets the second invocation exit cleanly with `sync_already_running` instead.
+ *
+ * A held lock refreshes a heartbeat every 30 s. Takeover happens only when the
+ * heartbeat is more than 2 minutes stale — a fixed short timeout would fire
+ * during a legitimate long first sync and recreate the interleaving it
+ * prevents (D33). The lock file stays local and stores a pid + heartbeat only;
+ * no paths or content.
+ */
+const LOCK_FILENAME = "sync.lock";
+const HEARTBEAT_INTERVAL_MS = 30_000;
+const STALE_TAKEOVER_MS = 2 * 60_000;
+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 });
+    const token = crypto.randomUUID();
+    const existing = await readLock(lockPath);
+    if (existing && now.getTime() - existing.heartbeat_ms <= STALE_TAKEOVER_MS) {
+        return { acquired: false, held_since: existing.heartbeat_at };
+    }
+    // Free or stale: try an exclusive create first; if another process created it
+    // in the gap, re-check staleness before taking over.
+    let owned = await tryExclusiveCreate(lockPath, token, now);
+    if (!owned) {
+        const current = await readLock(lockPath);
+        if (current && now.getTime() - current.heartbeat_ms <= STALE_TAKEOVER_MS) {
+            return { acquired: false, held_since: current.heartbeat_at };
+        }
+        await writeLock(lockPath, token, now); // take over the stale lock
+        owned = true;
+    }
+    const timer = setInterval(() => {
+        // Refresh only while the lock is still ours; if we were taken over, stop
+        // touching the file so we cannot steal it back from the new owner.
+        void (async () => {
+            const current = await readLock(lockPath);
+            if (current && current.token === token) {
+                await writeLock(lockPath, token, new Date()).catch(() => undefined);
+            }
+            else {
+                clearInterval(timer);
+            }
+        })().catch(() => undefined);
+    }, HEARTBEAT_INTERVAL_MS);
+    // Never keep the CLI process alive just to refresh the heartbeat.
+    timer.unref?.();
+    return {
+        acquired: true,
+        handle: {
+            release: async () => {
+                clearInterval(timer);
+                // Ownership-safe: only remove the lock if it is still ours. A stale
+                // owner that resumes after takeover must not delete the new owner's lock.
+                const current = await readLock(lockPath);
+                if (current && current.token === token) {
+                    await fs.rm(lockPath, { force: true }).catch(() => undefined);
+                }
+            },
+        },
+    };
+}
+async function tryExclusiveCreate(lockPath, token, now) {
+    try {
+        const handle = await fs.open(lockPath, "wx", 0o600);
+        await handle.writeFile(serializeLock(token, now));
+        await handle.close();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function writeLock(lockPath, token, now) {
+    await fs.writeFile(lockPath, serializeLock(token, now), { mode: 0o600 });
+}
+function serializeLock(token, now) {
+    const record = {
+        pid: process.pid,
+        token,
+        heartbeat_at: now.toISOString(),
+        heartbeat_ms: now.getTime(),
+    };
+    return `${JSON.stringify(record)}\n`;
+}
+async function readLock(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"];
+        const heartbeatAt = record["heartbeat_at"];
+        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 heartbeatAt === "string"
+                ? heartbeatAt
+                : new Date(heartbeatMs).toISOString(),
+            heartbeat_ms: heartbeatMs,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/upload.js

@@ -55,9 +55,15 @@ export async function buildLocalAmbientEnvelope(options = {}) {
         activeWorkContext: activeContext,
         rawEvidenceStateDir: paths.state_dir,
         rawEvidenceSessionsDir: path.join(paths.home_dir, ".codex", "sessions"),
+        claudeProjectsDir: path.join(paths.home_dir, ".claude", "projects"),
         rawEvidenceIncludeCodexJsonl: options.rawEvidenceIncludeCodexJsonl,
+        rawEvidenceIncludeClaudeJsonl: options.rawEvidenceIncludeClaudeJsonl,
         rawEvidenceCodexSessionFiles: options.codexSessionFiles,
+        rawEvidenceClaudeSessionFiles: options.claudeSessionFiles,
         rawEvidenceSkipContentHashes: skipContentHashes,
+        rawEvidenceByteBudget: options.rawEvidenceByteBudget,
+        rawEvidenceObjectBudget: options.rawEvidenceObjectBudget,
+        rawEvidenceBudget: options.rawEvidenceBudget,
         now,
     });
     const binding = sourceCollection.binding;
@@ -356,6 +362,8 @@ function rawEvidenceSummary(built, outcomes, uploadedChunkCount, cursor) {
             })),
             ...cursorReusedOutcomes,
         ],
+        raw_evidence_deferred_byte_budget: built.raw_evidence_facts?.deferred_byte_budget_count ?? 0,
+        raw_evidence_deferred_object_budget: built.raw_evidence_facts?.deferred_object_budget_count ?? 0,
         cursor_tracked_object_count: Object.keys(cursor.objects).length,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "private": false,
   "type": "module",
   "bin": {
@@ -26,6 +26,6 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/telemetry-core": "0.1.3"
+    "@bli-cockpit/telemetry-core": "0.1.4"
   }
 }