@bli-cockpit/cli 0.2.266 → 0.2.268

package/dist/adapters/pinned-transcript.js

@@ -0,0 +1,143 @@
+/**
+ * A transcript opened ONCE, its length pinned, read as byte lines by both passes and by the describe
+ * step's payload reads (BLI-23317, stage D).
+ *
+ * The census records where each image sits in THIS file's bytes, and the swap pass and the describe
+ * request read those very offsets later, so every read must come from the same bytes. Therefore:
+ *
+ *  - the file is opened once and the length is the descriptor's size at that moment; nothing past it
+ *    is ever read, so a live session appending meanwhile cannot move an offset;
+ *  - every read goes through that descriptor (a rename over the path leaves this snapshot intact);
+ *  - at the end `verifyUnchanged` asks the descriptor again. A file that got SHORTER, or that kept its
+ *    size and changed its mtime (rewritten in place), is `file_changed_during_pass`: the caller sets the
+ *    streamed result aside and the next tick builds it again. A file that only GREW is an append, and
+ *    the bytes below the pinned length are the bytes the passes saw, so it stands (and is logged).
+ *
+ * Lines are split at 0x0a on bytes, which is the same cut as splitting the decoded text at "\n" for
+ * valid UTF-8 (the byte never occurs inside a multi-byte character). Each line is a view into the read
+ * buffer where it fits in one chunk, and a fresh copy where it spans chunks: a view is valid until the
+ * generator is asked for the next line, so a consumer must not keep one.
+ *
+ * Failure vocabulary matches `transcript-text-stream.ts`: a read that fails is a `TranscriptReadError`
+ * (never a short file), a file over the cap is `TranscriptTooLargeError`.
+ */
+import fsp from "node:fs/promises";
+import { describeError } from "../health-detail.js";
+import { TranscriptNotStreamable, TranscriptReadError, TranscriptTooLargeError } from "./transcript-text-stream.js";
+const TAG = "[pinned-transcript]";
+const NEWLINE = 0x0a;
+/** Bytes per read step into one reused buffer. */
+export const PINNED_CHUNK_BYTES = 256 * 1024;
+export async function openPinnedTranscript(filePath, options = {}) {
+    let handle;
+    try {
+        handle = await fsp.open(filePath, "r");
+        const first = await handle.stat();
+        if (options.maxFileBytes && first.size > options.maxFileBytes) {
+            await handle.close().catch(() => undefined);
+            handle = undefined;
+            console.error(TAG + " transcript over the file cap, nothing read", JSON.stringify({ reason: "file_too_large", byte_size: first.size, max_file_bytes: options.maxFileBytes }));
+            throw new TranscriptTooLargeError(options.maxFileBytes);
+        }
+        return pinned(handle, first.size, first.mtimeMs);
+    }
+    catch (error) {
+        if (error instanceof TranscriptTooLargeError)
+            throw error;
+        await handle?.close().catch(() => undefined);
+        console.error(TAG + " transcript could not be opened", JSON.stringify({ reason: "file_read_failed", stage: "open", ...describeError(error) }));
+        throw new TranscriptReadError("open", error);
+    }
+}
+function pinned(handle, length, mtimeMs) {
+    let closed = false;
+    const readFailed = (stage, bytesRead, error) => {
+        console.error(TAG + " transcript could not be read to its end", JSON.stringify({ reason: "file_read_failed", stage, bytes_read: bytesRead, ...describeError(error) }));
+        throw new TranscriptReadError(stage, error);
+    };
+    async function* lines() {
+        if (length === 0) {
+            yield { start: 0, bytes: Buffer.alloc(0) };
+            return;
+        }
+        const chunk = Buffer.allocUnsafe(PINNED_CHUNK_BYTES);
+        let held = [];
+        let heldBytes = 0;
+        let lineStart = 0;
+        for (let position = 0; position < length;) {
+            let bytesRead;
+            try {
+                ({ bytesRead } = await handle.read(chunk, 0, Math.min(PINNED_CHUNK_BYTES, length - position), position));
+            }
+            catch (error) {
+                return readFailed("stream", position, error);
+            }
+            if (bytesRead === 0)
+                throw new TranscriptNotStreamable("file_changed_during_pass");
+            position += bytesRead;
+            const view = chunk.subarray(0, bytesRead);
+            let from = 0;
+            for (let newline = view.indexOf(NEWLINE, from); newline !== -1; newline = view.indexOf(NEWLINE, from)) {
+                const piece = view.subarray(from, newline);
+                const bytes = heldBytes === 0 ? piece : Buffer.concat([...held, piece], heldBytes + piece.length);
+                held = [];
+                heldBytes = 0;
+                yield { start: lineStart, bytes };
+                lineStart += bytes.length + 1;
+                from = newline + 1;
+            }
+            if (from < bytesRead) {
+                held.push(Buffer.from(view.subarray(from)));
+                heldBytes += bytesRead - from;
+            }
+        }
+        yield { start: lineStart, bytes: heldBytes === 0 ? Buffer.alloc(0) : Buffer.concat(held, heldBytes) };
+    }
+    return {
+        length,
+        lines,
+        async read(offset, size) {
+            const buffer = Buffer.allocUnsafe(size);
+            let done = 0;
+            while (done < size) {
+                let bytesRead;
+                try {
+                    ({ bytesRead } = await handle.read(buffer, done, size - done, offset + done));
+                }
+                catch (error) {
+                    return readFailed("range", offset + done, error);
+                }
+                if (bytesRead === 0)
+                    throw new TranscriptNotStreamable("file_changed_during_pass");
+                done += bytesRead;
+            }
+            return buffer;
+        },
+        async verifyUnchanged() {
+            let now;
+            try {
+                now = await handle.stat();
+            }
+            catch (error) {
+                return readFailed("verify", length, error);
+            }
+            if (now.size < length || (now.size === length && now.mtimeMs !== mtimeMs)) {
+                console.error(TAG + " transcript changed while it was being prepared, set aside for the next tick", JSON.stringify({
+                    reason: "file_changed_during_pass", pinned_bytes: length, bytes_now: now.size, mtime_changed: now.mtimeMs !== mtimeMs,
+                }));
+                throw new TranscriptNotStreamable("file_changed_during_pass");
+            }
+            if (now.size > length) {
+                console.error(TAG + " transcript grew while it was being prepared; the pinned bytes stand", JSON.stringify({ reason: "source_grew_during_prepare", pinned_bytes: length, bytes_now: now.size }));
+            }
+        },
+        async close() {
+            if (closed)
+                return;
+            closed = true;
+            await handle.close().catch((error) => {
+                console.error(TAG + " file handle did not close", JSON.stringify({ reason: "file_close_failed", ...describeError(error) }));
+            });
+        },
+    };
+}

