@bli-cockpit/cli 0.1.2 → 0.1.5

package/dist/commands/local.js

@@ -1,6 +1,11 @@
+import os from "node:os";
+import path from "node:path";
 import { createCollectorServer } from "../server.js";
 import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, inspectLocalCollectorStatus, installLocalCollector, logoutLocalCollector, pairLocalCollector, readLocalCollectorSessionFile, readLocalSessionReference, startLocalWorkContext, } from "../local-state.js";
-import { syncLocalAmbientEnvelope } from "../upload.js";
+import { postCodexSessionReport, syncLocalAmbientEnvelope, } from "../upload.js";
+import { scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
+import { countStaleSessions, readRawEvidenceCursor, recordSessionObservation, writeRawEvidenceCursor, } from "../cursors/raw-evidence-cursor.js";
+import { discoverGitWorktrees, } from "../repo-identity.js";
 export const rootCommandNames = new Set([
     "onboard",
     "install",
@@ -56,7 +61,7 @@ export function localCommandHelp(command) {
     if (command)
         return localSubcommandHelp(command);
     return [
-        "  cockpit onboard [--ticket <id>] [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--repo <path>] [--json]",
+        "  cockpit onboard [--ticket <id>] [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--repo <path>] [--branch <name>] [--json]",
         "  cockpit install [--dashboard-url <url>] [--repo <path>] [--json]",
         "  cockpit login [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--json]",
         "  cockpit pair [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--json]",
@@ -72,9 +77,10 @@ function localSubcommandHelp(command) {
         [
             "onboard",
             [
-                "Usage: cockpit onboard [--ticket <id>] [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--repo <path>] [--json]",
+                "Usage: cockpit onboard [--ticket <id>] [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--repo <path>] [--branch <name>] [--json]",
                 "",
-                "Installs, pairs, starts a work context, syncs once, and prints readiness proof.",
+                "Installs, pairs, starts work context(s), syncs once, and prints readiness proof.",
+                "If --repo is a parent folder, scans child git repos/worktrees and rolls them up by repo.",
                 "Use --email on shared or reused machines; mismatched existing sessions are re-paired.",
             ],
         ],
@@ -108,7 +114,8 @@ function localSubcommandHelp(command) {
             [
                 "Usage: cockpit start [--ticket <id>] [--repo <path>] [--branch <name>] [--json]",
                 "",
-                "Starts local ambient capture. Add --ticket only when the work already has a visible ticket.",
+                "Starts local ambient capture. Parent folders start each child git worktree.",
+                "Add --ticket only when the work already has a visible ticket.",
             ],
         ],
         [
@@ -116,7 +123,10 @@ function localSubcommandHelp(command) {
             [
                 "Usage: cockpit sync [--repo <path>] [--dashboard-url <url>] [--json]",
                 "",
-                "Uploads the latest local ambient envelope or spools a safe retry if blocked.",
+                "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.",
             ],
         ],
         [
@@ -455,6 +465,19 @@ async function runOnboard(command, io) {
                 writeLine(io.stdout, `Device: ${pair.session.device_name ?? pair.session.device_id ?? "unknown"}`);
             }
         }
+        const worktrees = await discoverCommandWorktrees(command.repoRoot);
+        if (worktrees.length > 1) {
+            const multi = await runMultiRepoOnboard(command, io, worktrees);
+            if (command.json) {
+                writeLine(io.stdout, JSON.stringify({
+                    ...onboardResult(multi.ok ? "pass" : "blocked", command, install, pair, null, null),
+                    mode: "multi_repo",
+                    repos: multi.results,
+                    codex_sessions: multi.codex_sessions,
+                }, null, 2));
+            }
+            return multi.ok ? 0 : 1;
+        }
         const context = await startLocalWorkContext({
             homeDir: command.homeDir,
             repoRoot: command.repoRoot,
@@ -468,12 +491,17 @@ async function runOnboard(command, io) {
             writeLine(io.stdout, `Ticket: ${context.active_ticket_id ?? "general ambient"}`);
             writeLine(io.stdout, `Context: ${context.work_context_id}`);
         }
-        sync = await syncLocalAmbientEnvelope({
+        const run = await runAttributedWorktreeSync({
             homeDir: command.homeDir,
-            repoRoot: command.repoRoot,
             dashboardUrl: command.dashboardUrl,
-            fetch: io.fetch,
+            startContexts: false,
+            worktrees,
+            fetchImpl: io.fetch,
         });
+        sync = run.outcomes[0]?.sync ?? null;
+        if (!sync) {
+            throw new Error("Onboard sync produced no result for the repo worktree.");
+        }
         status = await inspectLocalCollectorStatus({
             homeDir: command.homeDir,
             repoRoot: command.repoRoot,
@@ -481,7 +509,10 @@ async function runOnboard(command, io) {
         });
         if (sync.status !== "uploaded") {
             if (command.json) {
-                writeLine(io.stdout, JSON.stringify(onboardResult("blocked", command, install, pair, sync, status), null, 2));
+                writeLine(io.stdout, JSON.stringify({
+                    ...onboardResult("blocked", command, install, pair, sync, status),
+                    codex_sessions: run.summary,
+                }, null, 2));
             }
             else {
                 writeLine(io.stderr, "BLOCKED: ambient upload failed; safe retry metadata was spooled.");
@@ -491,7 +522,10 @@ async function runOnboard(command, io) {
             return 1;
         }
         if (command.json) {
-            writeLine(io.stdout, JSON.stringify(onboardResult("pass", command, install, pair, sync, status), null, 2));
+            writeLine(io.stdout, JSON.stringify({
+                ...onboardResult("pass", command, install, pair, sync, status),
+                codex_sessions: run.summary,
+            }, null, 2));
             return 0;
         }
         writeLine(io.stdout, "4/5 Ambient metadata uploaded.");
@@ -500,6 +534,9 @@ async function runOnboard(command, io) {
         writeLine(io.stdout, `Sources: ${sync.source_scan_count}`);
         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));
         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.");
@@ -560,6 +597,269 @@ async function readOnboardSessionReuseCandidate(homeDir) {
 function normalizeUrlForComparison(value) {
     return value ? normalizeUrl(value) : null;
 }
+/**
+ * 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.
+ */
+async function runAttributedWorktreeSync(options) {
+    const now = new Date();
+    const homeDir = options.homeDir ?? os.homedir();
+    const attribution = await scanAndAttributeCodexSessions({
+        sessionsDir: path.join(homeDir, ".codex", "sessions"),
+        worktrees: options.worktrees,
+        now,
+    });
+    const outcomes = [];
+    let ok = true;
+    for (const worktree of options.worktrees) {
+        let context = null;
+        if (options.startContexts) {
+            context = await startLocalWorkContext({
+                homeDir: options.homeDir,
+                repoRoot: worktree.repo_root,
+                branch: options.branch,
+                activeTicketId: options.activeTicketId,
+                operatorId: options.operatorId,
+                sessionId: options.sessionId,
+            });
+        }
+        const sync = await syncLocalAmbientEnvelope({
+            homeDir: options.homeDir,
+            repoRoot: worktree.repo_root,
+            dashboardUrl: options.dashboardUrl,
+            codexSessionFiles: attribution.results
+                .filter((result) => result.state === "attributed" &&
+                result.worktree?.worktree_fingerprint ===
+                    worktree.worktree_fingerprint)
+                .map((result) => ({
+                local_path: result.file_path,
+                codex_session_id: result.codex_session_id,
+            })),
+            fetch: options.fetchImpl,
+        });
+        ok = ok && sync.status === "uploaded";
+        outcomes.push({ worktree, context, sync });
+    }
+    const sessions = buildCodexSessionReport(attribution.results, outcomes, now);
+    // The sessions cursor is an optimization; a broken local state dir must not
+    // turn already-completed syncs into a CLI crash.
+    let staleSessionCount = 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);
+    }
+    catch {
+        // Best-effort: stale counts read 0 and observations re-record next sync.
+    }
+    const firstUploaded = outcomes.find((outcome) => outcome.sync.status === "uploaded");
+    const report = firstUploaded
+        ? await postCodexSessionReport({
+            homeDir: options.homeDir,
+            repoRoot: firstUploaded.worktree.repo_root,
+            dashboardUrl: options.dashboardUrl,
+            sessions,
+            fetch: options.fetchImpl,
+            now,
+        })
+        : {
+            posted: false,
+            reason: sessions.length === 0 ? "no_sessions_observed" : "no_successful_sync",
+        };
+    return {
+        ok,
+        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,
+        },
+    };
+}
+const ATTRIBUTION_STATE_RANK = {
+    attributed: 3,
+    ambiguous: 2,
+    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);
+        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);
+        }
+    }
+    const dedupedResults = [...bestBySessionId.values()];
+    const uploadBySessionId = new Map();
+    for (const outcome of 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);
+            }
+        }
+    }
+    return dedupedResults.map((result) => {
+        const upload = uploadBySessionId.get(result.codex_session_id);
+        return {
+            codex_session_id: result.codex_session_id,
+            observed_at: now.toISOString(),
+            attribution_state: result.state,
+            attribution_reason: result.reason,
+            attribution_score: result.attribution_score,
+            path_score: result.path_score,
+            signals: result.signals,
+            ...(result.content_hash_sha256
+                ? { session_file_hash_sha256: result.content_hash_sha256 }
+                : {}),
+            session_file_byte_size: result.byte_size,
+            session_file_mtime: result.session_file_mtime,
+            ...(result.worktree
+                ? {
+                    repo_fingerprint: result.worktree.repo_fingerprint,
+                    worktree_fingerprint: result.worktree.worktree_fingerprint,
+                    repo_label: result.worktree.repo_label,
+                    branch: result.worktree.branch,
+                }
+                : {}),
+            ...(result.cwd_basename ? { cwd_basename: result.cwd_basename } : {}),
+            ...(result.cwd_hash ? { cwd_hash: result.cwd_hash } : {}),
+            ...(upload
+                ? {
+                    raw_evidence_pointer_id: upload.raw_evidence_pointer_id,
+                    upload_state: upload.upload_state,
+                }
+                : result.state === "attributed"
+                    ? { upload_state: "not_uploaded" }
+                    : {}),
+        };
+    });
+}
+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 attributionReportLine(summary) {
+    return summary.report_posted
+        ? "Attribution report: recorded"
+        : `Attribution report: skipped (${summary.report_reason})`;
+}
+function rawEvidenceSyncLine(sync) {
+    const failures = sync.raw_evidence_failure_reasons.length > 0
+        ? ` failures: ${sync.raw_evidence_failure_reasons.join(",")}`
+        : "";
+    return `Raw evidence: uploaded ${sync.raw_evidence_uploaded_object_count} object(s) in ${sync.raw_evidence_uploaded_chunk_count} chunk(s), reused ${sync.raw_evidence_reused_count}, failed ${sync.raw_evidence_failed_count}${failures}`;
+}
+function cursorStatusLine(sync) {
+    return `Cursor: ${sync.cursor_tracked_object_count} durable object(s) tracked`;
+}
+async function discoverCommandWorktrees(repoRoot) {
+    const worktrees = await discoverGitWorktrees(repoRoot ?? process.cwd());
+    if (worktrees.length === 0) {
+        throw new Error("No git repos found. Run from a git repo, or from a parent folder containing git repos.");
+    }
+    return worktrees;
+}
+async function runMultiRepoOnboard(command, io, worktrees) {
+    if (!command.json) {
+        writeLine(io.stdout, `3/5 Parent folder mode: discovered ${worktrees.length} git worktree(s).`);
+    }
+    const run = await runAttributedWorktreeSync({
+        homeDir: command.homeDir,
+        dashboardUrl: command.dashboardUrl,
+        branch: command.branch,
+        activeTicketId: command.activeTicketId,
+        startContexts: true,
+        worktrees,
+        fetchImpl: io.fetch,
+    });
+    const results = run.outcomes.map((outcome) => worktreeSyncRow(outcome, run.attribution));
+    if (!command.json) {
+        for (const [index, outcome] of run.outcomes.entries()) {
+            const row = results[index];
+            if (!row)
+                continue;
+            const uploaded = outcome.sync.status === "uploaded";
+            writeLine(uploaded ? io.stdout : io.stderr, `${uploaded ? "PASS" : "BLOCKED"} ${row["repo_label"]}/${row["worktree_label"]} (${row["branch"]}) head:${shortSha(outcome.sync.head_sha ?? outcome.worktree.head_sha)} ${outcome.sync.status} objects:${outcome.sync.raw_evidence_uploaded_object_count} chunks:${outcome.sync.raw_evidence_uploaded_chunk_count} reused:${outcome.sync.raw_evidence_reused_count} failed:${outcome.sync.raw_evidence_failed_count} sessions:${row["attributed_session_count"]}${row["failure_reason"] ? ` reason:${row["failure_reason"]}` : ""}`);
+        }
+        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));
+        writeLine(io.stdout, "5/5 Status ready.");
+        writeLine(run.ok ? io.stdout : io.stderr, run.ok
+            ? "PASS: Cockpit collector is ready for harvest."
+            : "BLOCKED: One or more worktree uploads were spooled.");
+        writeLine(io.stdout, `Open: ${command.dashboardUrl}/my-work`);
+    }
+    return { ok: run.ok, results, codex_sessions: run.summary };
+}
+function worktreeSyncRow(outcome, attribution) {
+    const { worktree, context, sync } = outcome;
+    const attributedSessionCount = attribution.results.filter((result) => result.state === "attributed" &&
+        result.worktree?.worktree_fingerprint === worktree.worktree_fingerprint).length;
+    return {
+        repo_label: context?.repo_label ?? worktree.repo_label,
+        repo_fingerprint: context?.repo_fingerprint ?? worktree.repo_fingerprint,
+        worktree_label: context?.worktree_label ?? worktree.worktree_label,
+        worktree_fingerprint: context?.worktree_fingerprint ?? worktree.worktree_fingerprint,
+        branch: context?.branch ?? worktree.branch,
+        head_sha: sync.head_sha ?? worktree.head_sha,
+        work_context_id: context?.work_context_id ?? sync.work_context_id,
+        upload_status: sync.status,
+        raw_evidence_file_count: sync.raw_evidence_file_count,
+        raw_evidence_uploaded_object_count: sync.raw_evidence_uploaded_object_count,
+        raw_evidence_uploaded_chunk_count: sync.raw_evidence_uploaded_chunk_count,
+        raw_evidence_reused_count: sync.raw_evidence_reused_count,
+        raw_evidence_failed_count: sync.raw_evidence_failed_count,
+        raw_evidence_failure_reasons: sync.raw_evidence_failure_reasons,
+        attributed_session_count: attributedSessionCount,
+        cursor_tracked_object_count: sync.cursor_tracked_object_count,
+        failure_reason: sync.status === "spooled" ? sync.failure_reason : null,
+    };
+}
 async function runLogin(command, io) {
     const result = await pairLocalCollector({
         homeDir: command.homeDir,
@@ -636,7 +936,7 @@ function nextStepForOnboardBlocker(blocker) {
         case "ticket_binding":
             return "Run `cockpit start --ticket <id>` when actual ticket work begins, then run `cockpit sync`.";
         case "device_pairing":
-            return "Open the pairing URL, approve the exact code in Cockpit, then rerun `cockpit onboard`.";
+            return "Approve from Ambient -> Collector approvals, or paste the pairing code there, then rerun `cockpit onboard`.";
         case "network_or_ingest":
             return "Check dashboard URL/network, then run `cockpit sync --json` or rerun `cockpit onboard`.";
         case "install":
@@ -659,6 +959,26 @@ async function runLogout(command, io) {
     return 0;
 }
 async function runStart(command, io) {
+    const worktrees = await discoverCommandWorktrees(command.repoRoot);
+    if (worktrees.length > 1) {
+        const contexts = await Promise.all(worktrees.map((worktree) => startLocalWorkContext({
+            homeDir: command.homeDir,
+            repoRoot: worktree.repo_root,
+            branch: command.branch,
+            activeTicketId: command.activeTicketId,
+            operatorId: command.operatorId,
+            sessionId: command.sessionId,
+        })));
+        if (command.json) {
+            writeLine(io.stdout, JSON.stringify({ mode: "multi_repo", contexts }, null, 2));
+            return 0;
+        }
+        writeLine(io.stdout, `Cockpit parent work context active for ${contexts.length} worktree(s).`);
+        for (const context of contexts) {
+            writeLine(io.stdout, `- ${context.repo_label ?? context.repo}/${context.worktree_label ?? "worktree"} · ${context.branch} · ${context.work_context_id}`);
+        }
+        return 0;
+    }
     const context = await startLocalWorkContext(command);
     if (command.json) {
         writeLine(io.stdout, JSON.stringify(context, null, 2));
@@ -672,23 +992,57 @@ async function runStart(command, io) {
     return 0;
 }
 async function runSync(command, io) {
-    const result = await syncLocalAmbientEnvelope({
+    const worktrees = await discoverCommandWorktrees(command.repoRoot);
+    const run = await runAttributedWorktreeSync({
         homeDir: command.homeDir,
-        repoRoot: command.repoRoot,
         dashboardUrl: command.dashboardUrl,
-        fetch: io.fetch,
+        startContexts: false,
+        worktrees,
+        fetchImpl: io.fetch,
     });
+    if (worktrees.length > 1) {
+        const rows = run.outcomes.map((outcome) => worktreeSyncRow(outcome, run.attribution));
+        if (command.json) {
+            writeLine(io.stdout, JSON.stringify({
+                mode: "multi_repo",
+                status: run.ok ? "uploaded" : "spooled",
+                results: run.outcomes.map((outcome) => outcome.sync),
+                repos: rows,
+                codex_sessions: run.summary,
+            }, null, 2));
+            return run.ok ? 0 : 1;
+        }
+        writeLine(run.ok ? io.stdout : io.stderr, `Cockpit parent sync ${run.ok ? "uploaded" : "spooled"} ${run.outcomes.filter((outcome) => outcome.sync.status === "uploaded").length}/${run.outcomes.length} worktree(s).`);
+        for (const outcome of run.outcomes) {
+            const { worktree, sync } = outcome;
+            const uploaded = sync.status === "uploaded";
+            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));
+        return run.ok ? 0 : 1;
+    }
+    const result = run.outcomes[0]?.sync;
+    if (!result) {
+        throw new Error("Sync produced no result for the repo worktree.");
+    }
     if (command.json) {
-        writeLine(io.stdout, JSON.stringify(result, null, 2));
+        writeLine(io.stdout, JSON.stringify({ ...result, codex_sessions: run.summary }, null, 2));
         return result.status === "uploaded" ? 0 : 1;
     }
     if (result.status === "uploaded") {
         writeLine(io.stdout, "Cockpit ambient envelope uploaded.");
         writeLine(io.stdout, `Ticket: ${displayTicketId(result.ticket_id)}`);
         writeLine(io.stdout, `Context: ${result.work_context_id}`);
+        writeLine(io.stdout, `Head: ${shortSha(result.head_sha)}`);
         writeLine(io.stdout, `Facts: ${result.event_count}`);
         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));
+        writeLine(io.stdout, cursorStatusLine(result));
         return 0;
     }
     writeLine(io.stderr, "Cockpit ambient upload failed; safe retry metadata was spooled.");
@@ -698,6 +1052,25 @@ async function runSync(command, io) {
     return 1;
 }
 async function runStatus(command, io) {
+    const worktrees = await discoverCommandWorktrees(command.repoRoot);
+    if (worktrees.length > 1) {
+        const statuses = await Promise.all(worktrees.map(async (worktree) => ({
+            ...(await inspectLocalCollectorStatus({
+                homeDir: command.homeDir,
+                repoRoot: worktree.repo_root,
+            })),
+            head_sha: worktree.head_sha,
+        })));
+        if (command.json) {
+            writeLine(io.stdout, JSON.stringify({ mode: "multi_repo", statuses }, null, 2));
+            return 0;
+        }
+        writeLine(io.stdout, "Cockpit parent status");
+        for (const status of statuses) {
+            writeLine(io.stdout, `- ${status.repo_label ?? status.repo}/${status.worktree_label ?? "worktree"} · ${status.branch} · head:${shortSha(status.head_sha)} · ${status.upload_state}`);
+        }
+        return 0;
+    }
     const status = await inspectLocalCollectorStatus(command);
     if (command.json) {
         writeLine(io.stdout, JSON.stringify(status, null, 2));

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

@@ -0,0 +1,129 @@
+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;
+export function emptyRawEvidenceCursorState() {
+    return {
+        schema_version: "cockpit-raw-evidence-cursor.v1",
+        updated_at: null,
+        objects: {},
+        sessions: {},
+    };
+}
+export async function readRawEvidenceCursor(paths) {
+    try {
+        const raw = JSON.parse(await fs.readFile(rawEvidenceCursorPath(paths), "utf8"));
+        return parseCursorState(raw);
+    }
+    catch {
+        return emptyRawEvidenceCursorState();
+    }
+}
+export async function writeRawEvidenceCursor(paths, state) {
+    const filePath = rawEvidenceCursorPath(paths);
+    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 (process.platform !== "win32") {
+        await fs.chmod(filePath, 0o600).catch(() => undefined);
+    }
+}
+export function markObjectCommitted(state, contentHash, entry) {
+    state.objects[contentHash] = entry;
+}
+export function hasCommittedObject(state, contentHash) {
+    return Boolean(contentHash && state.objects[contentHash]);
+}
+export function recordSessionObservation(state, codexSessionId, entry) {
+    state.sessions[codexSessionId] = entry;
+}
+/**
+ * Sessions tracked by the cursor that no longer appear in the current scan
+ * window are stale: previously observed work that stopped producing evidence.
+ */
+export function countStaleSessions(state, seenSessionIds) {
+    return Object.keys(state.sessions).filter((id) => !seenSessionIds.has(id))
+        .length;
+}
+function pruneCursorState(state) {
+    return {
+        ...state,
+        objects: pruneNewest(state.objects, MAX_TRACKED_OBJECTS, (entry) => entry.committed_at),
+        sessions: pruneNewest(state.sessions, MAX_TRACKED_SESSIONS, (entry) => entry.last_seen_at),
+    };
+}
+function pruneNewest(record, max, sortKey) {
+    const entries = Object.entries(record);
+    if (entries.length <= max)
+        return record;
+    entries.sort((a, b) => sortKey(b[1]).localeCompare(sortKey(a[1])));
+    return Object.fromEntries(entries.slice(0, max));
+}
+function parseCursorState(value) {
+    if (!value || typeof value !== "object")
+        return emptyRawEvidenceCursorState();
+    const record = value;
+    return {
+        schema_version: "cockpit-raw-evidence-cursor.v1",
+        updated_at: optionalString(record["updated_at"]),
+        objects: parseRecord(record["objects"], parseObjectEntry),
+        sessions: parseRecord(record["sessions"], parseSessionEntry),
+    };
+}
+function parseRecord(value, parseEntry) {
+    if (!value || typeof value !== "object")
+        return {};
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+        const parsed = parseEntry(entry);
+        if (parsed)
+            out[key] = parsed;
+    }
+    return out;
+}
+function parseObjectEntry(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    const objectKey = optionalString(record["object_key"]);
+    const committedAt = optionalString(record["committed_at"]);
+    if (!objectKey || !committedAt)
+        return null;
+    return {
+        object_key: objectKey,
+        byte_size: optionalNumber(record["byte_size"]),
+        committed_at: committedAt,
+    };
+}
+function parseSessionEntry(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    const lastSeenAt = optionalString(record["last_seen_at"]);
+    const state = optionalString(record["state"]);
+    if (!lastSeenAt || !state)
+        return null;
+    return {
+        file_hash_sha256: optionalString(record["file_hash_sha256"]),
+        file_mtime_ms: optionalNumber(record["file_mtime_ms"]),
+        byte_size: optionalNumber(record["byte_size"]),
+        byte_offset: optionalNumber(record["byte_offset"]),
+        state,
+        reason: optionalString(record["reason"]) ?? "unknown",
+        worktree_fingerprint: optionalString(record["worktree_fingerprint"]),
+        uploaded_object_key: optionalString(record["uploaded_object_key"]),
+        last_seen_at: lastSeenAt,
+    };
+}
+function rawEvidenceCursorPath(paths) {
+    return path.join(paths.cursors_dir, CURSOR_FILENAME);
+}
+function optionalString(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function optionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}