@bli-cockpit/cli 0.1.6 → 0.1.7

package/dist/commands/local.js

@@ -4,7 +4,11 @@ import { createCollectorServer } from "../server.js";
 import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, inspectLocalCollectorStatus, installLocalCollector, logoutLocalCollector, pairLocalCollector, readLocalCollectorSessionFile, readLocalSessionReference, startLocalWorkContext, } from "../local-state.js";
 import { LocalUploadBlockedError, postCodexSessionReport, syncLocalAmbientEnvelope, } from "../upload.js";
 import { scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
-import { countStaleSessions, readRawEvidenceCursor, recordSessionObservation, writeRawEvidenceCursor, } from "../cursors/raw-evidence-cursor.js";
+import { scanAndAttributeClaudeSessions, } from "../adapters/claude-attribution.js";
+import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET, } from "../adapters/raw-evidence.js";
+import { CLAUDE_CURSOR_FILENAME, countStaleSessions, emptyRawEvidenceCursorState, readRawEvidenceCursor, recordSessionObservation, writeRawEvidenceCursor, } from "../cursors/raw-evidence-cursor.js";
+import { readLocalCollectorConfig } from "../local-state.js";
+import { acquireSyncLock } from "../sync-lock.js";
 import { discoverGitWorktrees, } from "../repo-identity.js";
 export const rootCommandNames = new Set([
     "onboard",
@@ -15,6 +19,7 @@ export const rootCommandNames = new Set([
     "start",
     "sync",
     "status",
+    "sessions",
     "serve",
 ]);
 export async function runLocalCockpitCli(argv, io = defaultIo()) {
@@ -48,6 +53,8 @@ export async function runLocalCockpitCli(argv, io = defaultIo()) {
                 return await runSync(command, io);
             case "status":
                 return await runStatus(command, io);
+            case "sessions":
+                return await runSessions(command, io);
             case "serve":
                 return await runServe(command, io);
         }
@@ -69,6 +76,7 @@ export function localCommandHelp(command) {
         "  cockpit start [--ticket <id>] [--repo <path>] [--branch <name>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit sync [--repo <path>] [--dashboard-url <url>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit status [--repo <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
+        "  cockpit sessions [--source codex|claude] [--repo <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit serve [--port <port>] [--repo <path>]",
     ].join("\n");
 }
@@ -124,9 +132,11 @@ function localSubcommandHelp(command) {
                 "Usage: cockpit sync [--repo <path>] [--dashboard-url <url>] [--json]",
                 "",
                 "Uploads latest local ambient envelope(s), or spools safe retries if blocked.",
-                "Parent folders sync each child git worktree; Codex JSONL transcripts are attributed",
-                "to repos deterministically and ambiguous transcripts are retained as unattributed",
-                "instead of being duplicated across repos.",
+                "Parent folders sync each child git worktree; Codex AND Claude Code JSONL",
+                "transcripts (and Claude subagent sidecars) are attributed to repos",
+                "deterministically and ambiguous transcripts are retained as unattributed",
+                "instead of being duplicated across repos. Use `cockpit sessions` to see why",
+                "a session is or is not collected.",
                 "Newly discovered repos get a general ambient work context automatically.",
                 "Discovery scans 3 folder levels and up to 50 repos by default; tune with",
                 "--max-depth and --max-repos.",
@@ -140,6 +150,17 @@ function localSubcommandHelp(command) {
                 "Prints install, pairing, active work, upload, and retry state.",
             ],
         ],
+        [
+            "sessions",
+            [
+                "Usage: cockpit sessions [--source codex|claude] [--repo <path>] [--json]",
+                "",
+                "Read-only: re-runs Codex + Claude session attribution and prints each",
+                "session's id, source, state, reason, scores, signals, and per-sidecar",
+                "skip reasons. No upload, no cursor writes. Answers \"why is session X",
+                "missing?\" locally — counts and labels only, never paths or content.",
+            ],
+        ],
         [
             "serve",
             [
@@ -175,6 +196,8 @@ function parseLocalArgs(argv) {
             return parseSyncArgs(argv.slice(1));
         case "status":
             return parseStatusArgs(argv.slice(1));
+        case "sessions":
+            return parseSessionsArgs(argv.slice(1));
         case "serve":
             return parseServeArgs(argv.slice(1));
         default:
@@ -362,6 +385,26 @@ function parseStatusArgs(args) {
         maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
     };
 }
+function parseSessionsArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: ["--home", "--repo", "--source", "--json", "--max-depth", "--max-repos"],
+        valueFlags: ["--home", "--repo", "--source", "--max-depth", "--max-repos"],
+    });
+    assertNoPositionals(values.positionals, "sessions");
+    const source = values.flags.get("--source");
+    if (source !== undefined && source !== "codex" && source !== "claude") {
+        throw new Error("--source must be 'codex' or 'claude'.");
+    }
+    return {
+        kind: "sessions",
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        repoRoot: optionalNonEmpty(values.flags.get("--repo")),
+        source,
+        json: values.booleans.has("--json"),
+        maxDepth: optionalPositiveInteger(values.flags.get("--max-depth"), "--max-depth"),
+        maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
+    };
+}
 function parseServeArgs(args) {
     const values = parseNamedArgs(args, {
         allowedFlags: ["--home", "--repo", "--port"],
@@ -554,8 +597,7 @@ async function runOnboard(command, io) {
         writeLine(io.stdout, `Risk flags: ${sync.risk_flag_count}`);
         writeLine(io.stdout, `Raw evidence files: ${sync.raw_evidence_file_count}`);
         writeLine(io.stdout, rawEvidenceSyncLine(sync));
-        writeLine(io.stdout, codexSummaryLine(run.summary));
-        writeLine(io.stdout, attributionReportLine(run.summary));
+        writeAgentSessionSummary(io, run.summary);
         writeLine(io.stdout, "5/5 Status ready.");
         writeLine(io.stdout, `Upload state: ${status.upload_state}`);
         writeLine(io.stdout, "PASS: Cockpit collector is ready for harvest.");
@@ -616,21 +658,68 @@ async function readOnboardSessionReuseCandidate(homeDir) {
 function normalizeUrlForComparison(value) {
     return value ? normalizeUrl(value) : null;
 }
+const CLAUDE_FIRST_RUN_BACKFILL_MINUTES = 14 * 24 * 60;
+const CLAUDE_DAMP_GROWTH_BYTES = 256 * 1024;
+const CLAUDE_DAMP_MAX_AGE_MS = 6 * 60 * 60 * 1000;
 /**
- * Shared sync orchestration for single-repo and parent-folder modes: Codex
- * sessions are scanned and attributed once across every discovered worktree,
- * each worktree syncs with only its own attributed transcripts, and the
- * ambiguous/unattributed/skipped remainder is reported with reason labels
- * instead of being duplicated into every repo or silently dropped.
+ * Shared dual-source sync orchestration for single-repo and parent-folder
+ * modes. Codex AND Claude Code sessions are scanned and attributed once across
+ * every discovered worktree; each worktree syncs with only its own attributed
+ * transcripts (codex + claude main + sidecars), and the
+ * ambiguous/unattributed/skipped remainder is reported with reason labels and a
+ * `source` discriminator instead of being duplicated into every repo or
+ * silently dropped. The session row's upload state maps ONLY from the main-file
+ * outcome (D3); sidecar outcomes aggregate into CLI counts.
  */
 async function runAttributedWorktreeSync(options) {
     const now = new Date();
     const homeDir = options.homeDir ?? os.homedir();
-    const attribution = await scanAndAttributeCodexSessions({
+    const paths = getCollectorRuntimePaths(options.homeDir);
+    const claudeEnabled = await isClaudeCollectionEnabled(paths);
+    const codexAttribution = await scanAndAttributeCodexSessions({
         sessionsDir: path.join(homeDir, ".codex", "sessions"),
         worktrees: options.worktrees,
         now,
     });
+    // First run (D B.4 §8): without a Claude cursor yet, widen the window to 14
+    // days so the first sync captures retroactive history instead of only 24h.
+    const claudeCursorExists = await fileExists(path.join(paths.cursors_dir, CLAUDE_CURSOR_FILENAME));
+    const firstRunBackfill = claudeEnabled && !claudeCursorExists;
+    const claudeAttribution = claudeEnabled
+        ? await scanAndAttributeClaudeSessions({
+            projectsDir: path.join(homeDir, ".claude", "projects"),
+            worktrees: options.worktrees,
+            now,
+            sinceMinutes: firstRunBackfill
+                ? CLAUDE_FIRST_RUN_BACKFILL_MINUTES
+                : undefined,
+        })
+        : emptyClaudeScan();
+    // Read the Claude cursor up front: damping decisions need prior upload state.
+    const claudeCursorBefore = claudeEnabled
+        ? await readRawEvidenceCursor(paths, {
+            filename: CLAUDE_CURSOR_FILENAME,
+        }).catch(() => emptyRawEvidenceCursorState())
+        : emptyRawEvidenceCursorState();
+    // sessionId -> prior durable pointer for damped sessions (drives the
+    // growth_damped count + the skip_main decision).
+    const dampedClaudePointers = new Map();
+    // sessionId -> prior durable pointer for EVERY already-durable Claude session
+    // (superset of damped). A session that was durable before but had no fresh
+    // upload this sync (damped, spooled, budget-deferred) reports reused_existing
+    // with this pointer instead of not_uploaded, so the store row never flips.
+    const claudePriorDurablePointers = new Map();
+    for (const [sessionId, entry] of Object.entries(claudeCursorBefore.sessions)) {
+        if (entry.uploaded_object_key) {
+            claudePriorDurablePointers.set(sessionId, entry.uploaded_object_key);
+        }
+    }
+    // One shared budget for the whole sync (D7b is per-sync): a parent-folder
+    // sync over many worktrees honors a single byte/object cap rather than N×.
+    const rawEvidenceBudget = {
+        remainingBytes: RAW_EVIDENCE_DEFAULT_BYTE_BUDGET,
+        remainingObjects: RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET,
+    };
     const outcomes = [];
     let ok = true;
     for (const worktree of options.worktrees) {
@@ -645,11 +734,32 @@ async function runAttributedWorktreeSync(options) {
                 sessionId: options.sessionId,
             });
         }
+        const claudeSessionFiles = claudeAttribution.results
+            .filter((result) => result.state === "attributed" &&
+            result.worktree?.worktree_fingerprint ===
+                worktree.worktree_fingerprint)
+            .map((result) => {
+            const damped = !result.main_file_oversized &&
+                shouldDampClaudeMain(result, claudeCursorBefore, now);
+            if (damped) {
+                dampedClaudePointers.set(result.claude_session_id, claudeCursorBefore.sessions[result.claude_session_id]
+                    ?.uploaded_object_key ?? null);
+            }
+            return {
+                local_path: result.file_path,
+                claude_session_id: result.claude_session_id,
+                main_file_oversized: result.main_file_oversized,
+                skip_main: damped,
+                sidecar_files: result.sidecar_files
+                    .filter((sidecar) => !sidecar.skipped_reason)
+                    .map((sidecar) => ({ local_path: sidecar.local_path })),
+            };
+        });
         const syncOptions = {
             homeDir: options.homeDir,
             repoRoot: worktree.repo_root,
             dashboardUrl: options.dashboardUrl,
-            codexSessionFiles: attribution.results
+            codexSessionFiles: codexAttribution.results
                 .filter((result) => result.state === "attributed" &&
                 result.worktree?.worktree_fingerprint ===
                     worktree.worktree_fingerprint)
@@ -657,6 +767,8 @@ async function runAttributedWorktreeSync(options) {
                 local_path: result.file_path,
                 codex_session_id: result.codex_session_id,
             })),
+            claudeSessionFiles,
+            rawEvidenceBudget,
             fetch: options.fetchImpl,
         };
         let sync;
@@ -684,39 +796,54 @@ async function runAttributedWorktreeSync(options) {
         ok = ok && sync.status === "uploaded";
         outcomes.push({ worktree, context, sync });
     }
-    const sessions = buildCodexSessionReport(attribution.results, outcomes, now);
+    const sessions = buildAgentSessionReport({
+        codexResults: codexAttribution.results,
+        claudeResults: claudeAttribution.results,
+        outcomes,
+        now,
+        claudePriorDurablePointers,
+    });
     // The sessions cursor is an optimization; a broken local state dir must not
     // turn already-completed syncs into a CLI crash.
-    let staleSessionCount = 0;
+    let codexStaleCount = 0;
+    let claudeStaleCount = 0;
     try {
-        const paths = getCollectorRuntimePaths(options.homeDir);
-        const cursor = await readRawEvidenceCursor(paths);
-        const seenSessionIds = new Set(attribution.results.map((result) => result.codex_session_id));
-        staleSessionCount = countStaleSessions(cursor, seenSessionIds);
-        for (const result of attribution.results) {
-            const reported = sessions.find((session) => session.codex_session_id === result.codex_session_id);
-            const sessionDurable = reported?.upload_state === "uploaded" ||
-                reported?.upload_state === "reused_existing";
-            recordSessionObservation(cursor, result.codex_session_id, {
-                file_hash_sha256: result.content_hash_sha256,
-                file_mtime_ms: result.session_file_mtime_ms,
-                byte_size: result.byte_size,
-                byte_offset: sessionDurable ? result.byte_size : 0,
-                state: result.state,
-                reason: result.reason,
-                worktree_fingerprint: result.worktree?.worktree_fingerprint ?? null,
-                uploaded_object_key: sessionDurable
-                    ? (reported?.raw_evidence_pointer_id ?? null)
-                    : null,
-                last_seen_at: now.toISOString(),
-            });
-        }
-        cursor.updated_at = now.toISOString();
-        await writeRawEvidenceCursor(paths, cursor);
+        const codexCursor = await readRawEvidenceCursor(paths);
+        codexStaleCount = recordSourceObservations({
+            cursor: codexCursor,
+            results: codexAttribution.results,
+            sessions,
+            source: "codex",
+            sessionIdOf: (result) => result.codex_session_id,
+            now,
+        });
+        codexCursor.updated_at = now.toISOString();
+        await writeRawEvidenceCursor(paths, codexCursor);
     }
     catch {
         // Best-effort: stale counts read 0 and observations re-record next sync.
     }
+    if (claudeEnabled) {
+        try {
+            claudeStaleCount = recordSourceObservations({
+                cursor: claudeCursorBefore,
+                results: claudeAttribution.results,
+                sessions,
+                source: "claude_code",
+                sessionIdOf: (result) => result.claude_session_id,
+                now,
+                priorCursor: claudeCursorBefore,
+            });
+            claudeCursorBefore.updated_at = now.toISOString();
+            await writeRawEvidenceCursor(paths, claudeCursorBefore, {
+                filename: CLAUDE_CURSOR_FILENAME,
+                sessionsOnly: true,
+            });
+        }
+        catch {
+            // Best-effort: a broken Claude cursor must not fail the sync.
+        }
+    }
     const firstUploaded = outcomes.find((outcome) => outcome.sync.status === "uploaded");
     const report = firstUploaded
         ? await postCodexSessionReport({
@@ -731,21 +858,17 @@ async function runAttributedWorktreeSync(options) {
             posted: false,
             reason: sessions.length === 0 ? "no_sessions_observed" : "no_successful_sync",
         };
-    return {
-        ok,
+    const summary = buildAgentSessionSummary({
+        codexAttribution,
+        claudeAttribution,
         outcomes,
-        attribution,
-        summary: {
-            scanned: attribution.scanned_file_count,
-            attributed: attribution.counts.attributed,
-            ambiguous: attribution.counts.ambiguous,
-            unattributed: attribution.counts.unattributed,
-            skipped: attribution.counts.skipped,
-            stale: staleSessionCount,
-            report_posted: report.posted,
-            report_reason: report.reason,
-        },
-    };
+        codexStaleCount,
+        claudeStaleCount,
+        firstRunBackfill,
+        growthDamped: dampedClaudePointers.size,
+        report,
+    });
+    return { ok, outcomes, codexAttribution, claudeAttribution, summary };
 }
 const ATTRIBUTION_STATE_RANK = {
     attributed: 3,
@@ -753,38 +876,100 @@ const ATTRIBUTION_STATE_RANK = {
     unattributed: 1,
     skipped: 0,
 };
-function buildCodexSessionReport(results, outcomes, now) {
-    // Resumed/forked sessions can span multiple files with the same session id;
-    // report each session once, preferring the strongest attribution and the
-    // freshest file.
-    const bestBySessionId = new Map();
-    for (const result of results) {
-        const existing = bestBySessionId.get(result.codex_session_id);
+function normalizeCodexResult(result) {
+    return {
+        source: "codex",
+        session_id: result.codex_session_id,
+        state: result.state,
+        reason: result.reason,
+        signals: result.signals,
+        attribution_score: result.attribution_score,
+        path_score: result.path_score,
+        content_hash_sha256: result.content_hash_sha256,
+        byte_size: result.byte_size,
+        session_file_mtime: result.session_file_mtime,
+        session_file_mtime_ms: result.session_file_mtime_ms,
+        worktree: result.worktree,
+        cwd_basename: result.cwd_basename,
+        cwd_hash: result.cwd_hash,
+    };
+}
+function normalizeClaudeResult(result) {
+    return {
+        source: "claude_code",
+        session_id: result.claude_session_id,
+        state: result.state,
+        reason: result.reason,
+        signals: result.signals,
+        attribution_score: result.attribution_score,
+        path_score: result.path_score,
+        content_hash_sha256: result.content_hash_sha256,
+        byte_size: result.byte_size,
+        session_file_mtime: result.session_file_mtime,
+        session_file_mtime_ms: result.session_file_mtime_ms,
+        worktree: result.worktree,
+        cwd_basename: result.cwd_basename,
+        cwd_hash: result.cwd_hash,
+    };
+}
+/**
+ * Generalizes the per-session report across sources. Dedupe is per
+ * `(source, session_id)` so a Codex session and a Claude session that happen to
+ * share an id are never collapsed. Upload state maps ONLY from the main-file
+ * outcome (kind `codex_jsonl` / `claude_jsonl`); sidecar outcomes never set a
+ * session's upload state (D3). Damped Claude sessions report `reused_existing`
+ * carrying their prior durable pointer.
+ */
+function buildAgentSessionReport(options) {
+    const normalized = [
+        ...options.codexResults.map(normalizeCodexResult),
+        ...options.claudeResults.map(normalizeClaudeResult),
+    ];
+    const bestByKey = new Map();
+    for (const result of normalized) {
+        const key = `${result.source}:${result.session_id}`;
+        const existing = bestByKey.get(key);
         if (!existing ||
             (ATTRIBUTION_STATE_RANK[result.state] ?? 0) >
                 (ATTRIBUTION_STATE_RANK[existing.state] ?? 0) ||
             ((ATTRIBUTION_STATE_RANK[result.state] ?? 0) ===
                 (ATTRIBUTION_STATE_RANK[existing.state] ?? 0) &&
                 result.session_file_mtime_ms > existing.session_file_mtime_ms)) {
-            bestBySessionId.set(result.codex_session_id, result);
+            bestByKey.set(key, result);
         }
     }
-    const dedupedResults = [...bestBySessionId.values()];
-    const uploadBySessionId = new Map();
-    for (const outcome of outcomes) {
+    // Main-file outcomes only (D3): a sidecar making it must never mark a session
+    // uploaded when the main did not.
+    const uploadByKey = new Map();
+    for (const outcome of options.outcomes) {
         if (outcome.sync.status !== "uploaded")
             continue;
         for (const upload of outcome.sync.raw_evidence_outcomes) {
-            if (upload.codex_session_id && upload.raw_evidence_pointer_id) {
-                uploadBySessionId.set(upload.codex_session_id, upload);
-            }
+            if (!upload.codex_session_id || !upload.raw_evidence_pointer_id)
+                continue;
+            const source = upload.kind === "claude_jsonl"
+                ? "claude_code"
+                : upload.kind === "codex_jsonl"
+                    ? "codex"
+                    : null;
+            if (!source)
+                continue; // sidecars and other kinds do not set session state
+            uploadByKey.set(`${source}:${upload.codex_session_id}`, upload);
         }
     }
-    return dedupedResults.map((result) => {
-        const upload = uploadBySessionId.get(result.codex_session_id);
+    return [...bestByKey.values()].map((result) => {
+        const key = `${result.source}:${result.session_id}`;
+        const upload = uploadByKey.get(key);
+        // A previously-durable Claude session with no fresh main upload this sync
+        // (damped / spooled / budget-deferred) reports reused_existing + its prior
+        // pointer rather than not_uploaded, so the store row never flips.
+        const priorDurablePointer = result.source === "claude_code"
+            ? (options.claudePriorDurablePointers.get(result.session_id) ?? null)
+            : null;
         return {
-            codex_session_id: result.codex_session_id,
-            observed_at: now.toISOString(),
+            codex_session_id: result.session_id,
+            source: result.source,
+            observed_at: options.now.toISOString(),
             attribution_state: result.state,
             attribution_reason: result.reason,
             attribution_score: result.attribution_score,
@@ -810,23 +995,215 @@ function buildCodexSessionReport(results, outcomes, now) {
                     raw_evidence_pointer_id: upload.raw_evidence_pointer_id,
                     upload_state: upload.upload_state,
                 }
-                : result.state === "attributed"
-                    ? { upload_state: "not_uploaded" }
-                    : {}),
+                : priorDurablePointer
+                    ? {
+                        raw_evidence_pointer_id: priorDurablePointer,
+                        upload_state: "reused_existing",
+                    }
+                    : result.state === "attributed"
+                        ? { upload_state: "not_uploaded" }
+                        : {}),
         };
     });
 }
+/**
+ * Records per-source session observations into its cursor and returns the stale
+ * count. Damped/reused Claude sessions carry forward their prior upload
+ * timestamp + byte size so the 6h damping window keeps counting from the real
+ * last upload (otherwise a slowly-growing file would never re-upload — D21).
+ */
+function recordSourceObservations(options) {
+    const seen = new Set(options.results.map((result) => options.sessionIdOf(result)));
+    const stale = countStaleSessions(options.cursor, seen);
+    for (const result of options.results) {
+        const sessionId = options.sessionIdOf(result);
+        const reported = options.sessions.find((session) => session.source === options.source &&
+            session.codex_session_id === sessionId);
+        const uploadedThisSync = reported?.upload_state === "uploaded";
+        const durableThisSync = reported?.upload_state === "uploaded" ||
+            reported?.upload_state === "reused_existing";
+        const prior = options.priorCursor?.sessions[sessionId];
+        // D21 / no-flip-flop: a sync that is spooled (offline), budget-deferred, or
+        // upload-failed for a session that was ALREADY durable must NOT wipe the
+        // prior durable state — otherwise damping is forfeited forever and the
+        // store row oscillates uploaded -> not_uploaded hourly. Carry the prior
+        // durable pointer/timestamp/size forward unless we durably uploaded anew.
+        const uploadedObjectKey = durableThisSync
+            ? (reported?.raw_evidence_pointer_id ?? prior?.uploaded_object_key ?? null)
+            : (prior?.uploaded_object_key ?? null);
+        const uploadedAt = uploadedThisSync
+            ? options.now.toISOString()
+            : (prior?.uploaded_at ?? (durableThisSync ? options.now.toISOString() : null));
+        const uploadedByteSize = uploadedThisSync
+            ? result.byte_size
+            : (prior?.uploaded_byte_size ??
+                (durableThisSync ? result.byte_size : null));
+        const entry = {
+            file_hash_sha256: result.content_hash_sha256,
+            file_mtime_ms: result.session_file_mtime_ms,
+            byte_size: result.byte_size,
+            // Durable byte offset reflects how many bytes are durable remotely (the
+            // last uploaded size), not the current file size.
+            byte_offset: uploadedByteSize ?? 0,
+            state: result.state,
+            reason: result.reason,
+            worktree_fingerprint: result.worktree?.worktree_fingerprint ?? null,
+            uploaded_object_key: uploadedObjectKey,
+            uploaded_at: uploadedAt,
+            uploaded_byte_size: uploadedByteSize,
+            last_seen_at: options.now.toISOString(),
+        };
+        recordSessionObservation(options.cursor, sessionId, entry);
+    }
+    return stale;
+}
+function shouldDampClaudeMain(result, cursor, now) {
+    const entry = cursor.sessions[result.claude_session_id];
+    if (!entry ||
+        !entry.uploaded_object_key ||
+        !entry.uploaded_at ||
+        entry.uploaded_byte_size == null) {
+        return false;
+    }
+    const grew = result.byte_size > entry.uploaded_byte_size;
+    if (!grew)
+        return false; // unchanged content reuses via the object cursor
+    const growth = result.byte_size - entry.uploaded_byte_size;
+    const ageMs = now.getTime() - Date.parse(entry.uploaded_at);
+    return (growth <= CLAUDE_DAMP_GROWTH_BYTES &&
+        Number.isFinite(ageMs) &&
+        ageMs <= CLAUDE_DAMP_MAX_AGE_MS);
+}
+function buildAgentSessionSummary(options) {
+    const sidecarOutcomes = options.outcomes.flatMap((outcome) => outcome.sync.raw_evidence_outcomes.filter((upload) => upload.kind === "claude_jsonl_sidecar"));
+    const attributedClaude = options.claudeAttribution.results.filter((result) => result.state === "attributed");
+    const sidecarsCollected = attributedClaude.reduce((total, result) => total +
+        result.sidecar_files.filter((sidecar) => !sidecar.skipped_reason).length, 0);
+    const sidecarsSkipped = options.claudeAttribution.results.reduce((total, result) => total +
+        result.sidecar_files.filter((sidecar) => sidecar.skipped_reason).length, 0);
+    const codex = {
+        scanned: options.codexAttribution.scanned_file_count,
+        attributed: options.codexAttribution.counts.attributed,
+        ambiguous: options.codexAttribution.counts.ambiguous,
+        unattributed: options.codexAttribution.counts.unattributed,
+        skipped: options.codexAttribution.counts.skipped,
+        stale: options.codexStaleCount,
+    };
+    const claude = {
+        scanned: options.claudeAttribution.scanned_session_count,
+        attributed: options.claudeAttribution.counts.attributed,
+        ambiguous: options.claudeAttribution.counts.ambiguous,
+        unattributed: options.claudeAttribution.counts.unattributed,
+        skipped: options.claudeAttribution.counts.skipped,
+        stale: options.claudeStaleCount,
+        sidecars_collected: sidecarsCollected,
+        sidecars_uploaded: sidecarOutcomes.filter((upload) => upload.upload_state === "uploaded" ||
+            upload.upload_state === "reused_existing").length,
+        sidecars_skipped: sidecarsSkipped,
+        sidecars_capped: options.claudeAttribution.counts.sidecars_capped,
+        sidecars_failed: sidecarOutcomes.filter((upload) => upload.upload_state === "upload_failed").length,
+        mains_oversized: options.claudeAttribution.counts.mains_oversized,
+        oversized_lines_skipped: options.claudeAttribution.counts.oversized_lines_skipped,
+        project_dirs_skipped: options.claudeAttribution.project_dirs_skipped,
+        sessions_schema_drift: options.claudeAttribution.counts.sessions_schema_drift,
+        growth_damped: options.growthDamped,
+        first_run_backfill: options.firstRunBackfill,
+    };
+    return {
+        scanned: codex.scanned,
+        attributed: codex.attributed,
+        ambiguous: codex.ambiguous,
+        unattributed: codex.unattributed,
+        skipped: codex.skipped,
+        stale: codex.stale,
+        report_posted: options.report.posted,
+        report_reason: options.report.reason,
+        codex,
+        claude,
+        files_deferred_byte_budget: options.outcomes.reduce((total, outcome) => total + outcome.sync.raw_evidence_deferred_byte_budget, 0),
+        files_deferred_object_budget: options.outcomes.reduce((total, outcome) => total + outcome.sync.raw_evidence_deferred_object_budget, 0),
+    };
+}
+function emptyClaudeScan() {
+    return {
+        results: [],
+        scanned_session_count: 0,
+        project_dirs_skipped: 0,
+        counts: {
+            attributed: 0,
+            ambiguous: 0,
+            unattributed: 0,
+            skipped: 0,
+            mains_oversized: 0,
+            oversized_lines_skipped: 0,
+            sessions_schema_drift: 0,
+            sidecars_capped: 0,
+        },
+    };
+}
+async function isClaudeCollectionEnabled(paths) {
+    const config = await readLocalCollectorConfig(paths).catch(() => null);
+    return config?.collect_claude_jsonl !== false;
+}
+async function fileExists(filePath) {
+    const { stat } = await import("node:fs/promises");
+    return stat(filePath).then(() => true, () => false);
+}
 function shortSha(value) {
     return value ? value.slice(0, 12) : "unknown";
 }
-function codexSummaryLine(summary) {
-    return `Codex sessions: attributed ${summary.attributed}, ambiguous ${summary.ambiguous}, unattributed ${summary.unattributed}, skipped ${summary.skipped}, stale ${summary.stale}`;
+function sourceFunnelLine(label, counts) {
+    return `${label} sessions: attributed ${counts.attributed}, ambiguous ${counts.ambiguous}, unattributed ${counts.unattributed}, skipped ${counts.skipped}, stale ${counts.stale}`;
 }
 function attributionReportLine(summary) {
     return summary.report_posted
         ? "Attribution report: recorded"
         : `Attribution report: skipped (${summary.report_reason})`;
 }
+/**
+ * One funnel line per source, an anomaly diagnostics line only when something
+ * is nonzero (clean syncs stay one line per source), and the report line.
+ * Counts only — project-dir slugs encode full local paths and never print
+ * (B.4 §5).
+ */
+function writeAgentSessionSummary(io, summary) {
+    writeLine(io.stdout, sourceFunnelLine("Codex", summary.codex));
+    writeLine(io.stdout, sourceFunnelLine("Claude", summary.claude));
+    const claudeDiagnostics = claudeDiagnosticsLine(summary);
+    if (claudeDiagnostics)
+        writeLine(io.stdout, claudeDiagnostics);
+    writeLine(io.stdout, attributionReportLine(summary));
+}
+function claudeDiagnosticsLine(summary) {
+    // Anomaly-only (D34): sidecars_collected/uploaded are normal-operation
+    // counters and must NOT trigger this line, or a healthy orchestrated sync
+    // prints it 48×/day in launchd logs. Clean syncs stay one line per source.
+    const claude = summary.claude;
+    const parts = [];
+    if (claude.sidecars_skipped)
+        parts.push(`sidecars_skipped ${claude.sidecars_skipped}`);
+    if (claude.sidecars_capped)
+        parts.push(`sidecars_capped ${claude.sidecars_capped}`);
+    if (claude.sidecars_failed)
+        parts.push(`sidecars_failed ${claude.sidecars_failed}`);
+    if (claude.mains_oversized)
+        parts.push(`mains_oversized ${claude.mains_oversized}`);
+    if (claude.oversized_lines_skipped)
+        parts.push(`oversized_lines_skipped ${claude.oversized_lines_skipped}`);
+    if (claude.project_dirs_skipped)
+        parts.push(`project_dirs_skipped ${claude.project_dirs_skipped}`);
+    if (claude.sessions_schema_drift)
+        parts.push(`schema_drift ${claude.sessions_schema_drift}`);
+    if (claude.growth_damped)
+        parts.push(`growth_damped ${claude.growth_damped}`);
+    if (claude.first_run_backfill)
+        parts.push("first_run_backfill");
+    if (summary.files_deferred_byte_budget)
+        parts.push(`deferred_byte_budget ${summary.files_deferred_byte_budget}`);
+    if (summary.files_deferred_object_budget)
+        parts.push(`deferred_object_budget ${summary.files_deferred_object_budget}`);
+    return parts.length > 0 ? `Claude diagnostics: ${parts.join(", ")}` : null;
+}
 function rawEvidenceSyncLine(sync) {
     const failures = sync.raw_evidence_failure_reasons.length > 0
         ? ` failures: ${sync.raw_evidence_failure_reasons.join(",")}`
@@ -865,7 +1242,7 @@ async function runMultiRepoOnboard(command, io, worktrees) {
         worktrees,
         fetchImpl: io.fetch,
     });
-    const results = run.outcomes.map((outcome) => worktreeSyncRow(outcome, run.attribution));
+    const results = run.outcomes.map((outcome) => worktreeSyncRow(outcome, run));
     if (!command.json) {
         for (const [index, outcome] of run.outcomes.entries()) {
             const row = results[index];
@@ -876,8 +1253,7 @@ async function runMultiRepoOnboard(command, io, worktrees) {
         }
         writeLine(io.stdout, "4/5 Parent worktree sync complete.");
         writeLine(io.stdout, `Uploaded: ${results.filter((row) => row["upload_status"] === "uploaded").length}/${results.length}`);
-        writeLine(io.stdout, codexSummaryLine(run.summary));
-        writeLine(io.stdout, attributionReportLine(run.summary));
+        writeAgentSessionSummary(io, run.summary);
         writeLine(io.stdout, "5/5 Status ready.");
         writeLine(run.ok ? io.stdout : io.stderr, run.ok
             ? "PASS: Cockpit collector is ready for harvest."
@@ -886,10 +1262,13 @@ async function runMultiRepoOnboard(command, io, worktrees) {
     }
     return { ok: run.ok, results, codex_sessions: run.summary };
 }
-function worktreeSyncRow(outcome, attribution) {
+function worktreeSyncRow(outcome, run) {
     const { worktree, context, sync } = outcome;
-    const attributedSessionCount = attribution.results.filter((result) => result.state === "attributed" &&
-        result.worktree?.worktree_fingerprint === worktree.worktree_fingerprint).length;
+    const matchesWorktree = (result) => result.state === "attributed" &&
+        result.worktree?.worktree_fingerprint === worktree.worktree_fingerprint;
+    const codexSessionCount = run.codexAttribution.results.filter(matchesWorktree).length;
+    const claudeSessionCount = run.claudeAttribution.results.filter(matchesWorktree).length;
+    const attributedSessionCount = codexSessionCount + claudeSessionCount;
     return {
         repo_label: context?.repo_label ?? worktree.repo_label,
         repo_fingerprint: context?.repo_fingerprint ?? worktree.repo_fingerprint,
@@ -906,6 +1285,8 @@ function worktreeSyncRow(outcome, attribution) {
         raw_evidence_failed_count: sync.raw_evidence_failed_count,
         raw_evidence_failure_reasons: sync.raw_evidence_failure_reasons,
         attributed_session_count: attributedSessionCount,
+        codex_session_count: codexSessionCount,
+        claude_session_count: claudeSessionCount,
         cursor_tracked_object_count: sync.cursor_tracked_object_count,
         failure_reason: sync.status === "spooled" ? sync.failure_reason : null,
     };
@@ -1042,6 +1423,26 @@ async function runStart(command, io) {
     return 0;
 }
 async function runSync(command, io) {
+    // Single-flight: a launchd timer and a manual sync must not interleave the
+    // cursor read-modify-write. A blocked invocation exits cleanly (B.4 §7).
+    const lock = await acquireSyncLock(getCollectorRuntimePaths(command.homeDir));
+    if (!lock.acquired) {
+        if (command.json) {
+            writeLine(io.stdout, JSON.stringify({ status: "sync_already_running", held_since: lock.held_since }, null, 2));
+        }
+        else {
+            writeLine(io.stdout, "Cockpit sync already running; skipping this run.");
+        }
+        return 0;
+    }
+    try {
+        return await runSyncLocked(command, io);
+    }
+    finally {
+        await lock.handle.release();
+    }
+}
+async function runSyncLocked(command, io) {
     const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos }, io);
     const run = await runAttributedWorktreeSync({
         homeDir: command.homeDir,
@@ -1051,7 +1452,7 @@ async function runSync(command, io) {
         fetchImpl: io.fetch,
     });
     if (worktrees.length > 1) {
-        const rows = run.outcomes.map((outcome) => worktreeSyncRow(outcome, run.attribution));
+        const rows = run.outcomes.map((outcome) => worktreeSyncRow(outcome, run));
         if (command.json) {
             writeLine(io.stdout, JSON.stringify({
                 mode: "multi_repo",
@@ -1069,8 +1470,7 @@ async function runSync(command, io) {
             const failureSuffix = sync.status === "spooled" ? ` reason:${sync.failure_reason}` : "";
             writeLine(uploaded ? io.stdout : io.stderr, `- ${worktree.repo_label}/${worktree.worktree_label} (${worktree.branch}) head:${shortSha(sync.head_sha ?? worktree.head_sha)} ${sync.status} objects:${sync.raw_evidence_uploaded_object_count} chunks:${sync.raw_evidence_uploaded_chunk_count} reused:${sync.raw_evidence_reused_count} failed:${sync.raw_evidence_failed_count} cursor:${sync.cursor_tracked_object_count}${failureSuffix}`);
         }
-        writeLine(io.stdout, codexSummaryLine(run.summary));
-        writeLine(io.stdout, attributionReportLine(run.summary));
+        writeAgentSessionSummary(io, run.summary);
         return run.ok ? 0 : 1;
     }
     const result = run.outcomes[0]?.sync;
@@ -1090,8 +1490,7 @@ async function runSync(command, io) {
         writeLine(io.stdout, `Risk flags: ${result.risk_flag_count}`);
         writeLine(io.stdout, `Raw evidence files: ${result.raw_evidence_file_count}`);
         writeLine(io.stdout, rawEvidenceSyncLine(result));
-        writeLine(io.stdout, codexSummaryLine(run.summary));
-        writeLine(io.stdout, attributionReportLine(run.summary));
+        writeAgentSessionSummary(io, run.summary);
         writeLine(io.stdout, cursorStatusLine(result));
         return 0;
     }
@@ -1145,6 +1544,100 @@ async function runStatus(command, io) {
 function displayTicketId(ticketId) {
     return ticketId ?? "general ambient";
 }
+/**
+ * Read-only diagnostic: re-runs attribution (no upload, no cursor writes) and
+ * prints why each session is or is not collected. Per-session reasons otherwise
+ * live only in a service-role table with no UI, so this is the operator's local
+ * answer to "why is session X missing?" (B.4 §6). Counts and labels only — the
+ * project-dir slug encodes a local path and is never printed.
+ */
+async function runSessions(command, io) {
+    const now = new Date();
+    const homeDir = command.homeDir ?? os.homedir();
+    const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos }, io);
+    const wantCodex = command.source !== "claude";
+    const wantClaude = command.source !== "codex";
+    const codex = wantCodex
+        ? await scanAndAttributeCodexSessions({
+            sessionsDir: path.join(homeDir, ".codex", "sessions"),
+            worktrees,
+            now,
+        })
+        : null;
+    const claude = wantClaude
+        ? await scanAndAttributeClaudeSessions({
+            projectsDir: path.join(homeDir, ".claude", "projects"),
+            worktrees,
+            now,
+        })
+        : null;
+    // Safe output contract (B.4 §6): id, state, reason, scores, signals, sidecar
+    // skip reasons, plus the repo_label basename. Branch is intentionally omitted
+    // — branch names can carry operator-authored task/customer text.
+    const codexRows = (codex?.results ?? []).map((result) => ({
+        source: "codex",
+        session_id: result.codex_session_id,
+        state: result.state,
+        reason: result.reason,
+        attribution_score: result.attribution_score,
+        path_score: result.path_score,
+        signals: result.signals,
+        repo_label: result.worktree?.repo_label ?? null,
+    }));
+    const claudeRows = (claude?.results ?? []).map((result) => ({
+        source: "claude_code",
+        session_id: result.claude_session_id,
+        state: result.state,
+        reason: result.reason,
+        attribution_score: result.attribution_score,
+        path_score: result.path_score,
+        signals: result.signals,
+        repo_label: result.worktree?.repo_label ?? null,
+        main_file_oversized: result.main_file_oversized,
+        sidecar_skips: result.sidecar_files
+            .filter((sidecar) => sidecar.skipped_reason)
+            .map((sidecar) => ({
+            file_name: sidecar.file_name,
+            reason: sidecar.skipped_reason,
+        })),
+    }));
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({
+            ...(codex
+                ? { codex: { counts: codex.counts, sessions: codexRows } }
+                : {}),
+            ...(claude
+                ? {
+                    claude: {
+                        counts: claude.counts,
+                        project_dirs_skipped: claude.project_dirs_skipped,
+                        sessions: claudeRows,
+                    },
+                }
+                : {}),
+        }, null, 2));
+        return 0;
+    }
+    writeLine(io.stdout, "Cockpit sessions (read-only attribution)");
+    for (const row of codexRows) {
+        writeLine(io.stdout, sessionRowLine(row));
+    }
+    for (const row of claudeRows) {
+        writeLine(io.stdout, sessionRowLine(row));
+        for (const sidecar of row.sidecar_skips) {
+            writeLine(io.stdout, `    sidecar ${sidecar.file_name}: ${sidecar.reason}`);
+        }
+    }
+    if (codexRows.length === 0 && claudeRows.length === 0) {
+        writeLine(io.stdout, "No sessions observed in the scan window.");
+    }
+    return 0;
+}
+function sessionRowLine(row) {
+    const repo = row.repo_label ? ` repo:${row.repo_label}` : "";
+    const signals = row.signals.length > 0 ? ` signals:${row.signals.join("|")}` : "";
+    return `- [${row.source}] ${row.session_id} ${row.state} (${row.reason}) score:${row.attribution_score} path:${row.path_score}${repo}${signals}`;
+}
 async function runServe(command, io) {
     const server = createCollectorServer(command);
     await new Promise((resolve) => {