@bli-cockpit/cli 0.1.6 → 0.1.8

package/dist/adapters/codex-attribution.js

@@ -1,29 +1,24 @@
-import { containsSecretLikeContent } from "@bli-cockpit/telemetry-core";
-import crypto from "node:crypto";
+import { SECRET_FILE_SEGMENT_PATTERN, containsSecretLikeContent, } from "@bli-cockpit/telemetry-core";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { normalizeGitOrigin } from "../repo-identity.js";
+import { sanitizeSessionId, scoreSignalsAgainstWorktrees, sessionIdFromFileName, sha256, shortHash, } from "./attribution-core.js";
 /**
  * Deterministic Codex session JSONL -> repo/worktree attribution.
  *
  * Only metadata-bearing records are inspected (session_meta, turn_context):
  * cwd, workspace roots, and git branch/commit/origin. Prompt, response,
  * reasoning, and tool payload fields are never extracted, printed, or
- * summarized. A session is attributed only when exactly one worktree clearly
- * wins; close calls stay ambiguous instead of being duplicated across repos.
+ * summarized. Scoring, the deepest-root tie-break, and the threshold/margin
+ * decision all live in the shared attribution-core so Codex and Claude Code
+ * attribute identically.
  */
+// Re-exported for callers (and tests) that historically imported these from
+// the codex adapter; the single implementation lives in attribution-core.
+export { sanitizeSessionId, sessionIdFromFileName };
 export const CODEX_ATTRIBUTION_DEFAULT_SINCE_MINUTES = 24 * 60;
 export const CODEX_ATTRIBUTION_DEFAULT_SESSION_LIMIT = 50;
 export const CODEX_SESSION_MAX_FILE_BYTES = 10 * 1024 * 1024;
-const SECRET_FILE_SEGMENT_PATTERN = /(^|[/\\])(?:\.env(?:\..*)?|.*(?:secret|credential|private[_-]?key|service[_-]?role).*)$/i;
-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;
-const SCORE_CWD_MATCH = 0.5;
-const SCORE_WORKSPACE_ROOT_MATCH = 0.1;
-const SCORE_ORIGIN_MATCH = 0.3;
-const SCORE_BRANCH_MATCH = 0.15;
-const SCORE_HEAD_SHA_MATCH = 0.05;
-const ATTRIBUTION_MIN_SCORE = 0.4;
-const ATTRIBUTION_MIN_MARGIN = 0.15;
 export async function scanAndAttributeCodexSessions(options) {
     const sinceMinutes = options.sinceMinutes ?? CODEX_ATTRIBUTION_DEFAULT_SINCE_MINUTES;
     const limit = options.limit ?? CODEX_ATTRIBUTION_DEFAULT_SESSION_LIMIT;
@@ -134,7 +129,14 @@ async function attributeOneSession(file, worktrees) {
             worktree: null,
         };
     }
-    return scoreSessionAgainstWorktrees(base, signals, worktrees);
+    const outcome = scoreSignalsAgainstWorktrees({
+        cwds: signals.cwds,
+        workspaceRoots: signals.workspace_roots,
+        originUrls: signals.repository_urls,
+        branches: signals.branches,
+        headShas: signals.commit_hashes,
+    }, worktrees);
+    return { ...base, ...outcome };
 }
 export function extractCodexSessionSignals(content) {
     const sessionIds = new Set();
@@ -204,95 +206,6 @@ export function extractCodexSessionSignals(content) {
         parse_error_count: parseErrorCount,
     };
 }
