@bli-cockpit/cli 0.2.5 → 0.2.7

package/README.md

@@ -4,7 +4,7 @@ Cockpit watches how you and your AI agents work so Edward can coach from evidenc
 
 ## 90-second speedrun
 
-Run these three commands on the Mac that should be collected:
+Run these three commands on the Mac or Windows PC that should be collected:
 
 ```bash
 $ npm install -g @bli-cockpit/cli@latest
@@ -12,7 +12,7 @@ added <packages> in <seconds>s
 ```
 
 ```bash
-$ cockpit onboard
+$ cockpit do-everything
 Cockpit harvest onboarding
 Dashboard: https://bli-cockpit-dashboard.vercel.app
 Ticket: general ambient
@@ -45,14 +45,22 @@ The OTP proves you own an approved BLI mailbox. The JWT is used once to register
 
 ## Every command, what it does, and why it's called that
 
-On a blank Mac, `npm i -g @bli-cockpit/cli && cockpit do-everything` is enough to sign in, choose roots, and converge the machine. `onboard` remains the named setup subset, and the rest exist for recovery and maintenance.
+On a blank Mac or Windows PC, `npm i -g @bli-cockpit/cli && cockpit do-everything` is enough to sign in, choose roots, and converge the machine. `onboard` remains the named setup subset, and the rest exist for recovery and maintenance.
+
+The core collection contract is the same on Apple Silicon macOS and native
+Windows: every eligible Codex and Claude session attributable to an approved
+root is collected, redacted before ingest, and either uploaded with a durable
+receipt or surfaced with an explicit ambiguity, skip, or retry reason. A green
+machine must not hide silently missing sessions. This support claim remains
+release-gated: the packed candidate must pass normal-user canaries on both host
+families before its exact version is promoted to npm `latest`.
 
 | Command | What it does | Why it exists / why this name |
 |---|---|---|
-| `cockpit onboard` | The everything-command: signs you in (email code), registers this Mac, starts capture, uploads once, installs the 15-min background sync, and prints proof you're live. | You are boarding the crew. Run it once per machine; rerunning is always safe. |
-| `cockpit do-everything` / `cockpit fix` | Converges a Mac from blank or already-onboarded state: latest CLI, signed-in device token, saved roots, autostart, historical backfill, raw-evidence GC, and fresh sync. Interactive first runs prompt for email OTP and collection roots; headless/`--json` runs explain and exit instead of blocking. `--dry-run` previews without writing. | Edward can post one line and every intern machine should end green. `fix` is the alias people guess. |
+| `cockpit onboard` | The named setup subset: signs you in (email code), registers this machine, starts capture, uploads once, completes all-history Codex and Claude backfill for saved approved roots, installs the 15-min background sync, and only then prints proof you're live. | You are boarding the crew. `do-everything` calls this flow when setup is missing; rerunning it directly is safe. Partial or failed backfill blocks readiness with an exact retry reason. |
+| `cockpit do-everything` / `cockpit fix` | Converges a Mac or Windows PC from blank or already-onboarded state: latest CLI, signed-in device token, saved roots, autostart, historical backfill, raw-evidence GC, and fresh sync. Interactive first runs prompt for email OTP and collection roots; headless/`--json` runs explain and exit instead of blocking. `--dry-run` previews without writing. | Edward can post one line and every intern machine should end green. `fix` is the alias people guess. |
 | `cockpit status` | Prints install / sign-in / capture / upload health in one screen. | The "is it working?" command. Run it whenever you're unsure. |
-| `cockpit backfill --all` | Uploads your HISTORICAL Codex + Claude sessions (from before Cockpit existed on this Mac). | One-time catch-up so your past work counts too. "Backfill" = fill in the back-catalog. |
+| `cockpit backfill --all` | Uploads your HISTORICAL Codex + Claude sessions (from before Cockpit existed on this machine). Discovery defaults to depth 3 and 50 repos; raise `--max-depth` or `--max-repos` when the returned retry command says a cap was reached. | One-time catch-up so your past work counts too. "Backfill" = fill in the back-catalog. |
 | `cockpit sync` | Captures and uploads once, right now. This is what the background agent runs every 15 min — you almost never type it yourself. | Named for what it does: synchronize local session files up to the dashboard. |
 | `cockpit analyze` | Runs a fresh sync, then queues batch analysis of your latest uploaded sessions. It returns immediately; status and results appear in My Work. | One command when you want newly finished work uploaded and judged now. |
 | `cockpit start --ticket <id>` | Tags your CURRENT work with a Linear ticket so sessions attribute to it. `--clear-ticket` returns to general capture. | "Start (working on) X." Agents usually run this for you per the agent rules. |
@@ -61,7 +69,7 @@ On a blank Mac, `npm i -g @bli-cockpit/cli && cockpit do-everything` is enough t
 | `cockpit update` / `cockpit upgrade` | Updates the CLI itself from npm, then reruns onboard. Two names, one command — aliases because half of people guess each. | Self-update; run when Edward announces a new version. |
 | `cockpit install` | Writes local config only (step 1 of onboard, standalone). | Plumbing; exists so onboard's pieces are individually runnable. You'll likely never type it. |
 | `cockpit sessions` | Read-only: lists your observed sessions and how each attributed. | Debugging "why isn't my session showing up?" without uploading anything. |
-| `cockpit autostart install\|uninstall\|status` | Manages the macOS launchd agent behind the 15-min background sync. | Direct control of the background piece when you need to stop/inspect it. |
+| `cockpit autostart install\|uninstall\|status` | Manages the macOS launchd agent or per-user Windows Task Scheduler task behind the 15-min background sync. | Direct control of the background piece when you need to stop/inspect it. |
 | `cockpit agent-rules install\|uninstall\|status` | Manages the Cockpit ticket-binding text block inside `~/.codex/AGENTS.md` / `~/.claude/CLAUDE.md`. | It's literally "the rules your agents read." Passive markdown — never an executable hook. |
 | `cockpit serve` | Runs a tiny local HTTP status server. | Niche: lets other tools ask the collector how it's doing. |
 | `cockpit logout`, `cockpit release`, `cockpit admin *` | `release` publishes the CLI (maintainer, repo-gated); `admin` (bootstrap/invite) is absent from the public build entirely. | Maintainer surface — interns never touch these. |
@@ -94,6 +102,10 @@ cockpit onboard --no-auth
 
 `cockpit update` installs the latest public CLI and reruns onboarding checks against saved roots. `cockpit upgrade` is the same command.
 
+`cockpit --version`, `cockpit -V`, and `cockpit version` print the installed
+public package version. Windows autostart details and verification steps are in
+[`docs/runbooks/cockpit-windows-task-scheduler-sync.md`](../../docs/runbooks/cockpit-windows-task-scheduler-sync.md).
+
 ## Analyze latest work
 
 ```bash

