@bli-cockpit/cli 0.2.27 → 0.2.28

package/dist/adapters/raw-evidence.js

@@ -8,6 +8,7 @@ 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";
+import { contentKeyedRawEvidencePackId, DELIVERY_BACKOFF_HOLDING_REASON, evidenceSourceKey, heldSourceKeys, readRawEvidenceStagingState, recordStagedObject, resolveStagedObject, writeRawEvidenceStagingState, } from "../raw-evidence-staging.js";
 const DEFAULT_SINCE_MINUTES = 24 * 60;
 const DEFAULT_SESSION_LIMIT = 50;
 const MAX_GIT_DIFF_BYTES = 2 * 1024 * 1024;
@@ -23,9 +24,14 @@ export const RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET = 300;
 const CLAUDE_MAX_COLLECT_FILE_BYTES = RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES;
 export async function collectRawEvidencePack(context, options) {
     const startedAt = context.now.toISOString();
-    const packId = rawEvidencePackId(context);
-    const evidenceDir = path.join(options.stateDir, "raw-evidence", packId);
-    const filesDir = path.join(evidenceDir, "files");
+    const rawEvidenceRoot = path.join(options.stateDir, "raw-evidence");
+    // Staging first, promotion second (BLI-3066). The pack id cannot be known
+    // until the content is, so bytes land in a private staging directory and the
+    // directory is then renamed to its content-keyed name — or dropped, when an
+    // identical pack is already there.
+    const stagingDir = path.join(rawEvidenceRoot, `.staging-${process.pid}-${crypto.randomUUID().slice(0, 8)}`);
+    const filesDir = path.join(stagingDir, "files");
+    const staging = await readRawEvidenceStagingState(options.stateDir);
     const entries = [];
     const skipped = [];
     const truncated = [];
@@ -39,7 +45,13 @@ export async function collectRawEvidencePack(context, options) {
     const collection = {
         context,
         filesDir,
-        packId,
+        rawEvidenceRoot,
+        packId: "",
+        staging,
+        heldSources: heldSourceKeys(staging, context.now),
+        stagedReusedCount: 0,
+        stagedNewCount: 0,
+        deliveryHeldCount: 0,
         entries,
         skipped,
         truncated,
@@ -101,7 +113,7 @@ export async function collectRawEvidencePack(context, options) {
         index: { value: 0 },
     };
     try {
-        await ensurePrivateDir(evidenceDir);
+        await ensurePrivateDir(stagingDir);
         await ensurePrivateDir(filesDir);
         recordAttributionCompleteness(collection, {
             codex: options.codexAttributionScan,
@@ -125,6 +137,16 @@ export async function collectRawEvidencePack(context, options) {
         const deferredByteBudgetCount = skipped.filter((entry) => entry.reason === "deferred_byte_budget").reduce((sum, entry) => sum + evidenceEntryCount(entry), 0);
         const deferredObjectBudgetCount = skipped.filter((entry) => entry.reason === "deferred_object_budget").reduce((sum, entry) => sum + evidenceEntryCount(entry), 0);
         if (entries.length === 0) {
+            // Nothing collected: drop the staging directory instead of leaving an
+            // empty pack behind. This used to leave one empty `work-*` dir per sync.
+            await fs.rm(stagingDir, { recursive: true, force: true }).catch(() => undefined);
+            const packId = contentKeyedRawEvidencePackId({
+                workContextId: context.workContextId,
+                contentHashes: [],
+            });
+            collection.packId = packId;
+            const evidenceDir = path.join(rawEvidenceRoot, packId);
+            await persistStagingState(options.stateDir, collection);
             const evidenceCompleteness = makeEvidenceCompleteness(collection, {
                 startedAt,
                 finishedAt: context.now.toISOString(),
@@ -140,6 +162,10 @@ export async function collectRawEvidencePack(context, options) {
                 skipped_count: countEvidenceEntries(skipped),
                 sanitized_count: redacted.length,
                 reused_count: reused.length,
+                staged_reused_count: collection.stagedReusedCount,
+                staged_new_count: collection.stagedNewCount,
+                delivery_held_count: collection.deliveryHeldCount,
+                stage_state: "empty",
                 deferred_byte_budget_count: deferredByteBudgetCount,
                 deferred_object_budget_count: deferredObjectBudgetCount,
                 content_kinds: [],
@@ -158,18 +184,45 @@ export async function collectRawEvidencePack(context, options) {
                 }),
             };
         }
-        const manifestWithoutSelf = makeManifest({
+        // The pack is named by what is in it, never by when it was made. Identical
+        // content on the next sync resolves to the identical directory, which is
+        // the whole fix for BLI-3066.
+        const packId = contentKeyedRawEvidencePackId({
+            workContextId: context.workContextId,
+            contentHashes: entries.map((entry) => entry.content_hash_sha256),
+        });
+        collection.packId = packId;
+        const promotion = await promoteStagedPack({
+            rawEvidenceRoot,
+            stagingDir,
+            packId,
+            workContextId: context.workContextId,
+            entries,
+        });
+        const evidenceDir = promotion.evidenceDir;
+        for (const entry of entries) {
+            if (!entry.staged_in_pack)
+                continue;
+            entry.local_path = path.join(evidenceDir, "files", path.basename(entry.local_path));
+            recordStagedObject(collection.staging, entry.content_hash_sha256, {
+                pack_id: packId,
+                relative_path: `files/${path.basename(entry.local_path)}`,
+                byte_size: entry.byte_size,
+                source_key: entry.source_key,
+                staged_at: context.now.toISOString(),
+            });
+        }
+        const manifestPath = path.join(evidenceDir, "manifest.json");
+        const manifestBytes = await stageManifest({
             context,
             packId,
+            manifestPath,
             entries,
             skipped,
             redacted,
             reused,
+            reusePack: promotion.state === "reused",
         });
-        const manifestPath = path.join(evidenceDir, "manifest.json");
-        const manifestBytes = Buffer.from(`${JSON.stringify(manifestWithoutSelf, null, 2)}\n`, "utf8");
-        await fs.writeFile(manifestPath, manifestBytes, { mode: 0o600 });
-        await chmodPrivate(manifestPath, 0o600);
         const manifestEntry = evidenceEntry({
             context,
             kind: "manifest",
@@ -181,6 +234,25 @@ export async function collectRawEvidencePack(context, options) {
             bytes: manifestBytes,
         });
         entries.push(manifestEntry);
+        await persistStagingState(options.stateDir, collection);
+        console.error("[raw-evidence] pack staged", JSON.stringify({
+            pack_id: packId,
+            stage_state: promotion.state,
+            reason: promotion.state === "reused"
+                ? "staged_reused"
+                : promotion.state === "restaged_incomplete"
+                    ? "restaged_incomplete"
+                    : promotion.priorPackCount > 0
+                        ? "restaged_content_changed"
+                        : "staged_new",
+            prior_pack_count: promotion.priorPackCount,
+            refilled_file_count: promotion.refilledFileCount,
+            file_count: entries.length,
+            byte_size: entries.reduce((sum, entry) => sum + entry.byte_size, 0),
+            staged_new: collection.stagedNewCount,
+            staged_reused: collection.stagedReusedCount,
+            delivery_held: collection.deliveryHeldCount,
+        }));
         const evidenceCompleteness = makeEvidenceCompleteness(collection, {
             startedAt,
             finishedAt: context.now.toISOString(),
@@ -191,6 +263,10 @@ export async function collectRawEvidencePack(context, options) {
             manifest_path: manifestPath,
             evidence_dir: evidenceDir,
             storage_bucket: RAW_EVIDENCE_BUCKET,
+            staged_reused_count: collection.stagedReusedCount,
+            staged_new_count: collection.stagedNewCount,
+            delivery_held_count: collection.deliveryHeldCount,
+            stage_state: promotion.state,
             file_count: entries.length,
             byte_size: entries.reduce((sum, entry) => sum + entry.byte_size, 0),
             skipped_count: countEvidenceEntries(skipped),
@@ -222,11 +298,28 @@ export async function collectRawEvidencePack(context, options) {
             }),
         };
     }
-    catch {
+    catch (error) {
         failed.push({
             kind: "raw_evidence",
             reason: "collection_failed",
         });
+        // Staging is per-attempt scratch: a crashed pass must not leave a partial
+        // directory behind to be counted, re-hashed or swept later.
+        await fs.rm(stagingDir, { recursive: true, force: true }).catch(() => undefined);
+        const packId = collection.packId ||
+            contentKeyedRawEvidencePackId({
+                workContextId: context.workContextId,
+                contentHashes: entries.map((entry) => entry.content_hash_sha256),
+            });
+        const evidenceDir = path.join(rawEvidenceRoot, packId);
+        console.error("[raw-evidence] pack collection failed", JSON.stringify({
+            pack_id: packId,
+            reason: "collection_failed",
+            detail: error instanceof Error ? error.name : typeof error,
+            collected_file_count: entries.length,
+            staged_new: collection.stagedNewCount,
+            staged_reused: collection.stagedReusedCount,
+        }));
         const evidenceCompleteness = makeEvidenceCompleteness(collection, {
             startedAt,
             finishedAt: context.now.toISOString(),
@@ -242,6 +335,10 @@ export async function collectRawEvidencePack(context, options) {
             skipped_count: countEvidenceEntries(skipped),
             sanitized_count: redacted.length,
             reused_count: reused.length,
+            staged_reused_count: collection.stagedReusedCount,
+            staged_new_count: collection.stagedNewCount,
+            delivery_held_count: collection.deliveryHeldCount,
+            stage_state: "empty",
             deferred_byte_budget_count: skipped
                 .filter((entry) => entry.reason === "deferred_byte_budget")
                 .reduce((sum, entry) => sum + evidenceEntryCount(entry), 0),
@@ -293,6 +390,10 @@ function makeRawEvidenceScan(options) {
             `bytes:${options.facts.byte_size}`,
             `skipped:${options.facts.skipped_count}`,
             `reused:${options.facts.reused_count}`,
+            `stage_state:${options.facts.stage_state}`,
+            `staged_new:${options.facts.staged_new_count}`,
+            `staged_reused:${options.facts.staged_reused_count}`,
+            `delivery_held:${options.facts.delivery_held_count}`,
             `completeness:${options.facts.evidence_completeness.status}`,
             `truncated:${options.facts.evidence_completeness.totals.truncated_count}`,
             `deferred:${options.facts.evidence_completeness.totals.deferred_count}`,
@@ -576,15 +677,26 @@ async function collectOneAgentImageFile(collection, options) {
     }
     collection.index.value += 1;
     const relativePath = path.join("files", `${String(collection.index.value).padStart(3, "0")}-agent-image-${contentHash.slice(0, 16)}.${options.image.extension}`);
-    const destination = path.join(collection.filesDir, path.basename(relativePath));
-    await fs.writeFile(destination, raw, { mode: 0o600 });
-    await chmodPrivate(destination, 0o600);
+    const imageSourceKey = evidenceSourceKey({
+        kind: options.kind,
+        sessionId: options.sessionId,
+        label: options.image.label,
+    });
+    const staged = await stageEvidenceBytes(collection, {
+        contentHash,
+        bytes: raw,
+        fileName: path.basename(relativePath),
+        kind: options.kind,
+        sourceKey: imageSourceKey,
+    });
     collection.entries.push(evidenceEntry({
         context: collection.context,
         kind: options.kind,
         packId: collection.packId,
-        localPath: destination,
+        localPath: staged.local_path,
         relativePath,
+        stagedInPack: staged.staged_in_pack,
+        sourceKey: imageSourceKey,
         mediaType: metadata.media_type,
         redactedSummary: "Raw image explicitly attached to an agent session, preserved in private durable storage.",
         bytes: raw,
@@ -606,6 +718,29 @@ async function collectOneEvidenceFile(collection, options) {
         ? "[REDACTED_FILE_NAME]"
         : fileName;
     const packedFileName = secretLikeFileName ? "redacted-file.jsonl" : fileName;
+    const sourceKey = evidenceSourceKey({
+        kind: options.kind,
+        sessionId: options.sessionId,
+        sourcePath: options.filePath,
+    });
+    // Delivery backoff is checked BEFORE the file is read. An object whose commit
+    // has failed repeatedly costs nothing at all this cycle — no read, no hash,
+    // no copy, no request — and the hold is a named, retryable gap so a held
+    // session cannot make the sync look clean (BLI-3066).
+    if (collection.heldSources.has(sourceKey)) {
+        collection.deliveryHeldCount += 1;
+        collection.skipped.push({
+            kind: options.kind,
+            label: evidenceLabel,
+            reason: DELIVERY_BACKOFF_HOLDING_REASON,
+        });
+        console.error("[raw-evidence] delivery backoff holding source", JSON.stringify({
+            reason: DELIVERY_BACKOFF_HOLDING_REASON,
+            kind: options.kind,
+            source_key: sourceKey,
+        }));
+        return false;
+    }
     if (options.maxFileBytes) {
         let stat;
         try {
@@ -694,14 +829,18 @@ async function collectOneEvidenceFile(collection, options) {
     }
     collection.index.value += 1;
     const relativePath = path.join("files", `${String(collection.index.value).padStart(3, "0")}-${shortHash(options.filePath)}-${packedFileName}`);
-    const destination = path.join(collection.filesDir, path.basename(relativePath));
-    await fs.writeFile(destination, evidenceBytes, { mode: 0o600 });
-    await chmodPrivate(destination, 0o600);
+    const staged = await stageEvidenceBytes(collection, {
+        contentHash,
+        bytes: evidenceBytes,
+        fileName: path.basename(relativePath),
+        kind: options.kind,
+        sourceKey,
+    });
     collection.entries.push(evidenceEntry({
         context: collection.context,
         kind: options.kind,
         packId: collection.packId,
-        localPath: destination,
+        localPath: staged.local_path,
         relativePath,
         mediaType: options.mediaType,
         redactedSummary: redaction
@@ -711,9 +850,38 @@ async function collectOneEvidenceFile(collection, options) {
         bytes: evidenceBytes,
         codexSessionId: options.sessionId,
         contentAddress: options.contentAddress(contentHash.slice(0, 16)),
+        stagedInPack: staged.staged_in_pack,
+        sourceKey,
     }));
     return true;
 }
+/**
+ * Put these bytes on disk once.
+ *
+ * If an earlier sync already staged this exact content and the copy is still
+ * there, that copy is used — the uploader only needs a readable path, and it
+ * does not care which pack directory holds it. This is the branch that stops
+ * one 334 MB rollout from becoming 559 copies while its commit keeps failing.
+ */
+async function stageEvidenceBytes(collection, options) {
+    const existing = await resolveStagedObject(collection.rawEvidenceRoot, collection.staging, options.contentHash);
+    if (existing) {
+        collection.stagedReusedCount += 1;
+        console.error("[raw-evidence] staged copy reused", JSON.stringify({
+            reason: "staged_reused",
+            kind: options.kind,
+            content_hash_prefix: options.contentHash.slice(0, 16),
+            byte_size: existing.entry.byte_size,
+            pack_id: existing.entry.pack_id,
+        }));
+        return { local_path: existing.local_path, staged_in_pack: false };
+    }
+    const destination = path.join(collection.filesDir, options.fileName);
+    await fs.writeFile(destination, options.bytes, { mode: 0o600 });
+    await chmodPrivate(destination, 0o600);
+    collection.stagedNewCount += 1;
+    return { local_path: destination, staged_in_pack: true };
+}
 /**
  * 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
@@ -934,15 +1102,26 @@ async function collectGitDiffFiles(collection, repoRoot) {
             continue;
         }
         const relativePath = path.join("files", `git-${target.label}.diff`);
-        const destination = path.join(collection.filesDir, path.basename(relativePath));
-        await fs.writeFile(destination, raw, { mode: 0o600 });
-        await chmodPrivate(destination, 0o600);
+        const diffSourceKey = evidenceSourceKey({
+            kind: "git_diff",
+            sessionId: collection.context.workContextId,
+            label: target.label,
+        });
+        const staged = await stageEvidenceBytes(collection, {
+            contentHash,
+            bytes: raw,
+            fileName: path.basename(relativePath),
+            kind: "git_diff",
+            sourceKey: diffSourceKey,
+        });
         collection.entries.push(evidenceEntry({
             context: collection.context,
             kind: "git_diff",
             packId: collection.packId,
-            localPath: destination,
+            localPath: staged.local_path,
             relativePath,
+            stagedInPack: staged.staged_in_pack,
+            sourceKey: diffSourceKey,
             mediaType: "text/x-diff",
             redactedSummary: redaction
                 ? `Raw git ${target.label} diff preserved locally with env/secret paths excluded and secret-like values deterministically redacted.`
@@ -1309,6 +1488,8 @@ function evidenceEntry(options) {
         redacted_summary: options.redactedSummary,
         ...(options.redaction ? { redaction: options.redaction } : {}),
         codex_session_id: options.codexSessionId ?? null,
+        staged_in_pack: options.stagedInPack !== false,
+        source_key: options.sourceKey ?? null,
         ...(options.artifactMetadata
             ? {
                 artifact_metadata: {
@@ -1323,6 +1504,10 @@ function evidenceEntry(options) {
             : {}),
     };
 }
+// `local_path` is redacted out, and so are the staging bookkeeping fields:
+// where a copy happens to live on this disk is not part of the pack's identity,
+// and putting it in the manifest would make byte-identical content produce
+// different manifests.
 function redactManifestEntry(entry) {
     return {
         kind: entry.kind,
@@ -1417,13 +1602,125 @@ function readableKeySegment(value, fallback, options = {}) {
 function posixPath(parts) {
     return parts.join("/").replace(/\\/g, "/").replace(/\/+/g, "/");
 }
-function rawEvidencePackId(context) {
-    const material = [
-        context.workContextId,
-        context.sessionId,
-        context.now.toISOString(),
-    ].join(":");
-    return `${context.workContextId}-${shortHash(material)}`;
+/**
+ * Turn the staging directory into the content-keyed pack directory.
+ *
+ * Three outcomes, all of them named:
+ * - the pack does not exist yet: rename staging into place (`new`);
+ * - it exists and holds every file this pass staged: adopt it and delete the
+ *   staging copy (`reused`) — nothing is copied twice;
+ * - it exists but is missing files: fill the gaps from staging
+ *   (`restaged_incomplete`), because a half-written pack must not be trusted.
+ *
+ * Never deletes an existing pack directory wholesale: another pack's entries
+ * can point into it through the staged-object index.
+ */
+async function promoteStagedPack(options) {
+    const evidenceDir = path.join(options.rawEvidenceRoot, options.packId);
+    const priorPackCount = await countPriorPacks(options.rawEvidenceRoot, options.workContextId, options.packId);
+    const existing = await fs.stat(evidenceDir).catch(() => null);
+    if (!existing?.isDirectory()) {
+        try {
+            await fs.rename(options.stagingDir, evidenceDir);
+            return {
+                state: "new",
+                evidenceDir,
+                priorPackCount,
+                refilledFileCount: 0,
+            };
+        }
+        catch {
+            // A concurrent sync can win the race to the same content-keyed name.
+            // Losing it is fine: the winner staged the identical bytes.
+        }
+    }
+    let refilledFileCount = 0;
+    await ensurePrivateDir(path.join(evidenceDir, "files"));
+    for (const entry of options.entries) {
+        if (!entry.staged_in_pack)
+            continue;
+        const fileName = path.basename(entry.local_path);
+        const target = path.join(evidenceDir, "files", fileName);
+        const info = await fs.stat(target).catch(() => null);
+        if (info?.isFile() && info.size === entry.byte_size)
+            continue;
+        await fs.copyFile(entry.local_path, target).catch(() => undefined);
+        await chmodPrivate(target, 0o600);
+        refilledFileCount += 1;
+    }
+    await fs.rm(options.stagingDir, { recursive: true, force: true }).catch(() => undefined);
+    return {
+        state: refilledFileCount > 0 ? "restaged_incomplete" : "reused",
+        evidenceDir,
+        priorPackCount,
+        refilledFileCount,
+    };
+}
+async function countPriorPacks(rawEvidenceRoot, workContextId, packId) {
+    const entries = await fs
+        .readdir(rawEvidenceRoot, { withFileTypes: true })
+        .catch(() => []);
+    return entries.filter((entry) => entry.isDirectory() &&
+        entry.name !== packId &&
+        entry.name.startsWith(`${workContextId}-`)).length;
+}
+/**
+ * Write the manifest, or keep the one already in a reused pack.
+ *
+ * Byte-stability matters here: the manifest's object key is the only key that
+ * embeds the pack id, so rewriting it with a fresh `created_at` every sync
+ * would push different bytes at the same content-addressed key forever. A
+ * reused pack whose manifest already describes exactly these files keeps it.
+ */
+async function stageManifest(options) {
+    if (options.reusePack) {
+        const existing = await fs.readFile(options.manifestPath).catch(() => null);
+        if (existing && manifestDescribesEntries(existing, options.entries)) {
+            return existing;
+        }
+    }
+    const manifestBytes = Buffer.from(`${JSON.stringify(makeManifest({
+        context: options.context,
+        packId: options.packId,
+        entries: options.entries,
+        skipped: options.skipped,
+        redacted: options.redacted,
+        reused: options.reused,
+    }), null, 2)}\n`, "utf8");
+    await fs.writeFile(options.manifestPath, manifestBytes, { mode: 0o600 });
+    await chmodPrivate(options.manifestPath, 0o600);
+    return manifestBytes;
+}
+function manifestDescribesEntries(manifestBytes, entries) {
+    try {
+        const parsed = JSON.parse(manifestBytes.toString("utf8"));
+        const recorded = (parsed.files ?? [])
+            .map((file) => typeof file.content_hash_sha256 === "string"
+            ? file.content_hash_sha256
+            : "")
+            .filter(Boolean)
+            .sort();
+        const expected = entries
+            .map((entry) => entry.content_hash_sha256)
+            .sort();
+        return (recorded.length === expected.length &&
+            recorded.every((hash, index) => hash === expected[index]));
+    }
+    catch {
+        return false;
+    }
+}
+async function persistStagingState(stateDir, collection) {
+    collection.staging.updated_at = collection.context.now.toISOString();
+    await writeRawEvidenceStagingState(stateDir, collection.staging).catch((error) => {
+        // Losing this file costs reuse and attempt counts, not evidence, so it
+        // must never fail a collection — but it must never be silent either.
+        console.error("[raw-evidence] staging state write failed", JSON.stringify({
+            reason: "staging_state_write_failed",
+            detail: error instanceof Error ? error.name : typeof error,
+            staged_count: Object.keys(collection.staging.staged).length,
+        }));
+    });
 }
 function shortHash(value) {
     return crypto.createHash("sha256").update(value, "utf8").digest("hex").slice(0, 12);

package/dist/commands/local.js

@@ -20,7 +20,7 @@ import { collectionRootPathAliases, discoverGitWorktreesInRootsWithStatus, } fro
 import { resolveDiscoveryLimits, saveDiscoveryLimits, } from "../discovery-limits.js";
 import { runAttributedWorktreeSync, matchesLiveSyncWorktree, } from "./session-sync.js";
 import { COLLECTION_ROOT_REQUIRED, missingCollectionRootMessage, normalizeRootsDetailed, resolveOnboardingRoots, rootRejectionExplanation, } from "../onboarding-roots.js";
-import { rawEvidenceGcSummary, runRawEvidenceLocalGc, } from "../raw-evidence-gc.js";
+import { rawEvidenceDedupSummary, rawEvidenceGcSummary, runRawEvidenceLocalGc, sweepDuplicateStagedRawEvidence, } from "../raw-evidence-gc.js";
 import { envWithNodeRuntimeOnPath, runScheduledSelfUpdate, } from "../scheduled-self-update.js";
 import { runAutostartSelfHeal, } from "../autostart-self-heal.js";
 import { enqueueInstallEventEntry, readPendingInstallEventEntries, recordInstallEventAttemptFailure, removeInstallEventEntry, } from "../spool/install-event-outbox.js";
@@ -1808,7 +1808,16 @@ function rawEvidenceSyncLine(sync) {
     const retries = sync.raw_evidence_retry_reasons.length > 0
         ? ` retry_required: ${sync.raw_evidence_retry_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}${retries}`;
+    // A held object and a nine-day-old first failure both belong on this line.
+    // Neither used to appear anywhere, which is how a 1,030-attempt loop stayed
+    // invisible (BLI-3066).
+    const held = sync.raw_evidence_delivery_held_count > 0
+        ? ` held: ${sync.raw_evidence_delivery_held_count}`
+        : "";
+    const stuck = sync.raw_evidence_stuck_object_count > 0
+        ? ` stuck: ${sync.raw_evidence_stuck_object_count} (worst ${sync.raw_evidence_max_delivery_attempts} attempt(s) since ${sync.raw_evidence_oldest_delivery_failure_at ?? "unknown"})`
+        : "";
+    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}${held}${stuck}${failures}${retries}`;
 }
 function cursorStatusLine(sync) {
     return `Cursor: ${sync.cursor_tracked_object_count} durable object(s) tracked`;
@@ -2488,6 +2497,15 @@ function syncResult(run) {
 }
 async function runSyncLocked(command, io) {
     const collectionRoots = await resolveSyncCollectionRoots(command);
+    // Before anything is collected: collapse byte-identical staged packs. It runs
+    // first, unconditionally and unthrottled, because a machine that already
+    // holds 559 copies of one rollout needs the disk back before it stages
+    // anything else (BLI-3066). Safe by construction — a duplicate is identical
+    // by content hash to the survivor.
+    const dedup = await sweepDuplicateStagedRawEvidence(getCollectorRuntimePaths(command.homeDir), io.env);
+    if (!dedup.skipped && dedup.removed_dirs > 0) {
+        writeLine(io.stdout, rawEvidenceDedupSummary(dedup));
+    }
     const worktrees = await discoverCommandWorktrees(collectionRoots, {
         maxDepth: command.maxDepth,
         maxRepos: command.maxRepos,
@@ -2515,6 +2533,7 @@ async function runSyncLocked(command, io) {
                 repos: rows,
                 codex_sessions: run.summary,
                 raw_evidence_gc: gc,
+                raw_evidence_dedup: dedup,
             }, null, 2));
             return syncResult(run);
         }
@@ -2546,6 +2565,7 @@ async function runSyncLocked(command, io) {
                 collection_complete: run.ok,
                 codex_sessions: run.summary,
                 raw_evidence_gc: gc,
+                raw_evidence_dedup: dedup,
             }, null, 2));
             return syncResult(run);
         }
@@ -2568,6 +2588,7 @@ async function runSyncLocked(command, io) {
             collection_complete: run.ok,
             codex_sessions: run.summary,
             raw_evidence_gc: gc,
+            raw_evidence_dedup: dedup,
         }, null, 2));
         return syncResult(run);
     }
@@ -2801,10 +2822,20 @@ async function runStatus(command, io) {
     writeLine(io.stdout, `pending_health_receipts: ${status.pending_health_receipt_count}`);
     writeLine(io.stdout, `last_health_receipt_failure: ${status.last_health_receipt_failure_reason ?? "none"}`);
     writeLine(io.stdout, `backfill: ${backfillCursorLine(backfillCursor)}`);
+    writeLine(io.stdout, `stuck_evidence: ${stuckEvidenceLine(status)}`);
     for (const detail of status.details)
         writeLine(io.stdout, `- ${detail}`);
     return 0;
 }
+/**
+ * One line that cannot say "fine" while an object has never been accepted.
+ * Named reasons, worst attempt count, and the date it started.
+ */
+function stuckEvidenceLine(status) {
+    if (status.stuck_evidence_object_count === 0)
+        return "none";
+    return `${status.stuck_evidence_object_count} object(s), ${status.stuck_evidence_held_count} held, worst ${status.stuck_evidence_max_attempts} attempt(s) since ${status.stuck_evidence_oldest_failure_at ?? "unknown"} (${status.stuck_evidence_reasons.join(",") || "unknown"})`;
+}
 function displayTicketId(ticketId) {
     return ticketId ?? "general ambient";
 }

package/dist/commands/public-root.js

@@ -15,7 +15,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.27");
+    writeLine(io?.stdout ?? process.stdout, "0.2.28");
     return 0;
   }
 

package/dist/local-state.js

@@ -8,6 +8,7 @@ import { normalizeGitOrigin, repoFingerprintFromLocalRoot, repoFingerprintFromOr
 import { isSamePath, normalizeCollectionRoots, } from "./root-normalization.js";
 import { summarizeLocalUploadSpool } from "./spool/local-spool.js";
 import { summarizeInstallEventOutbox } from "./spool/install-event-outbox.js";
+import { readRawEvidenceStagingState, summarizeStuckEvidence, } from "./raw-evidence-staging.js";
 const localCollectorPackage = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 export const LOCAL_COLLECTOR_VERSION = typeof localCollectorPackage.version === "string"
     ? localCollectorPackage.version
@@ -340,10 +341,12 @@ export async function inspectLocalCollectorStatus(options = {}) {
     const identity = await resolveIdentityOrFallback(repoRoot, options.branch);
     const context = await readLocalWorkContextForRepo(paths, repoRoot).catch(() => null);
     const branch = options.branch ?? identity.branch;
-    const [uploadSpool, healthOutbox] = await Promise.all([
+    const [uploadSpool, healthOutbox, stagingState] = await Promise.all([
         summarizeLocalUploadSpool(paths),
         summarizeInstallEventOutbox(paths),
+        readRawEvidenceStagingState(paths.state_dir),
     ]);
+    const stuckEvidence = summarizeStuckEvidence(stagingState, now);
     const freshness = classifyCollectorFreshness(context, uploadSpool.last_upload_success_at, now);
     const uploadState = !config
         ? "not_installed"
@@ -377,6 +380,9 @@ export async function inspectLocalCollectorStatus(options = {}) {
     if (healthOutbox.pending_count > 0) {
         details.push(`Collector health retry pending: ${healthOutbox.pending_count} sanitized receipt(s) queued since ${healthOutbox.oldest_created_at ?? "unknown"}.`);
     }
+    if (stuckEvidence.stuck_object_count > 0) {
+        details.push(`Raw evidence stuck: ${stuckEvidence.stuck_object_count} object(s) have never been accepted (${stuckEvidence.held_object_count} waiting on backoff, worst ${stuckEvidence.max_attempts} attempt(s) since ${stuckEvidence.oldest_first_failed_at ?? "unknown"}) — reasons: ${stuckEvidence.reasons.join(", ") || "unknown"}.`);
+    }
     return {
         installed: Boolean(config),
         config_file: paths.config_file,
@@ -405,6 +411,11 @@ export async function inspectLocalCollectorStatus(options = {}) {
         pending_health_receipt_count: healthOutbox.pending_count,
         oldest_pending_health_receipt_at: healthOutbox.oldest_created_at,
         last_health_receipt_failure_reason: healthOutbox.last_failure_reason,
+        stuck_evidence_object_count: stuckEvidence.stuck_object_count,
+        stuck_evidence_held_count: stuckEvidence.held_object_count,
+        stuck_evidence_max_attempts: stuckEvidence.max_attempts,
+        stuck_evidence_oldest_failure_at: stuckEvidence.oldest_first_failed_at,
+        stuck_evidence_reasons: stuckEvidence.reasons,
         details,
     };
 }