@bli-cockpit/cli 0.1.3 → 0.1.6

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 { 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 { discoverGitWorktrees, } from "../repo-identity.js";
 export const rootCommandNames = new Set([
     "onboard",
     "install",
@@ -56,14 +61,14 @@ 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>] [--max-depth <n>] [--max-repos <n>] [--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]",
         "  cockpit logout",
-        "  cockpit start [--ticket <id>] [--repo <path>] [--branch <name>] [--json]",
-        "  cockpit sync [--repo <path>] [--dashboard-url <url>] [--json]",
-        "  cockpit status [--repo <path>] [--json]",
+        "  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 serve [--port <port>] [--repo <path>]",
     ].join("\n");
 }
@@ -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,13 @@ 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.",
+                "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.",
             ],
         ],
         [
@@ -181,6 +194,8 @@ function parseOnboardArgs(args) {
             "--json",
             "--poll-interval-ms",
             "--timeout-ms",
+            "--max-depth",
+            "--max-repos",
         ],
         valueFlags: [
             "--home",
@@ -192,6 +207,8 @@ function parseOnboardArgs(args) {
             "--branch",
             "--poll-interval-ms",
             "--timeout-ms",
+            "--max-depth",
+            "--max-repos",
         ],
     });
     assertNoPositionals(values.positionals, "onboard");
@@ -207,6 +224,8 @@ function parseOnboardArgs(args) {
         json: values.booleans.has("--json"),
         pollIntervalMs: optionalPositiveInteger(values.flags.get("--poll-interval-ms"), "--poll-interval-ms"),
         timeoutMs: optionalPositiveInteger(values.flags.get("--timeout-ms"), "--timeout-ms"),
+        maxDepth: optionalPositiveInteger(values.flags.get("--max-depth"), "--max-depth"),
+        maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
     };
 }
 function parseInstallArgs(args) {
@@ -284,6 +303,8 @@ function parseStartArgs(args) {
             "--operator-id",
             "--session-id",
             "--json",
+            "--max-depth",
+            "--max-repos",
         ],
         valueFlags: [
             "--home",
@@ -292,6 +313,8 @@ function parseStartArgs(args) {
             "--ticket",
             "--operator-id",
             "--session-id",
+            "--max-depth",
+            "--max-repos",
         ],
     });
     assertNoPositionals(values.positionals, "start");
@@ -304,12 +327,14 @@ function parseStartArgs(args) {
         operatorId: optionalNonEmpty(values.flags.get("--operator-id")),
         sessionId: optionalNonEmpty(values.flags.get("--session-id")),
         json: values.booleans.has("--json"),
+        maxDepth: optionalPositiveInteger(values.flags.get("--max-depth"), "--max-depth"),
+        maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
     };
 }
 function parseSyncArgs(args) {
     const values = parseNamedArgs(args, {
-        allowedFlags: ["--home", "--repo", "--dashboard-url", "--json"],
-        valueFlags: ["--home", "--repo", "--dashboard-url"],
+        allowedFlags: ["--home", "--repo", "--dashboard-url", "--json", "--max-depth", "--max-repos"],
+        valueFlags: ["--home", "--repo", "--dashboard-url", "--max-depth", "--max-repos"],
     });
     assertNoPositionals(values.positionals, "sync");
     return {
@@ -318,12 +343,14 @@ function parseSyncArgs(args) {
         repoRoot: optionalNonEmpty(values.flags.get("--repo")),
         dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
         json: values.booleans.has("--json"),
+        maxDepth: optionalPositiveInteger(values.flags.get("--max-depth"), "--max-depth"),
+        maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
     };
 }
 function parseStatusArgs(args) {
     const values = parseNamedArgs(args, {
-        allowedFlags: ["--home", "--repo", "--json"],
-        valueFlags: ["--home", "--repo"],
+        allowedFlags: ["--home", "--repo", "--json", "--max-depth", "--max-repos"],
+        valueFlags: ["--home", "--repo", "--max-depth", "--max-repos"],
     });
     assertNoPositionals(values.positionals, "status");
     return {
@@ -331,6 +358,8 @@ function parseStatusArgs(args) {
         homeDir: optionalNonEmpty(values.flags.get("--home")),
         repoRoot: optionalNonEmpty(values.flags.get("--repo")),
         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) {
@@ -455,6 +484,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, { maxDepth: command.maxDepth, maxRepos: command.maxRepos }, io);
+        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 +510,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 +528,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 +541,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 +553,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 +616,300 @@ 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 syncOptions = {
+            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,
+        };
+        let sync;
+        try {
+            sync = await syncLocalAmbientEnvelope(syncOptions);
+        }
+        catch (error) {
+            // A newly cloned repo has no work context yet. Capture is permissive
+            // and ticket binding comes later, so start general ambient capture for
+            // it instead of blocking every other repo's sync until someone runs
+            // `cockpit start` by hand.
+            if (error instanceof LocalUploadBlockedError &&
+                error.blocker === "missing_context") {
+                context = await startLocalWorkContext({
+                    homeDir: options.homeDir,
+                    repoRoot: worktree.repo_root,
+                    branch: options.branch,
+                });
+                sync = await syncLocalAmbientEnvelope(syncOptions);
+            }
+            else {
+                throw error;
+            }
+        }
+        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`;
+}
+const DEFAULT_DISCOVERY_MAX_DEPTH = 3;
+const DEFAULT_DISCOVERY_MAX_REPOS = 50;
+async function discoverCommandWorktrees(repoRoot, discovery = {}, io) {
+    const maxWorktrees = discovery.maxRepos ?? DEFAULT_DISCOVERY_MAX_REPOS;
+    const worktrees = await discoverGitWorktrees(repoRoot ?? process.cwd(), {
+        maxDepth: discovery.maxDepth ?? DEFAULT_DISCOVERY_MAX_DEPTH,
+        maxWorktrees,
+    });
+    if (worktrees.length === 0) {
+        throw new Error("No git repos found. Run from a git repo, or from a parent folder containing git repos.");
+    }
+    if (io && worktrees.length >= maxWorktrees) {
+        writeLine(io.stderr, `Warning: repo discovery hit the cap of ${maxWorktrees}; additional repos may be excluded. Raise --max-repos if this folder really holds more.`);
+    }
+    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,
@@ -659,6 +1009,26 @@ async function runLogout(command, io) {
     return 0;
 }
 async function runStart(command, io) {
+    const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos }, io);
+    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 +1042,57 @@ async function runStart(command, io) {
     return 0;
 }
 async function runSync(command, io) {
-    const result = await syncLocalAmbientEnvelope({
+    const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos }, io);
+    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 +1102,25 @@ async function runSync(command, io) {
     return 1;
 }
 async function runStatus(command, io) {
+    const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos }, io);
+    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));