package/dist/adapters/attribution-core.js

@@ -1,4 +1,5 @@
 import crypto from "node:crypto";
+import { realpathSync } from "node:fs";
 import path from "node:path";
 import { normalizeGitOrigin, repoFingerprintFromLocalRoot, repoFingerprintFromOrigin, repoLabelFromOrigin, stableWorktreeFingerprint, } from "../repo-identity.js";
 /**
@@ -24,6 +25,12 @@ export const ATTRIBUTED_FALLBACK_MAX_SCORE = 0.39;
 export const SESSION_FILE_UUID_PATTERN = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
 export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
     const originLabel = options.originLabel ?? "origin_url_match";
+    const collectionRoots = collectionRootComparisonAliases(options.collectionRoots ?? []);
+    const recordedPaths = [...signals.cwds, ...signals.workspaceRoots];
+    const approvedRecordedPaths = recordedPathsWithinCollectionRoots(recordedPaths, collectionRoots);
+    const scopedWorktrees = worktreesWithinCollectionScope(worktrees, collectionRoots);
+    const cwdComparisonPaths = pathComparisonAliases(signals.cwds);
+    const workspaceRootComparisonPaths = pathComparisonAliases(signals.workspaceRoots);
     const hasAnySignal = signals.cwds.length > 0 ||
         signals.workspaceRoots.length > 0 ||
         signals.originUrls.length > 0 ||
@@ -38,9 +45,9 @@ export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
     // nested package that is itself a worktree). Crediting every containing root
     // leaves the session ambiguous forever. Instead, only the DEEPEST containing
     // root earns the path score, which is also the most specific (correct) match.
-    const cwdWinners = deepestContainers(signals.cwds, worktrees);
-    const workspaceRootWinners = deepestContainers(signals.workspaceRoots, worktrees);
-    const scored = worktrees.map((worktree) => {
+    const cwdWinners = deepestContainers(cwdComparisonPaths, scopedWorktrees);
+    const workspaceRootWinners = deepestContainers(workspaceRootComparisonPaths, scopedWorktrees);
+    const scored = scopedWorktrees.map((worktree) => {
         const matched = [];
         let score = 0;
         let pathScore = 0;
@@ -73,21 +80,23 @@ export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
     const best = scored[0];
     const secondBestScore = scored[1]?.score ?? 0;
     if (!best || best.score === 0) {
-        const recordedPaths = [...signals.cwds, ...signals.workspaceRoots];
-        if (repoPathAbsentFromDisk(recordedPaths, options.collectionRoots ?? [])) {
+        if (approvedRecordedPaths.length > 0) {
             const folderFallback = fallbackToFolderWorkspaceForContainerCwd({
                 signals,
-                worktrees,
+                worktrees: scopedWorktrees,
+                approvedRecordedPaths,
             });
             if (folderFallback)
                 return folderFallback;
             const transcriptFallback = fallbackToTranscriptOriginForDeletedRepo({
                 originLabel,
                 signals,
+                collectionRoots,
+                pathExists: options.pathExists,
             });
             if (transcriptFallback)
                 return transcriptFallback;
-            return skipped(terminalReasonForRecordedPaths(recordedPaths, options.pathExists));
+            return skipped(terminalReasonForRecordedPaths(approvedRecordedPaths, options.pathExists));
         }
         const reason = signals.cwds.length > 0 || signals.workspaceRoots.length > 0
             ? "cwd_outside_scanned_worktrees"
@@ -109,11 +118,16 @@ export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
         };
     }
     if (best.pathScore === 0) {
+        if (collectionRoots.length > 0 && approvedRecordedPaths.length === 0) {
+            return unattributed(recordedPaths.length > 0
+                ? "cwd_outside_scanned_worktrees"
+                : "no_matching_worktree_signals");
+        }
         const fallback = fallbackToKnownRepoPrimaryWorkContext({
             originLabel,
             scored,
             signals,
-            worktrees,
+            worktrees: scopedWorktrees,
         });
         if (fallback)
             return fallback;
@@ -157,10 +171,9 @@ function skipped(reason) {
  * root.
  */
 function fallbackToFolderWorkspaceForContainerCwd(options) {
-    const recordedPaths = [...options.signals.cwds, ...options.signals.workspaceRoots];
     let bestFolder = null;
-    for (const recordedPath of recordedPaths) {
-        const resolvedPath = path.resolve(recordedPath);
+    for (const recordedPath of pathComparisonAliases(options.approvedRecordedPaths)) {
+        const resolvedPath = resolveAttributionPath(recordedPath);
         const containedWorktrees = options.worktrees.filter((worktree) => isPathStrictlyWithin(worktree.repo_root, resolvedPath));
         if (containedWorktrees.length === 0)
             continue;
@@ -185,7 +198,7 @@ function fallbackToFolderWorkspaceForContainerCwd(options) {
             worktree: primary,
         };
     }
-    const repoLabel = path.basename(bestFolder.resolvedPath);
+    const repoLabel = basenameForAttributionPath(bestFolder.resolvedPath);
     return {
         state: "attributed_fallback",
         reason: "multi_repo_folder_workspace",
@@ -213,7 +226,7 @@ function fallbackToKnownRepoPrimaryWorkContext(options) {
         return null;
     const primaryByClone = originCandidates.filter((worktree) => worktree.worktree_is_primary);
     const cloneCandidates = primaryByClone.length > 0 ? primaryByClone : originCandidates;
-    const cloneRoots = new Set(cloneCandidates.map((worktree) => path.resolve(worktree.repo_root)));
+    const cloneRoots = new Set(cloneCandidates.map((worktree) => normalizedAttributionPathKey(worktree.repo_root)));
     if (cloneRoots.size > 1) {
         return {
             state: "ambiguous",
@@ -262,10 +275,26 @@ function fallbackToTranscriptOriginForDeletedRepo(options) {
         return null;
     if (origins.length > 1)
         return skipped("multiple_transcript_origins");
-    const recordedPath = options.signals.workspaceRoots[0] ?? options.signals.cwds[0] ?? null;
+    if (!options.pathExists)
+        return null;
+    // Prefer an explicitly recorded workspace root, but only after proving that
+    // exact selected path remains inside the operator-approved boundary. A
+    // different cwd being approved must never authorize an outside workspace
+    // root (or vice versa).
+    const recordedPath = [...options.signals.workspaceRoots, ...options.signals.cwds].find((value) => {
+        if (!options.collectionRoots.some((root) => isPathWithin(value, root))) {
+            return false;
+        }
+        try {
+            return !options.pathExists?.(value);
+        }
+        catch {
+            return false;
+        }
+    }) ?? null;
     if (!recordedPath)
         return null;
-    const resolvedPath = path.resolve(recordedPath);
+    const resolvedPath = resolveAttributionPath(recordedPath);
     const origin = origins[0] ?? "";
     return {
         state: "attributed_fallback",
@@ -281,7 +310,7 @@ function fallbackToTranscriptOriginForDeletedRepo(options) {
             repo_origin_url: origin,
             branch: options.signals.branches[0] ?? "unknown",
             head_sha: options.signals.headShas[0] ?? null,
-            worktree_label: path.basename(resolvedPath),
+            worktree_label: basenameForAttributionPath(resolvedPath),
             worktree_fingerprint: stableWorktreeFingerprint(resolvedPath),
             worktree_is_primary: false,
         },
@@ -318,7 +347,7 @@ function deepestContainers(signalValues, worktrees) {
         for (const worktree of worktrees) {
             if (!isPathWithin(value, worktree.repo_root))
                 continue;
-            const rootLength = path.resolve(worktree.repo_root).length;
+            const rootLength = normalizedAttributionPathKey(worktree.repo_root).length;
             if (rootLength > bestRootLength) {
                 best = worktree;
                 bestRootLength = rootLength;
@@ -330,30 +359,122 @@ function deepestContainers(signalValues, worktrees) {
     return winners;
 }
 export function isPathWithin(candidate, root) {
-    const normalizedCandidate = path.resolve(candidate);
-    const normalizedRoot = path.resolve(root);
-    return (normalizedCandidate === normalizedRoot ||
-        normalizedCandidate.startsWith(normalizedRoot + path.sep));
+    return pathContainment(candidate, root, false);
 }
 function isPathStrictlyWithin(candidate, root) {
-    const normalizedCandidate = path.resolve(candidate);
-    const normalizedRoot = path.resolve(root);
-    return (normalizedCandidate !== normalizedRoot &&
-        normalizedCandidate.startsWith(normalizedRoot + path.sep));
+    return pathContainment(candidate, root, true);
 }
-function repoPathAbsentFromDisk(paths, collectionRoots) {
+function recordedPathsWithinCollectionRoots(paths, collectionRoots) {
     if (paths.length === 0 || collectionRoots.length === 0)
-        return false;
-    const roots = collectionRoots.map((root) => path.resolve(root));
-    return paths.some((value) => roots.some((root) => isPathWithin(value, root)));
+        return [];
+    return paths.filter((value) => collectionRoots.some((root) => isPathWithin(value, root)));
+}
+function worktreesWithinCollectionScope(worktrees, collectionRoots) {
+    if (collectionRoots.length === 0)
+        return worktrees;
+    const directlyApproved = new Set(worktrees
+        .filter((worktree) => collectionRoots.some((root) => isPathWithin(worktree.repo_root, root)))
+        .map((worktree) => worktree.worktree_fingerprint));
+    const approvedRepoFingerprints = new Set(worktrees
+        .filter((worktree) => directlyApproved.has(worktree.worktree_fingerprint))
+        .map((worktree) => worktree.repo_fingerprint));
+    return worktrees.filter((worktree) => directlyApproved.has(worktree.worktree_fingerprint) ||
+        (isCodexManagedWorktreePath(worktree.repo_root) &&
+            approvedRepoFingerprints.has(worktree.repo_fingerprint)));
+}
+function isCodexManagedWorktreePath(value) {
+    const pathApi = attributionPathApi(value);
+    const windowsPath = isWindowsAbsolutePath(value);
+    const parts = pathApi.resolve(value).split(pathApi.sep).filter(Boolean);
+    return parts.some((part, index) => {
+        const codex = windowsPath ? part.toLowerCase() : part;
+        const nextPart = parts[index + 1] ?? "";
+        const worktrees = windowsPath ? nextPart.toLowerCase() : nextPart;
+        return codex === ".codex" && worktrees === "worktrees";
+    });
 }
 function sortWorktreesForFolderFallback(worktrees) {
     return [...worktrees].sort((a, b) => Number(b.worktree_is_primary) - Number(a.worktree_is_primary) ||
-        path.resolve(a.repo_root).localeCompare(path.resolve(b.repo_root)) ||
+        normalizedAttributionPathKey(a.repo_root).localeCompare(normalizedAttributionPathKey(b.repo_root)) ||
         a.worktree_fingerprint.localeCompare(b.worktree_fingerprint));
 }
 function pathDepth(value) {
-    return path.resolve(value).split(path.sep).filter(Boolean).length;
+    const pathApi = attributionPathApi(value);
+    return pathApi.resolve(value).split(pathApi.sep).filter(Boolean).length;
+}
+/**
+ * Transcript paths describe the host that produced the session, which may not
+ * be the host currently running tests or replaying evidence. Detect Windows
+ * drive/UNC paths from the values themselves so attribution keeps win32
+ * separator and case rules on macOS/Linux too.
+ */
+function pathContainment(candidate, root, strict) {
+    const candidateIsWindows = isWindowsAbsolutePath(candidate);
+    const rootIsWindows = isWindowsAbsolutePath(root);
+    if (candidateIsWindows !== rootIsWindows)
+        return false;
+    const pathApi = candidateIsWindows ? path.win32 : path.posix;
+    const normalizedCandidate = pathApi.resolve(candidate);
+    const normalizedRoot = pathApi.resolve(root);
+    return normalizedPathContainment(normalizedCandidate, normalizedRoot, pathApi, strict);
+}
+function normalizedPathContainment(candidate, root, pathApi, strict) {
+    const relative = pathApi.relative(root, candidate);
+    if (relative === "")
+        return !strict;
+    return (relative !== ".." &&
+        !relative.startsWith(`..${pathApi.sep}`) &&
+        !pathApi.isAbsolute(relative));
+}
+function collectionRootComparisonAliases(roots) {
+    return pathComparisonAliases(roots);
+}
+function pathComparisonAliases(values) {
+    const aliases = [];
+    const seen = new Set();
+    for (const value of values) {
+        for (const candidate of [
+            resolveAttributionPath(value),
+            canonicalExistingAttributionPath(value),
+        ]) {
+            if (!candidate)
+                continue;
+            const key = normalizedAttributionPathKey(candidate);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            aliases.push(candidate);
+        }
+    }
+    return aliases;
+}
+function canonicalExistingAttributionPath(value) {
+    const windowsPath = isWindowsAbsolutePath(value);
+    if (windowsPath !== (process.platform === "win32"))
+        return null;
+    try {
+        return attributionPathApi(value).resolve(realpathSync(value));
+    }
+    catch {
+        return null;
+    }
+}
+function attributionPathApi(value) {
+    return isWindowsAbsolutePath(value) ? path.win32 : path.posix;
+}
+function resolveAttributionPath(value) {
+    return attributionPathApi(value).resolve(value);
+}
+function basenameForAttributionPath(value) {
+    return attributionPathApi(value).basename(value);
+}
+function normalizedAttributionPathKey(value) {
+    const resolved = resolveAttributionPath(value);
+    return isWindowsAbsolutePath(value) ? resolved.toLowerCase() : resolved;
+}
+function isWindowsAbsolutePath(value) {
+    return (/^[A-Za-z]:[\\/]/.test(value) ||
+        /^[\\/]{2}[^\\/]+[\\/][^\\/]+(?:[\\/]|$)/.test(value));
 }
 export function clampScore(value) {
     return Math.min(1, Math.max(0, Number(value.toFixed(4))));

package/dist/adapters/claude-attribution.js

@@ -4,6 +4,7 @@ import fs from "node:fs/promises";
 import { createReadStream, existsSync } from "node:fs";
 import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
+import { isRawEvidenceUploadableAttributionState } from "../raw-evidence-attribution-policy.js";
 import { SESSION_FILE_UUID_PATTERN, isPathWithin, sanitizeSessionId, scoreSignalsAgainstWorktrees, sessionIdFromFileName, shortHash, } from "./attribution-core.js";
 /**
  * Deterministic Claude Code session JSONL -> repo/worktree attribution.
@@ -92,11 +93,11 @@ async function discoverClaudeSessions(projectsDir, cutoffMs) {
     try {
         projectEntries = await fs.readdir(projectsDir, { withFileTypes: true });
     }
-    catch {
+    catch (error) {
         return {
             sessions,
             projectDirsSkipped,
-            projectDirReadFailedCount: 1,
+            projectDirReadFailedCount: isMissingPathError(error) ? 0 : 1,
             sessionStatFailedCount,
             sidecarDirReadFailedCount,
             sidecarStatFailedCount,
@@ -118,8 +119,9 @@ async function discoverClaudeSessions(projectsDir, cutoffMs) {
         try {
             sessionEntries = await fs.readdir(projectDir, { withFileTypes: true });
         }
-        catch {
-            projectDirReadFailedCount += 1;
+        catch (error) {
+            if (!isMissingPathError(error))
+                projectDirReadFailedCount += 1;
             continue;
         }
         for (const sessionEntry of sessionEntries) {
@@ -169,11 +171,11 @@ async function discoverSidecars(subagentsDir) {
     try {
         entries = await fs.readdir(subagentsDir, { withFileTypes: true });
     }
-    catch {
+    catch (error) {
         return {
             sidecars: [],
             sidecarsCapped: 0,
-            dirReadFailedCount: 1,
+            dirReadFailedCount: isMissingPathError(error) ? 0 : 1,
             statFailedCount: 0,
         };
     }
@@ -212,6 +214,11 @@ async function discoverSidecars(subagentsDir) {
         statFailedCount,
     };
 }
+function isMissingPathError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
 async function attributeOneSession(session, worktrees, collectionRoots) {
     const fileName = path.basename(session.mainFile);
     const base = {
@@ -310,7 +317,7 @@ async function attributeOneSession(session, worktrees, collectionRoots) {
         extraSignals.push("main_file_oversized");
     if (isSchemaDriftSuspected(signals))
         extraSignals.push("schema_drift_suspected");
-    const sidecarFiles = outcome.state === "attributed" && outcome.worktree
+    const sidecarFiles = isRawEvidenceUploadableAttributionState(outcome.state) && outcome.worktree
         ? await collectSidecarDiagnostics(session.sidecars, outcome.worktree)
         : session.sidecars.map((sidecar) => ({
             local_path: sidecar.local_path,

package/dist/adapters/codex-attribution.js

@@ -87,8 +87,9 @@ async function discoverCodexJsonlFiles(dir, cutoffMs) {
         try {
             entries = await fs.readdir(current, { withFileTypes: true });
         }
-        catch {
-            directoryReadFailedCount += 1;
+        catch (error) {
+            if (!isMissingPathError(error))
+                directoryReadFailedCount += 1;
             continue;
         }
         for (const entry of entries) {
@@ -133,6 +134,11 @@ async function discoverCodexJsonlFiles(dir, cutoffMs) {
         secretPathSkippedCount,
     };
 }
+function isMissingPathError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
 function codexSessionDirsFromOptions(options) {
     const dirs = options.sessionsDirs ?? (options.sessionsDir ? [options.sessionsDir] : []);
     return dedupePaths(dirs);

package/dist/adapters/raw-evidence.js

@@ -7,6 +7,7 @@ import path from "node:path";
 import { makeSourceAdapterIdentity, } from "./common.js";
 import { collectAgentImageEvidenceFromJsonlFile, } from "./agent-image-evidence.js";
 import { defaultCodexSessionDirs, } from "./codex-attribution.js";
+import { isLiveRawEvidenceSyncAttribution } from "../raw-evidence-attribution-policy.js";
 const DEFAULT_SINCE_MINUTES = 24 * 60;
 const DEFAULT_SESSION_LIMIT = 50;
 const MAX_GIT_DIFF_BYTES = 2 * 1024 * 1024;
@@ -14,8 +15,8 @@ const GIT_DIFF_TIMEOUT_MS = 3_000;
 export const RAW_EVIDENCE_BUCKET = "ambient-raw-evidence";
 export const RAW_EVIDENCE_RETENTION_MODE = "remote_durable";
 // Per-sync upload budgets enforced at COLLECTION time (D7b). A single marathon
-// transcript can now approach 512 MiB, so 2 GiB leaves room for several files
-// without starving the sync; overflow still defers and converges next run.
+// transcript can approach the 256 MiB wire cap, so 2 GiB leaves room for
+// several files without starving the sync; overflow still defers and converges.
 export const RAW_EVIDENCE_DEFAULT_BYTE_BUDGET = 2 * 1024 * 1024 * 1024;
 export const RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET = 300;
 const CLAUDE_MAX_COLLECT_FILE_BYTES = RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES;
@@ -72,6 +73,12 @@ export async function collectRawEvidencePack(context, options) {
                 limit: GIT_DIFF_TIMEOUT_MS,
                 applied: false,
             },
+            {
+                source: "codex_jsonl",
+                cap_type: "max_file_bytes",
+                limit: RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES,
+                applied: false,
+            },
             {
                 source: "claude_jsonl",
                 cap_type: "max_file_bytes",
@@ -98,6 +105,8 @@ export async function collectRawEvidencePack(context, options) {
         recordAttributionCompleteness(collection, {
             codex: options.codexAttributionScan,
             claude: options.claudeAttributionScan,
+            selectedCodexPaths: new Set(options.codexSessionFiles?.map((file) => file.local_path) ?? []),
+            selectedClaudePaths: new Set(options.claudeSessionFiles?.map((file) => file.local_path) ?? []),
         });
         if (options.includeCodexJsonl !== false) {
             await collectCodexJsonlFiles(collection, {
@@ -292,12 +301,14 @@ function makeRawEvidenceScan(options) {
     });
 }
 function recordAttributionCompleteness(collection, scans) {
-    if (scans.codex)
-        recordCodexAttributionCompleteness(collection, scans.codex);
-    if (scans.claude)
-        recordClaudeAttributionCompleteness(collection, scans.claude);
+    if (scans.codex) {
+        recordCodexAttributionCompleteness(collection, scans.codex, scans.selectedCodexPaths);
+    }
+    if (scans.claude) {
+        recordClaudeAttributionCompleteness(collection, scans.claude, scans.selectedClaudePaths);
+    }
 }
-function recordCodexAttributionCompleteness(collection, scan) {
+function recordCodexAttributionCompleteness(collection, scan, selectedPaths) {
     recordScanned(collection, "codex_attribution", scan.scanned_file_count);
     collection.caps.push({
         source: "codex_attribution",
@@ -316,9 +327,9 @@ function recordCodexAttributionCompleteness(collection, scan) {
     recordSkipCount(collection, "codex_attribution", "directory_read_failed", scan.directory_read_failed_count);
     recordSkipCount(collection, "codex_attribution", "file_stat_failed", scan.stat_failed_count);
     recordSkipCount(collection, "codex_attribution", "secret_like_directory", scan.secret_path_skipped_count);
-    recordAttributionResultSkips(collection, "codex_attribution", scan.results);
+    recordAttributionResultSkips(collection, "codex_attribution", scan.results, selectedPaths);
 }
-function recordClaudeAttributionCompleteness(collection, scan) {
+function recordClaudeAttributionCompleteness(collection, scan, selectedPaths) {
     recordScanned(collection, "claude_attribution", scan.scanned_session_count);
     if (scan.disabled_reason) {
         recordSkipCount(collection, "claude_attribution", scan.disabled_reason, 1);
@@ -361,7 +372,7 @@ function recordClaudeAttributionCompleteness(collection, scan) {
     recordSkipCount(collection, "claude_attribution", "sidecar_stat_failed", scan.sidecar_stat_failed_count);
     recordSkipCount(collection, "claude_attribution", "sidecar_limit_overflow", scan.counts.sidecars_capped);
     recordTruncationCount(collection, "claude_attribution", "oversized_jsonl_line", scan.counts.oversized_lines_skipped, { max_bytes: scan.max_line_buffer_bytes });
-    recordAttributionResultSkips(collection, "claude_attribution", scan.results);
+    recordAttributionResultSkips(collection, "claude_attribution", scan.results, selectedPaths);
     for (const result of scan.results) {
         for (const sidecar of result.sidecar_files) {
             if (!sidecar.skipped_reason)
@@ -370,10 +381,17 @@ function recordClaudeAttributionCompleteness(collection, scan) {
         }
     }
 }
-function recordAttributionResultSkips(collection, source, results) {
+function recordAttributionResultSkips(collection, source, results, selectedPaths) {
     for (const result of results) {
-        if (result.state === "attributed")
+        // A selected fallback is being collected by this pass. A live-sync-safe
+        // fallback is also not a skip when another worktree pack owns its upload.
+        if (result.state === "attributed" ||
+            (result.state === "attributed_fallback" &&
+                (selectedPaths.has(result.file_path) ||
+                    (result.worktree !== null &&
+                        isLiveRawEvidenceSyncAttribution(result.state, result.reason))))) {
             continue;
+        }
         const reason = result.state === "skipped"
             ? result.reason
             : `attribution_${result.state}:${result.reason}`;
@@ -409,6 +427,9 @@ async function collectCodexJsonlFiles(collection, options) {
             kind: "codex_jsonl",
             sessionId: codexSessionId,
             mediaType: "application/jsonl",
+            // Guard before read/toString: Codex files can exceed the buffered commit
+            // ceiling just like Claude mains.
+            maxFileBytes: RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES,
             redactedSummary: "Raw Codex JSONL transcript with prompts, responses, tool arguments, and tool outputs preserved locally.",
             contentAddress: (hash16) => `codex/${safeKeySegment(codexSessionId)}/${hash16}.jsonl`,
         });