-function scoreSessionAgainstWorktrees(base, signals, worktrees) {
-    const hasAnySignal = signals.cwds.length > 0 ||
-        signals.workspace_roots.length > 0 ||
-        signals.repository_urls.length > 0 ||
-        signals.branches.length > 0 ||
-        signals.commit_hashes.length > 0;
-    if (!hasAnySignal) {
-        return {
-            ...base,
-            state: "unattributed",
-            reason: "no_repo_signals",
-            signals: [],
-            attribution_score: 0,
-            path_score: 0,
-            worktree: null,
-        };
-    }
-    const scored = worktrees.map((worktree) => {
-        const matched = [];
-        let score = 0;
-        let pathScore = 0;
-        if (signals.cwds.some((cwd) => isPathWithin(cwd, worktree.repo_root))) {
-            score += SCORE_CWD_MATCH;
-            pathScore += SCORE_CWD_MATCH;
-            matched.push("cwd_match");
-        }
-        if (signals.workspace_roots.some((root) => isPathWithin(root, worktree.repo_root))) {
-            score += SCORE_WORKSPACE_ROOT_MATCH;
-            pathScore += SCORE_WORKSPACE_ROOT_MATCH;
-            matched.push("workspace_root_match");
-        }
-        if (worktree.repo_origin_url &&
-            signals.repository_urls.includes(worktree.repo_origin_url)) {
-            score += SCORE_ORIGIN_MATCH;
-            matched.push("origin_url_match");
-        }
-        if (signals.branches.includes(worktree.branch)) {
-            score += SCORE_BRANCH_MATCH;
-            matched.push("branch_match");
-        }
-        if (worktree.head_sha && signals.commit_hashes.includes(worktree.head_sha)) {
-            score += SCORE_HEAD_SHA_MATCH;
-            matched.push("head_sha_match");
-        }
-        return { worktree, score, pathScore, matched };
-    });
-    scored.sort((a, b) => b.score - a.score);
-    const best = scored[0];
-    const secondBestScore = scored[1]?.score ?? 0;
-    if (!best || best.score === 0) {
-        const reason = signals.cwds.length > 0 || signals.workspace_roots.length > 0
-            ? "cwd_outside_scanned_worktrees"
-            : "no_matching_worktree_signals";
-        return {
-            ...base,
-            state: "unattributed",
-            reason,
-            signals: [],
-            attribution_score: 0,
-            path_score: 0,
-            worktree: null,
-        };
-    }
-    const score = clampScore(best.score);
-    const pathScore = clampScore(best.pathScore);
-    if (best.score >= ATTRIBUTION_MIN_SCORE &&
-        best.score - secondBestScore >= ATTRIBUTION_MIN_MARGIN) {
-        return {
-            ...base,
-            state: "attributed",
-            reason: "deterministic_signal_match",
-            signals: best.matched,
-            attribution_score: score,
-            path_score: pathScore,
-            worktree: best.worktree,
-        };
-    }
-    return {
-        ...base,
-        state: "ambiguous",
-        reason: best.score - secondBestScore < ATTRIBUTION_MIN_MARGIN
-            ? "multiple_worktrees_close_scores"
-            : "signal_score_below_threshold",
-        signals: best.matched,
-        attribution_score: score,
-        path_score: pathScore,
-        worktree: null,
-    };
-}
 function skippedResult(base, reason) {
     return {
         ...base,
@@ -304,41 +217,10 @@ function skippedResult(base, reason) {
         worktree: null,
     };
 }
-export function sessionIdFromFileName(fileName) {
-    const match = fileName.match(SESSION_FILE_UUID_PATTERN);
-    return match?.[1]?.toLowerCase() ?? null;
-}
-/**
- * Session ids come from file content and end up inside remote object keys, so
- * anything outside the safe charset falls back to a hash of the raw value
- * instead of poisoning every begin request in the batch.
- */
-export function sanitizeSessionId(value) {
-    if (!value)
-        return null;
-    if (/^[A-Za-z0-9._-]{4,80}$/.test(value))
-        return value;
-    return shortHash(value);
-}
-function isPathWithin(candidate, root) {
-    const normalizedCandidate = path.resolve(candidate);
-    const normalizedRoot = path.resolve(root);
-    return (normalizedCandidate === normalizedRoot ||
-        normalizedCandidate.startsWith(normalizedRoot + path.sep));
-}
 function addString(target, value) {
     if (typeof value === "string" && value.trim())
         target.add(value.trim());
 }
-function clampScore(value) {
-    return Math.min(1, Math.max(0, Number(value.toFixed(4))));
-}
 function isSecretLikePath(value) {
     return SECRET_FILE_SEGMENT_PATTERN.test(value);
-}
-function shortHash(value) {
-    return crypto.createHash("sha256").update(value, "utf8").digest("hex").slice(0, 16);
-}
-function sha256(value) {
-    return crypto.createHash("sha256").update(value).digest("hex");
 }

package/dist/adapters/common.js

@@ -20,10 +20,13 @@ export function makeCaptureProvenance(context, captureSource) {
     };
 }
 export function makeUnavailableScan(context, captureSource, adapterName, reasonLabel) {
+    return makeSourceScan(context, captureSource, adapterName, "skipped", reasonLabel);
+}
+export function makeSourceScan(context, captureSource, adapterName, status, reasonLabel) {
     return SourceScanResultSchema.parse({
         adapter: makeSourceAdapterIdentity(captureSource, adapterName),
         work_context_id: context.workContextId,
-        status: "skipped",
+        status,
         started_at: context.now.toISOString(),
         finished_at: context.now.toISOString(),
         diagnostic_labels: [reasonLabel],

package/dist/adapters/local-sources.js

@@ -1,5 +1,6 @@
 import { collectCarState } from "./car-state.js";
-import { makeUnavailableScan, } from "./common.js";
+import fs from "node:fs/promises";
+import { makeSourceScan, makeUnavailableScan, } from "./common.js";
 import { collectGitState } from "./git-state.js";
 import { collectRawEvidencePack, } from "./raw-evidence.js";
 import { generateDumbRiskFlags } from "./risk-flags.js";
@@ -21,8 +22,13 @@ export async function runLocalSourceCollectors(options) {
             repoRoot: options.repoRoot,
             sessionsDir: options.rawEvidenceSessionsDir,
             includeCodexJsonl: options.rawEvidenceIncludeCodexJsonl,
+            includeClaudeJsonl: options.rawEvidenceIncludeClaudeJsonl,
             codexSessionFiles: options.rawEvidenceCodexSessionFiles,
+            claudeSessionFiles: options.rawEvidenceClaudeSessionFiles,
             skipContentHashes: options.rawEvidenceSkipContentHashes,
+            byteBudget: options.rawEvidenceByteBudget,
+            objectBudget: options.rawEvidenceObjectBudget,
+            budget: options.rawEvidenceBudget,
         })
         : {
             scan: makeUnavailableScan(context, "codex_jsonl", "codex-jsonl", "raw_evidence_state_dir_not_configured"),
@@ -35,10 +41,16 @@ export async function runLocalSourceCollectors(options) {
         makeUnavailableScan(context, "mcp_local", "mcp-local", "mcp_activity_not_configured"),
         makeUnavailableScan(context, "claude_hooks", "claude-hooks", "claude_hooks_not_present"),
     ];
+    // claude_jsonl availability (B.4): "ok" when ~/.claude/projects exists, else
+    // skipped with claude_projects_dir_not_found so an operator on a non-Claude
+    // machine sees why the claude funnel is empty. Collection itself is gated
+    // separately by collect_claude_jsonl in the sync orchestrator.
+    const claudeJsonlScan = await makeClaudeJsonlScan(context, options.claudeProjectsDir);
     const candidates = collectBindingCandidates([
         git.scan,
         car.scan,
         rawEvidence.scan,
+        claudeJsonlScan,
         ...unavailableScans,
     ]);
     const binding = resolveTicketBinding({
@@ -56,7 +68,7 @@ export async function runLocalSourceCollectors(options) {
         binding,
     });
     return {
-        scans: [git.scan, car.scan, rawEvidence.scan, ...unavailableScans],
+        scans: [git.scan, car.scan, rawEvidence.scan, claudeJsonlScan, ...unavailableScans],
         facts: {
             git: gitFacts,
             car: carFacts,
@@ -69,6 +81,13 @@ export async function runLocalSourceCollectors(options) {
 function collectBindingCandidates(scans) {
     return scans.flatMap((scan) => scan.ticket_binding_candidates);
 }
+async function makeClaudeJsonlScan(context, projectsDir) {
+    if (!projectsDir) {
+        return makeUnavailableScan(context, "claude_jsonl", "claude-jsonl", "claude_projects_dir_not_configured");
+    }
+    const present = await fs.stat(projectsDir).then((stat) => stat.isDirectory(), () => false);
+    return makeSourceScan(context, "claude_jsonl", "claude-jsonl", present ? "ok" : "skipped", present ? "claude_projects_dir_present" : "claude_projects_dir_not_found");
+}
 function isGitStateFacts(value) {
     return Boolean(value && typeof value === "object" && "repo_root" in value);
 }

package/dist/adapters/raw-evidence.js

@@ -1,4 +1,4 @@
-import { SourceScanResultSchema, containsSecretLikeContent, } from "@bli-cockpit/telemetry-core";
+import { SECRET_FILE_SEGMENT_PATTERN, SourceScanResultSchema, containsSecretLikeContent, } from "@bli-cockpit/telemetry-core";
 import { execFile } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
@@ -12,7 +12,14 @@ const DEFAULT_SESSION_LIMIT = 50;
 const MAX_GIT_DIFF_BYTES = 2 * 1024 * 1024;
 export const RAW_EVIDENCE_BUCKET = "ambient-raw-evidence";
 export const RAW_EVIDENCE_RETENTION_MODE = "remote_durable";
-const SECRET_FILE_SEGMENT_PATTERN = /(^|[/\\])(?:\.env(?:\..*)?|.*(?:secret|credential|private[_-]?key|service[_-]?role).*)$/i;
+// Per-sync upload budgets enforced at COLLECTION time (D7b). With sidecars a
+// worst-case sync could buffer hundreds of MiB and fire thousands of chunk
+// POSTs; the byte budget bounds buffered bytes and the object budget bounds
+// request count. Overflow becomes a deferred-skip entry, picked up next sync
+// (content addressing makes this convergent).
+export const RAW_EVIDENCE_DEFAULT_BYTE_BUDGET = 512 * 1024 * 1024;
+export const RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET = 300;
+const CLAUDE_MAX_COLLECT_FILE_BYTES = 10 * 1024 * 1024;
 export async function collectRawEvidencePack(context, options) {
     const startedAt = context.now.toISOString();
     const packId = rawEvidencePackId(context);
@@ -21,35 +28,37 @@ export async function collectRawEvidencePack(context, options) {
     const entries = [];
     const skipped = [];
     const reused = [];
-    const skipContentHashes = options.skipContentHashes ?? new Set();
+    const collection = {
+        context,
+        filesDir,
+        packId,
+        entries,
+        skipped,
+        reused,
+        skipContentHashes: options.skipContentHashes ?? new Set(),
+        budget: options.budget ?? {
+            remainingBytes: options.byteBudget ?? RAW_EVIDENCE_DEFAULT_BYTE_BUDGET,
+            remainingObjects: options.objectBudget ?? RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET,
+        },
+        index: { value: 0 },
+    };
     try {
         await ensurePrivateDir(evidenceDir);
         await ensurePrivateDir(filesDir);
         if (options.includeCodexJsonl !== false) {
-            await collectCodexJsonlFiles({
-                context,
-                filesDir,
-                packId,
-                entries,
-                skipped,
-                reused,
-                skipContentHashes,
+            await collectCodexJsonlFiles(collection, {
                 codexSessionFiles: options.codexSessionFiles,
                 sessionsDir: options.sessionsDir,
                 sinceMinutes: options.sinceMinutes ?? DEFAULT_SINCE_MINUTES,
                 limit: options.sessionLimit ?? DEFAULT_SESSION_LIMIT,
             });
         }
-        await collectGitDiffFiles({
-            context,
-            filesDir,
-            packId,
-            repoRoot: options.repoRoot,
-            entries,
-            skipped,
-            reused,
-            skipContentHashes,
-        });
+        if (options.includeClaudeJsonl !== false && options.claudeSessionFiles) {
+            await collectClaudeJsonlFiles(collection, options.claudeSessionFiles);
+        }
+        await collectGitDiffFiles(collection, options.repoRoot);
+        const deferredByteBudgetCount = skipped.filter((entry) => entry.reason === "deferred_byte_budget").length;
+        const deferredObjectBudgetCount = skipped.filter((entry) => entry.reason === "deferred_object_budget").length;
         if (entries.length === 0) {
             const facts = {
                 pack_id: packId,
@@ -60,6 +69,8 @@ export async function collectRawEvidencePack(context, options) {
                 byte_size: 0,
                 skipped_count: skipped.length,
                 reused_count: reused.length,
+                deferred_byte_budget_count: deferredByteBudgetCount,
+                deferred_object_budget_count: deferredObjectBudgetCount,
                 content_kinds: [],
                 pointers: [],
                 upload_files: [],
@@ -78,7 +89,6 @@ export async function collectRawEvidencePack(context, options) {
         const manifestWithoutSelf = makeManifest({
             context,
             packId,
-            evidenceDir,
             entries,
             skipped,
             reused,
@@ -108,6 +118,8 @@ export async function collectRawEvidencePack(context, options) {
             byte_size: entries.reduce((sum, entry) => sum + entry.byte_size, 0),
             skipped_count: skipped.length,
             reused_count: reused.length,
+            deferred_byte_budget_count: deferredByteBudgetCount,
+            deferred_object_budget_count: deferredObjectBudgetCount,
             content_kinds: [...new Set(entries.map((entry) => entry.kind))],
             pointers: entries.map(pointerFromEntry),
             upload_files: entries.map((entry) => ({
@@ -174,88 +186,181 @@ function makeRawEvidenceScan(options) {
         ],
     });
 }
-async function collectCodexJsonlFiles(options) {
+async function collectCodexJsonlFiles(collection, options) {
     const candidates = options.codexSessionFiles
         ? options.codexSessionFiles.map((file) => ({
             filePath: file.local_path,
             codexSessionId: file.codex_session_id,
         }))
-        : (await walkJsonlFiles(options.sessionsDir ?? path.join(os.homedir(), ".codex", "sessions"), options.context.now.getTime() - options.sinceMinutes * 60 * 1000))
+        : (await walkJsonlFiles(options.sessionsDir ?? path.join(os.homedir(), ".codex", "sessions"), collection.context.now.getTime() - options.sinceMinutes * 60 * 1000))
             .slice(0, options.limit)
             .map((filePath) => ({ filePath, codexSessionId: null }));
-    let index = 0;
     for (const candidate of candidates) {
-        const fileName = path.basename(candidate.filePath);
-        if (isSecretLikePath(fileName)) {
-            options.skipped.push({
-                kind: "codex_jsonl",
-                label: fileName,
-                reason: "secret_like_file_name",
+        const codexSessionId = candidate.codexSessionId ?? shortHash(candidate.filePath);
+        await collectOneEvidenceFile(collection, {
+            filePath: candidate.filePath,
+            kind: "codex_jsonl",
+            sessionId: codexSessionId,
+            mediaType: "application/jsonl",
+            redactedSummary: "Raw Codex JSONL transcript with prompts, responses, tool arguments, and tool outputs preserved locally.",
+            contentAddress: (hash16) => `codex/${safeKeySegment(codexSessionId)}/${hash16}.jsonl`,
+        });
+    }
+}
+async function collectClaudeJsonlFiles(collection, sessions) {
+    for (const session of sessions) {
+        const sessionId = session.claude_session_id;
+        if (session.main_file_oversized) {
+            // D7: the oversized main was attributed via a streamed read but its bytes
+            // are never uploaded (server commit assembles in memory). Its sidecars
+            // still collect below.
+            collection.skipped.push({
+                kind: "claude_jsonl",
+                label: path.basename(session.local_path),
+                reason: "file_too_large",
             });
-            continue;
         }
-        let raw;
-        try {
-            raw = await fs.readFile(candidate.filePath);
+        else if (session.skip_main) {
+            // D9 damped: prior durable copy is still good enough; collect sidecars
+            // only. The session reports reused_existing from cursor state, so no
+            // skipped entry is recorded here.
         }
-        catch {
-            options.skipped.push({
-                kind: "codex_jsonl",
-                label: fileName,
-                reason: "file_read_failed",
+        else {
+            await collectOneEvidenceFile(collection, {
+                filePath: session.local_path,
+                kind: "claude_jsonl",
+                sessionId,
+                mediaType: "application/jsonl",
+                // Re-check size at collection: a main that grew past the cap between
+                // attribution and collection is an honest file_too_large skip, not an
+                // upload_failed at the chunk client.
+                maxFileBytes: CLAUDE_MAX_COLLECT_FILE_BYTES,
+                redactedSummary: "Raw Claude Code JSONL transcript with prompts, responses, tool arguments, and tool outputs preserved locally.",
+                contentAddress: (hash16) => `claude/${safeKeySegment(sessionId)}/${hash16}.jsonl`,
             });
-            continue;
         }
-        if (containsSecretLikeContent(raw.toString("utf8"))) {
-            options.skipped.push({
-                kind: "codex_jsonl",
-                label: fileName,
-                reason: "secret_like_content_guard",
-            });
-            continue;
-        }
-        const contentHash = sha256(raw);
-        const codexSessionId = candidate.codexSessionId ?? shortHash(candidate.filePath);
-        if (options.skipContentHashes.has(contentHash)) {
-            options.reused.push({
-                kind: "codex_jsonl",
-                label: fileName,
-                content_hash_sha256: contentHash,
-                codex_session_id: codexSessionId,
+        for (const sidecar of session.sidecar_files) {
+            const stem = path.basename(sidecar.local_path).replace(/\.jsonl$/i, "");
+            await collectOneEvidenceFile(collection, {
+                filePath: sidecar.local_path,
+                kind: "claude_jsonl_sidecar",
+                sessionId,
+                mediaType: "application/jsonl",
+                maxFileBytes: CLAUDE_MAX_COLLECT_FILE_BYTES,
+                redactedSummary: "Raw Claude Code subagent transcript with prompts, responses, tool arguments, and tool outputs preserved locally.",
+                contentAddress: (hash16) => `claude/${safeKeySegment(sessionId)}/subagents/${safeKeySegment(stem)}-${hash16}.jsonl`,
             });
-            continue;
         }
-        index += 1;
-        const relativePath = path.join("files", `${String(index).padStart(3, "0")}-${shortHash(candidate.filePath)}-${fileName}`);
-        const destination = path.join(options.filesDir, path.basename(relativePath));
-        await fs.writeFile(destination, raw, { mode: 0o600 });
-        await chmodPrivate(destination, 0o600);
-        options.entries.push(evidenceEntry({
-            kind: "codex_jsonl",
-            packId: options.packId,
-            operatorId: options.context.operatorId,
-            workContextId: options.context.workContextId,
-            localPath: destination,
-            relativePath,
-            mediaType: "application/jsonl",
-            redactedSummary: "Raw Codex JSONL transcript with prompts, responses, tool arguments, and tool outputs preserved locally.",
-            bytes: raw,
-            codexSessionId,
-            contentAddress: `codex/${safeKeySegment(codexSessionId)}/${contentHash.slice(0, 16)}.jsonl`,
-        }));
     }
 }
-async function collectGitDiffFiles(options) {
+/**
+ * Reads, secret-guards, content-addresses, budget-checks, and copies one
+ * attributed transcript into the pack. The secret guard runs again here even
+ * though attribution already guarded — three reads per file (attribution,
+ * collection, server commit) is the accepted defense-in-depth cost; do not
+ * "optimize" a layer away.
+ */
+async function collectOneEvidenceFile(collection, options) {
+    const fileName = path.basename(options.filePath);
+    if (isSecretLikePath(fileName)) {
+        collection.skipped.push({
+            kind: options.kind,
+            label: fileName,
+            reason: "secret_like_file_name",
+        });
+        return;
+    }
+    let raw;
+    try {
+        raw = await fs.readFile(options.filePath);
+    }
+    catch {
+        collection.skipped.push({
+            kind: options.kind,
+            label: fileName,
+            reason: "file_read_failed",
+        });
+        return;
+    }
+    if (options.maxFileBytes && raw.byteLength > options.maxFileBytes) {
+        collection.skipped.push({
+            kind: options.kind,
+            label: fileName,
+            reason: "file_too_large",
+        });
+        return;
+    }
+    if (containsSecretLikeContent(raw.toString("utf8"))) {
+        collection.skipped.push({
+            kind: options.kind,
+            label: fileName,
+            reason: "secret_like_content_guard",
+        });
+        return;
+    }
+    const contentHash = sha256(raw);
+    if (collection.skipContentHashes.has(contentHash)) {
+        collection.reused.push({
+            kind: options.kind,
+            label: fileName,
+            content_hash_sha256: contentHash,
+            codex_session_id: options.sessionId,
+        });
+        return;
+    }
+    const deferReason = admitToBudget(collection.budget, raw.byteLength);
+    if (deferReason) {
+        collection.skipped.push({
+            kind: options.kind,
+            label: fileName,
+            reason: deferReason,
+        });
+        return;
+    }
+    collection.index.value += 1;
+    const relativePath = path.join("files", `${String(collection.index.value).padStart(3, "0")}-${shortHash(options.filePath)}-${fileName}`);
+    const destination = path.join(collection.filesDir, path.basename(relativePath));
+    await fs.writeFile(destination, raw, { mode: 0o600 });
+    await chmodPrivate(destination, 0o600);
+    collection.entries.push(evidenceEntry({
+        kind: options.kind,
+        packId: collection.packId,
+        operatorId: collection.context.operatorId,
+        workContextId: collection.context.workContextId,
+        localPath: destination,
+        relativePath,
+        mediaType: options.mediaType,
+        redactedSummary: options.redactedSummary,
+        bytes: raw,
+        codexSessionId: options.sessionId,
+        contentAddress: options.contentAddress(contentHash.slice(0, 16)),
+    }));
+}
+/**
+ * Decrements the per-sync budget when a file fits, or returns a deferred-skip
+ * reason when it does not. The object budget bounds request count; the byte
+ * budget bounds buffered bytes.
+ */
+function admitToBudget(budget, byteLength) {
+    if (budget.remainingObjects <= 0)
+        return "deferred_object_budget";
+    if (byteLength > budget.remainingBytes)
+        return "deferred_byte_budget";
+    budget.remainingObjects -= 1;
+    budget.remainingBytes -= byteLength;
+    return null;
+}
+async function collectGitDiffFiles(collection, repoRoot) {
     const diffTargets = [
         { label: "unstaged", args: ["diff", "--no-ext-diff", "--"] },
         { label: "staged", args: ["diff", "--cached", "--no-ext-diff", "--"] },
     ];
     for (const target of diffTargets) {
-        const diff = await runGitDiff(target.args, options.repoRoot);
+        const diff = await runGitDiff(target.args, repoRoot);
         if (!diff.trim())
             continue;
         if (containsSecretLikeContent(diff)) {
-            options.skipped.push({
+            collection.skipped.push({
                 kind: "git_diff",
                 label: target.label,
                 reason: "secret_like_content_guard",
@@ -264,8 +369,8 @@ async function collectGitDiffFiles(options) {
         }
         const raw = Buffer.from(diff.slice(0, MAX_GIT_DIFF_BYTES), "utf8");
         const contentHash = sha256(raw);
-        if (options.skipContentHashes.has(contentHash)) {
-            options.reused.push({
+        if (collection.skipContentHashes.has(contentHash)) {
+            collection.reused.push({
                 kind: "git_diff",
                 label: target.label,
                 content_hash_sha256: contentHash,
@@ -273,15 +378,24 @@ async function collectGitDiffFiles(options) {
             });
             continue;
         }
+        const deferReason = admitToBudget(collection.budget, raw.byteLength);
+        if (deferReason) {
+            collection.skipped.push({
+                kind: "git_diff",
+                label: target.label,
+                reason: deferReason,
+            });
+            continue;
+        }
         const relativePath = path.join("files", `git-${target.label}.diff`);
-        const destination = path.join(options.filesDir, path.basename(relativePath));
+        const destination = path.join(collection.filesDir, path.basename(relativePath));
         await fs.writeFile(destination, raw, { mode: 0o600 });
         await chmodPrivate(destination, 0o600);
-        options.entries.push(evidenceEntry({
+        collection.entries.push(evidenceEntry({
             kind: "git_diff",
-            packId: options.packId,
-            operatorId: options.context.operatorId,
-            workContextId: options.context.workContextId,
+            packId: collection.packId,
+            operatorId: collection.context.operatorId,
+            workContextId: collection.context.workContextId,
             localPath: destination,
             relativePath,
             mediaType: "text/x-diff",
@@ -358,6 +472,7 @@ function makeManifest(options) {
             raw_prompts: "preserved_private_durable_remote",
             raw_responses: "preserved_private_durable_remote",
             transcripts: "preserved_private_durable_remote",
+            claude_transcripts: "preserved_private_durable_remote",
             tool_payloads: "preserved_private_durable_remote",
             git_diffs: "preserved_private_durable_remote_env_secret_paths_excluded",
             env_files: "never_read",
@@ -417,10 +532,10 @@ function pointerFromEntry(entry) {
     };
 }
 /**
- * Codex JSONL and git diff objects are content-addressed (kind/id/hash) so the
- * same content maps to the same remote key across syncs: interrupted uploads
- * resume and repeated syncs dedupe server-side. Pack-scoped keys remain for
- * the per-sync manifest.
+ * Codex/Claude JSONL and git diff objects are content-addressed (kind/id/hash)
+ * so the same content maps to the same remote key across syncs: interrupted
+ * uploads resume and repeated syncs dedupe server-side. Pack-scoped keys remain
+ * for the per-sync manifest.
  */
 function remoteObjectKey(options) {
     if (options.contentAddress) {