package/dist/adapters/raw-evidence-budget-admission.js

@@ -1,5 +1,5 @@
 import { terminalDeliveryReason } from "../raw-evidence-staging.js";
-import { admitToStaging } from "../staging-gate.js";
+import { admitToStaging, roomToStageUpTo } from "../staging-gate.js";
 /**
  * The one door a file passes before its bytes may be copied: the per-sync
  * budget below, then the disk (BLI-12832). A refusal from the disk hands the
@@ -34,6 +34,23 @@ export function admitEvidence(collection, byteLength, file) {
     refundBudget(collection.budget, charged);
     return `staging_deferred:${diskReason}`;
 }
+/** The budget's refusal for a file of this size, with nothing charged or counted: the rule `admitToBudget` applies. */
+function budgetDeferralReason(budget, byteLength) {
+    const single = budget.singleFileByteAllowance;
+    const firstLargeFile = single && budget.remainingBytes === single.normalBytes &&
+        byteLength <= single.maxFileBytes;
+    return budget.remainingObjects <= 0 ? "deferred_object_budget" :
+        byteLength > 0 && byteLength > budget.remainingBytes && !firstLargeFile ? "deferred_byte_budget" : null;
+}
+/**
+ * May the streamed transcript pass write its output to staging while it makes it (BLI-23317 stage D)? The
+ * real admission needs the finished size and hash, so this asks ahead, read-only, with the source file's
+ * size as the bound: the per-sync budget, then the disk gate. A refusal returns its label and the pass
+ * writes nothing; the ordinary admission then refuses the file exactly as before. No refusal returns null.
+ */
+export function roomToStreamToStaging(collection, byteLength) {
+    return budgetDeferralReason(collection.budget, byteLength) ?? roomToStageUpTo(collection.budget.staging, byteLength);
+}
 /** Hands back one admission that a later gate refused, so nothing was staged and nothing counts as sent. */
 function refundBudget(budget, byteLength) {
     budget.remainingObjects += 1;
@@ -47,11 +64,7 @@ function refundBudget(budget, byteLength) {
  * budget bounds buffered bytes.
  */
 export function admitToBudget(budget, byteLength) {
-    const single = budget.singleFileByteAllowance;
-    const firstLargeFile = single && budget.remainingBytes === single.normalBytes &&
-        byteLength <= single.maxFileBytes;
-    const reason = budget.remainingObjects <= 0 ? "deferred_object_budget" :
-        byteLength > 0 && byteLength > budget.remainingBytes && !firstLargeFile ? "deferred_byte_budget" : null;
+    const reason = budgetDeferralReason(budget, byteLength);
     if (reason) {
         [budget.deferredObjects, budget.deferredBytes] = [(budget.deferredObjects ?? 0) + 1, (budget.deferredBytes ?? 0) + byteLength];
         return reason;

package/dist/adapters/raw-evidence-manifest.js

@@ -4,7 +4,10 @@ import { remoteObjectKey, sha256 } from "./raw-evidence-keys.js";
 export const RAW_EVIDENCE_BUCKET = "ambient-raw-evidence";
 export const RAW_EVIDENCE_RETENTION_MODE = "remote_durable";
 export function evidenceEntry(options) {
-    const digest = sha256(options.bytes);
+    const content = Buffer.isBuffer(options.bytes)
+        ? { sha256: sha256(options.bytes), byteLength: options.bytes.byteLength }
+        : options.bytes;
+    const digest = content.sha256;
     const objectKey = remoteObjectKey({
         context: options.context,
         packId: options.packId,
@@ -17,7 +20,7 @@ export function evidenceEntry(options) {
         relative_path: options.relativePath,
         object_key: objectKey,
         content_hash_sha256: digest,
-        byte_size: options.bytes.byteLength,
+        byte_size: content.byteLength,
         media_type: options.mediaType,
         redacted_summary: options.redactedSummary,
         ...(options.redaction ? { redaction: options.redaction } : {}),
@@ -34,7 +37,7 @@ export function evidenceEntry(options) {
                     storage_bucket: RAW_EVIDENCE_BUCKET,
                     object_key: objectKey,
                     content_hash_sha256: digest,
-                    byte_size: options.bytes.byteLength,
+                    byte_size: content.byteLength,
                 },
             }
             : {}),

package/dist/adapters/raw-evidence-sanitize-held.js

@@ -1,6 +1,16 @@
 import { containsSecretLikeContent, redactSecretLikeContent, scannedCleanRedactionMetadata, } from "@bli-cockpit/telemetry-core";
 import { createHash } from "node:crypto";
 import { WHOLE_FILE_MASK_LINE, fallbackRedactionMetadata, logRedactionCrash, maskSecretBearingLines, } from "./raw-evidence-sanitize.js";
+/** What `scannedCleanRedactionMetadata` gives for these bytes, from their hash and size (the same record, key for key). */
+function scannedCleanFromFacts(facts) {
+    return {
+        ...scannedCleanRedactionMetadata(Buffer.alloc(0)),
+        original_content_hash_sha256: facts.sha256,
+        sanitized_content_hash_sha256: facts.sha256,
+        original_byte_size: facts.byteLength,
+        sanitized_byte_size: facts.byteLength,
+    };
+}
 /** Code units per encode window: 4 Mi units encode to at most 12 MiB, and the window is garbage right after. */
 const WINDOW_UNITS = 4 * 1024 * 1024;
 /**
@@ -28,16 +38,14 @@ function isHighSurrogate(unit) {
 function isLowSurrogate(unit) {
     return unit >= 0xdc00 && unit <= 0xdfff;
 }
-/**
- * Same decision table as `sanitizeTextEvidenceForUpload`. The holder's text is cleared before the
- * bytes of the answer are built, so the answer is the only large thing left alive when this returns.
- */
 export function sanitizeHeldTextForUpload(held, options) {
     // No local in this frame points at the text: only `held` does, so clearing it frees the transcript.
     let facts;
+    const { staged } = held;
     const scan = {
         textLength: held.text.length,
-        facts: () => (facts ??= held.exactBytes ? { sha256: sha256Of(held.exactBytes), byteLength: held.exactBytes.byteLength } : factsOfText(held.text)),
+        // Staged bytes were hashed as they were written, so the original's hash and size cost nothing here.
+        facts: () => (facts ??= staged ? { sha256: staged.sha256, byteLength: staged.byteLength } : held.exactBytes ? { sha256: sha256Of(held.exactBytes), byteLength: held.exactBytes.byteLength } : factsOfText(held.text)),
         exactBytes: held.exactBytes,
         redactedFields: options.redactedFields,
         secretLikeFileName: options.secretLikeFileName === true,
@@ -55,6 +63,10 @@ export function sanitizeHeldTextForUpload(held, options) {
         }
         if (found.attempt.redacted)
             return keepDeterministicRedaction(held, scan, found.attempt);
+        if (staged) {
+            held.text = null;
+            return { status: "clean", staged, redaction: scannedCleanFromFacts(staged) };
+        }
         const bytes = held.exactBytes ?? Buffer.from(held.text, "utf8");
         held.text = null;
         return { status: "clean", bytes, redaction: scannedCleanRedactionMetadata(bytes) };
@@ -164,10 +176,6 @@ function stubForCrashedRedaction(scan, facts) {
         completenessLabel: "redaction_crashed_stubbed",
     };
 }
-/**
- * Mask secret-like values in a transcript and record that it happened (see `maskSecretsInTranscript`
- * in raw-evidence-sanitize.ts, whose answer this one matches), from text the caller holds once.
- */
 export function maskSecretsInHeldTranscript(collection, held, options) {
     const sanitized = sanitizeHeldTextForUpload(held, {
         redactedFields: [`${options.kind}.body`],

package/dist/adapters/raw-evidence-snapshot-supersede.js

@@ -20,8 +20,9 @@
  * says so: `snapshot_rewritten`, both sizes, and the byte range the first
  * difference falls in. Never content.
  */
+import { createReadStream } from "node:fs";
 import { REDACTION_STUB_LABEL } from "@bli-cockpit/telemetry-core";
-import { firstDifferenceRange, isPrefixSuccessor, prefixCheckpoints, } from "@bli-cockpit/telemetry-core/snapshot-supersede";
+import { firstDifferenceRange, isPrefixSuccessor, prefixCheckpoints, prefixDigestsFromStream, } from "@bli-cockpit/telemetry-core/snapshot-supersede";
 /**
  * The newest committed snapshot per source key, from the cursor's objects map,
  * restricted to objects this work context owns (the server refuses a claim
@@ -57,30 +58,79 @@ export function describeSnapshot(bytes) {
  * decide and says nothing.
  */
 export function supersedeClaimFor(options) {
+    return decideClaim({ contentHash: options.contentHash, kind: options.kind, byteSize: options.bytes.byteLength, prior: options.prior }, (prior) => isPrefixSuccessor(options.bytes, prior), (prior) => firstDifferenceRange(options.bytes, prior));
+}
+/** The decision and its log, shared by the in-memory and the on-disk forms so they cannot drift. */
+function decideClaim(options, isPrefix, differenceRange) {
     const { prior } = options;
     if (!prior || prior.content_hash_sha256 === options.contentHash)
         return null;
-    if (isPrefixSuccessor(options.bytes, prior)) {
+    if (isPrefix(prior)) {
         console.error("[evidence-upload] snapshot supersedes the previous one", JSON.stringify({
             reason: "snapshot_supersede_claimed",
             rule: "prefix",
             kind: options.kind,
             previous_byte_size: prior.byte_size,
-            byte_size: options.bytes.byteLength,
+            byte_size: options.byteSize,
         }));
         return { pointer_id: prior.raw_evidence_pointer_id, rule: "prefix" };
     }
-    const range = firstDifferenceRange(options.bytes, prior);
+    const range = differenceRange(prior);
     console.error("[evidence-upload] snapshot rewritten, keeping both", JSON.stringify({
         reason: "snapshot_rewritten",
         kind: options.kind,
         previous_byte_size: prior.byte_size,
-        byte_size: options.bytes.byteLength,
+        byte_size: options.byteSize,
         first_differing_offset_at_least: range.at_least,
         first_differing_offset_below: range.below,
     }));
     return null;
 }
+/**
+ * `describeSnapshot` and `supersedeClaimFor` for bytes that live in a file (BLI-23317 stage D): ONE
+ * streamed pass over the file yields every prefix digest either needs (`prefixDigestsFromStream`, one
+ * chunk and a hash state in memory), then the same decision runs on them. `claim` false skips the
+ * claim (a stub-replacement claim wins over a prefix claim and never reads the prior).
+ */
+export async function describeStagedSnapshot(options) {
+    const { byteLength, prior } = options;
+    const checkpointOffsets = [];
+    for (let at = 64; at < byteLength; at *= 2)
+        checkpointOffsets.push(at);
+    const wantClaim = options.claim && prior !== undefined && prior.content_hash_sha256 !== options.contentHash;
+    const priorOffsets = wantClaim
+        ? [prior.byte_size, ...Object.keys(prior.checkpoints ?? {}).map(Number)].filter((at) => at > 0 && at <= Math.min(prior.byte_size, byteLength))
+        : [];
+    const result = await prefixDigestsFromStream(createReadStream(options.filePath, { highWaterMark: 1024 * 1024 }), [...checkpointOffsets, ...priorOffsets]);
+    if (result.total_bytes !== byteLength) {
+        // The staged file is not the bytes that were hashed: a claim made on it would be a lie.
+        console.error("[evidence-upload] staged file size differs from what was written; no claim", JSON.stringify({
+            reason: "staged_size_mismatch", expected_bytes: byteLength, found_bytes: result.total_bytes, kind: options.kind,
+        }));
+        throw new Error("staged_size_mismatch");
+    }
+    const checkpoints = {};
+    for (const at of checkpointOffsets)
+        checkpoints[String(at)] = result.digests.get(at).slice(0, 16);
+    const supersedes = wantClaim
+        ? decideClaim({ contentHash: options.contentHash, kind: options.kind, byteSize: byteLength, prior }, (known) => known.byte_size > 0 && known.byte_size < byteLength && result.digests.get(known.byte_size) === known.content_hash_sha256, (known) => {
+            const limit = Math.min(known.byte_size, byteLength);
+            let atLeast = 0;
+            let below = limit;
+            const offsets = Object.keys(known.checkpoints ?? {}).map(Number).filter((at) => at <= limit).sort((a, b) => a - b);
+            for (const at of offsets) {
+                if (result.digests.get(at)?.slice(0, 16) === known.checkpoints[String(at)])
+                    atLeast = at;
+                else {
+                    below = at;
+                    break;
+                }
+            }
+            return { at_least: atLeast, below };
+        })
+        : null;
+    return { snapshot: { checkpoints }, supersedes };
+}
 /**
  * BLI-11102: the claim a re-offered transcript makes when the server named its
  * stored copy a redaction-crash stub. Only a main transcript that redacted

package/dist/adapters/raw-evidence-stage-file.js

@@ -0,0 +1,43 @@
+/**
+ * Publish a transcript whose bytes are ALREADY a file (BLI-23317 stage D): the `.partial` the streamed
+ * pass wrote and hashed. The twin of `stageEvidenceBytes` for bytes that were never held in memory.
+ *
+ * Same contract: content an earlier sync already staged is adopted (the partial is dropped), a new
+ * object lands under its final name only by rename, so the manifest never points at a truncated file,
+ * and a failure leaves no partial behind.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { describeError } from "../health-detail.js";
+import { resolveStagedObject } from "../raw-evidence-staging.js";
+import { chmodPrivate } from "./raw-evidence-pack-store.js";
+import { discardStagedOutput } from "./staged-output.js";
+export async function stageEvidenceFile(collection, options) {
+    const { staged } = options;
+    const existing = await resolveStagedObject(collection.rawEvidenceRoot, collection.staging, staged.sha256);
+    if (existing) {
+        collection.stagedReusedCount += 1;
+        console.error("[raw-evidence] staged copy reused", JSON.stringify({
+            reason: "staged_reused",
+            kind: options.kind,
+            content_hash_prefix: staged.sha256.slice(0, 16),
+            byte_size: existing.entry.byte_size,
+            pack_id: existing.entry.pack_id,
+        }));
+        await discardStagedOutput(staged, "staged_copy_reused");
+        return { local_path: existing.local_path, staged_in_pack: false };
+    }
+    const destination = path.join(collection.filesDir, options.fileName);
+    try {
+        await chmodPrivate(staged.path, 0o600);
+        await fs.rename(staged.path, destination);
+    }
+    catch (error) {
+        await fs.rm(staged.path, { force: true }).catch(() => undefined);
+        console.error("[raw-evidence] staging write failed, nothing was published", JSON.stringify({ reason: "staging_write_failed", kind: options.kind, byte_size: staged.byteLength, ...describeError(error) }));
+        throw error;
+    }
+    collection.stagedNewCount += 1;
+    console.error("[raw-evidence] staged partial published", JSON.stringify({ reason: "staged_published", kind: options.kind, byte_size: staged.byteLength }));
+    return { local_path: destination, staged_in_pack: true };
+}

package/dist/adapters/raw-evidence-transcript-body.js

@@ -12,6 +12,7 @@
 import { isUtf8 } from "node:buffer";
 import { mightHoldEmbeddedImages } from "@bli-cockpit/telemetry-core";
 import { describeError } from "../health-detail.js";
+import { roomToStreamToStaging } from "./raw-evidence-budget-admission.js";
 import { readTranscriptWhole, streamTranscriptBody, volatilityOf } from "./raw-evidence-transcript-stream.js";
 /** Which agent's transcript rules apply to this evidence kind; null for anything the image step does not know. */
 export function agentOfKind(kind) {
@@ -41,7 +42,13 @@ export async function prepareTranscriptBody(collection, file) {
     const session = collection.budget.images;
     const agent = agentOfKind(file.kind);
     if (file.source.stream) {
-        const streamed = await streamTranscriptBody(session, agent, { ...file.source.stream, sessionId: file.sessionId, kind: file.kind });
+        // BLI-23317 stage D: the slimmed bytes are written to this pack's `files` directory as they are made,
+        // but only when the budget and the disk gate would admit a file of the source's size: never a byte ahead of the gate.
+        const refusal = roomToStreamToStaging(collection, file.source.stream.inputBytes ?? 0);
+        if (refusal) {
+            console.error("[raw-evidence] streamed output is not written ahead of the staging gate", JSON.stringify({ reason: "stream_to_staging_declined", gate: refusal, kind: file.kind, input_bytes: file.source.stream.inputBytes ?? null }));
+        }
+        const streamed = await streamTranscriptBody(session, agent, { ...file.source.stream, sessionId: file.sessionId, kind: file.kind, stageDir: refusal ? undefined : collection.filesDir });
         if (streamed) {
             file.source.readBytes = streamed.readBytes;
             return { held: streamed.held, volatile: streamed.volatile, pendingImages: streamed.pendingImages };

package/dist/adapters/raw-evidence-transcript-file.js

@@ -20,16 +20,17 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { describeError } from "../health-detail.js";
 import { DELIVERY_BACKOFF_HOLDING_REASON, evidenceSourceKey, } from "../raw-evidence-staging.js";
-import { isSecretLikePath, sha256, shortHash, } from "./raw-evidence-keys.js";
+import { isSecretLikePath, sha256, } from "./raw-evidence-keys.js";
 import { maskSecretsInHeldTranscript } from "./raw-evidence-sanitize-held.js";
+import { discardStagedOutput } from "./staged-output.js";
+import { byteLengthOf, dropStagedBody, stageOneTranscript } from "./raw-evidence-transcript-stage.js";
 import { agentOfKind, prepareTranscriptBody } from "./raw-evidence-transcript-body.js";
 import { TranscriptReadError, TranscriptTooLargeError } from "./transcript-text-stream.js";
 import { markBudgetCapApplied, markCapApplied, } from "./raw-evidence-completeness.js";
-import { evidenceEntry } from "./raw-evidence-manifest.js";
 import { prepareRecipe, statSourceForMemo, } from "./raw-evidence-prepare-memo.js";
 import { logVolatileReuse, trustVolatileEntry } from "./raw-evidence-volatile-reuse.js";
-import { describeSnapshot, stubReplacementClaim, supersedeClaimFor, } from "./raw-evidence-snapshot-supersede.js";
-import { admitEvidence, stageEvidenceBytes, } from "./raw-evidence-collection-state.js";
+import { stubReplacementClaim } from "./raw-evidence-snapshot-supersede.js";
+import { admitEvidence, } from "./raw-evidence-collection-state.js";
 /**
  * Reads, secret-guards, content-addresses, budget-checks, and copies one
  * attributed transcript into the pack.
@@ -80,31 +81,41 @@ export async function collectOneEvidenceFile(collection, options) {
         throw error;
     }
     const { sanitized, contentHash, stubClaim, volatile, pendingImages, redactedEntry } = prepared;
-    await rememberPreparedTranscript(collection, options, names, {
-        stamp, recipe, readBytes: read.source.readBytes ?? read.byteLength, contentHash, byteSize: sanitized.bytes.byteLength, volatile, pendingImages, redactedEntry,
-    });
-    if (collection.skipContentHashes.has(contentHash) && !stubClaim) {
-        collection.reused.push({
-            kind: options.kind,
-            label: names.evidenceLabel,
-            content_hash_sha256: contentHash,
-            codex_session_id: options.sessionId,
+    const byteSize = byteLengthOf(sanitized);
+    try {
+        await rememberPreparedTranscript(collection, options, names, {
+            stamp, recipe, readBytes: read.source.readBytes ?? read.byteLength, contentHash, byteSize, volatile, pendingImages, redactedEntry,
+        });
+        if (collection.skipContentHashes.has(contentHash) && !stubClaim) {
+            await dropStagedBody(sanitized, "content_already_durable");
+            collection.reused.push({
+                kind: options.kind,
+                label: names.evidenceLabel,
+                content_hash_sha256: contentHash,
+                codex_session_id: options.sessionId,
+            });
+            return true;
+        }
+        const deferReason = admitEvidence(collection, byteSize, { contentHash, kind: options.kind });
+        if (deferReason) {
+            await dropStagedBody(sanitized, deferReason);
+            markBudgetCapApplied(collection, deferReason);
+            return skip(deferReason);
+        }
+        await stageOneTranscript(collection, {
+            ...options,
+            names,
+            sanitized,
+            contentHash,
+            stubClaim,
         });
         return true;
     }
-    const deferReason = admitEvidence(collection, sanitized.bytes.byteLength, { contentHash, kind: options.kind });
-    if (deferReason) {
-        markBudgetCapApplied(collection, deferReason);
-        return skip(deferReason);
+    catch (error) {
+        // A streamed partial is deleted whatever stopped the file (a no-op once it was published or discarded).
+        await dropStagedBody(sanitized, "collect_failed");
+        throw error;
     }
-    await stageOneTranscript(collection, {
-        ...options,
-        names,
-        sanitized,
-        contentHash,
-        stubClaim,
-    });
-    return true;
 }
 function recordEvidenceSkip(collection, kind, label, reason) {
     collection.skipped.push({ kind, label, reason });
@@ -117,21 +128,33 @@ async function prepareTranscriptForUpload(collection, options, names, source) {
     // bytes, the decoded text and the masked text are never all alive together.
     const body = await prepareTranscriptBody(collection, { source, kind: options.kind, sessionId: options.sessionId });
     const redactedBefore = collection.redacted.length;
-    const sanitized = maskSecretsInHeldTranscript(collection, body.held, {
-        kind: options.kind,
-        evidenceLabel: names.evidenceLabel,
-        secretLikeFileName: names.secretLikeFileName,
-    });
+    let sanitized;
+    try {
+        sanitized = maskSecretsInHeldTranscript(collection, body.held, {
+            kind: options.kind,
+            evidenceLabel: names.evidenceLabel,
+            secretLikeFileName: names.secretLikeFileName,
+        });
+    }
+    catch (error) {
+        if (body.held.staged)
+            await discardStagedOutput(body.held.staged, "mask_threw");
+        throw error;
+    }
+    // BLI-23317 stage D: only a clean file IS its staged bytes. Anything the mask rewrote has new bytes, built
+    // from the sanitizer's text, so the streamed partial is of no use.
+    if (body.held.staged && !("staged" in sanitized))
+        await discardStagedOutput(body.held.staged, "redaction_rewrote_the_bytes");
     // The ledger entry this mask pushed (if any), kept so a later skip can replay it.
     const redactedEntry = collection.redacted.length > redactedBefore ? collection.redacted[collection.redacted.length - 1] : null;
-    const contentHash = sha256(sanitized.bytes);
+    const contentHash = "staged" in sanitized ? sanitized.staged.sha256 : sha256(sanitized.bytes);
     // BLI-11102: a session the server named a redaction stub is re-offered even
     // when these bytes are already durable, because the stub is not a delivery.
     const stubClaim = stubReplacementClaim({
         kind: options.kind,
         stubPointerId: collection.stubReoffers.get(options.sessionId),
         completenessLabel: sanitized.completenessLabel,
-        byteSize: sanitized.bytes.byteLength,
+        byteSize: byteLengthOf(sanitized),
         alreadyDurable: collection.skipContentHashes.has(contentHash),
     });
     return { sanitized, contentHash, stubClaim, volatile: body.volatile, pendingImages: body.pendingImages, redactedEntry };
@@ -239,46 +262,6 @@ function logDeliveryBackoffHold(kind, sourceKey) {
         source_key: sourceKey,
     }));
 }
-/** Put an accepted transcript's bytes on disk and add its manifest entry. */
-async function stageOneTranscript(collection, file) {
-    collection.index.value += 1;
-    const relativePath = path.join("files", `${String(collection.index.value).padStart(3, "0")}-${shortHash(file.filePath)}-${file.names.packedFileName}`);
-    const staged = await stageEvidenceBytes(collection, {
-        contentHash: file.contentHash,
-        bytes: file.sanitized.bytes,
-        fileName: path.basename(relativePath),
-        kind: file.kind,
-        sourceKey: file.names.sourceKey,
-    });
-    collection.entries.push(evidenceEntry({
-        context: collection.context,
-        kind: file.kind,
-        packId: collection.packId,
-        localPath: staged.local_path,
-        relativePath,
-        mediaType: file.mediaType,
-        redactedSummary: file.sanitized.status === "redacted"
-            ? `${file.redactedSummary} Secret-like values were deterministically redacted before upload.`
-            : file.redactedSummary,
-        // Both branches carry a record now (BLI-3277), so "was anything
-        // replaced?" is the status, never the presence of `redaction`.
-        redaction: file.sanitized.redaction,
-        bytes: file.sanitized.bytes,
-        codexSessionId: file.sessionId,
-        contentAddress: file.contentAddress(file.contentHash.slice(0, 16)),
-        stagedInPack: staged.staged_in_pack,
-        sourceKey: file.names.sourceKey,
-        // BLI-11088: remember this snapshot's shape, and claim the last one when
-        // these bytes rebuild it.
-        snapshot: describeSnapshot(file.sanitized.bytes),
-        supersedes: file.stubClaim ?? supersedeClaimFor({
-            bytes: file.sanitized.bytes,
-            contentHash: file.contentHash,
-            kind: file.kind,
-            prior: collection.priorSnapshots.get(file.names.sourceKey),
-        }),
-    }));
-}
 /** The size from which this pass streams a transcript instead of reading it whole; null when its image session cannot (BLI-23317). */
 function streamMinBytesFor(collection, kind) {
     const session = collection.budget.images;
@@ -317,7 +300,7 @@ async function readEvidenceFileWithinCap(filePath, maxFileBytes, streamMinBytes)
         // falls through to the read below, which reports the failure itself.
         const size = await fs.stat(filePath).then((stat) => stat.size, () => null);
         if (size !== null && size >= streamMinBytes) {
-            return { status: "ok", source: { bytes: null, stream: { filePath, maxFileBytes } }, byteLength: size };
+            return { status: "ok", source: { bytes: null, stream: { filePath, maxFileBytes, inputBytes: size } }, byteLength: size };
         }
     }
     let bytes;