@bli-cockpit/cli 0.2.292 → 0.2.294

package/dist/adapters/opencode-store.js

@@ -0,0 +1,201 @@
+/** Read native OpenCode sessions without changing the live store or losing its WAL. */
+import path from "node:path";
+import { access } from "node:fs/promises";
+import { createHash } from "node:crypto";
+export class OpenCodeReadError extends Error {
+    reason;
+    constructor(reason) { super(reason); this.reason = reason; }
+}
+/** Resolve only the documented data home; never look in the sibling auth file. */
+export function openCodeDatabasePath(homeDir, xdgDataHome) {
+    return path.join(xdgDataHome || path.join(homeDir, ".local", "share"), "opencode", "opencode.db");
+}
+/** An absent store is distinct from an unreadable or incompatible one. */
+export async function openOpenCodeStore(databasePath) {
+    try {
+        await access(databasePath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw new OpenCodeReadError("opencode_store_unreadable");
+    }
+    let database;
+    try {
+        // Dynamic import keeps older CLI runtimes usable for their existing sources.
+        // They name this source's runtime gap rather than pretending it has no sessions.
+        const sqliteModule = "node:sqlite";
+        const { DatabaseSync } = await import(sqliteModule);
+        database = new DatabaseSync(databasePath, { readOnly: true, timeout: 1000 });
+    }
+    catch (error) {
+        const code = error.code;
+        throw new OpenCodeReadError(code === "ERR_UNKNOWN_BUILTIN_MODULE" || code === "ERR_MODULE_NOT_FOUND" ? "opencode_sqlite_runtime_unavailable" : "opencode_sqlite_open_failed");
+    }
+    return new OpenCodeStore(database);
+}
+export class OpenCodeStore {
+    database;
+    constructor(database) { this.database = database; }
+    close() { this.database.close(); }
+    /** Keyset inventory uses the same native identities for scheduled, historical and reconciliation reads. */
+    list(afterId = "", limit = 100) {
+        if (!Number.isInteger(limit) || limit < 1 || limit > 500)
+            throw new OpenCodeReadError("opencode_page_limit_invalid");
+        try {
+            return this.database.prepare(`select id, directory, parent_id, version, time_created, time_updated
+        from session where id > ? order by id limit ?`).all(afterId, limit).map(sessionMetadata);
+        }
+        catch {
+            throw new OpenCodeReadError("opencode_inventory_read_failed");
+        }
+    }
+    /** Stream native records at one WAL snapshot so total history size never becomes a buffered-session limit. */
+    *records(sessionId) {
+        try {
+            this.database.exec("BEGIN");
+        }
+        catch {
+            throw new OpenCodeReadError("opencode_snapshot_begin_failed");
+        }
+        try {
+            const session = this.database.prepare("select * from session where id = ?").get(sessionId);
+            if (!session)
+                throw new OpenCodeReadError("opencode_session_disappeared");
+            yield { type: "opencode_session", info: session, timestamp: new Date(Number(session.time_created)).toISOString() };
+            let afterMessage = "";
+            let parts = 0;
+            while (true) {
+                const messages = this.database.prepare("select id from message where session_id = ? and id > ? order by id limit 100").all(sessionId, afterMessage);
+                if (!messages.length)
+                    break;
+                for (const message of messages) {
+                    const raw = this.database.prepare("select * from message where session_id = ? and id = ?").get(sessionId, String(message.id));
+                    const info = { ...parseNativeObject(raw.data), id: message.id, sessionID: sessionId };
+                    yield { type: "opencode_message", info, storage: nativeStorageMetadata(raw), timestamp: nativeTimestamp(info.time) };
+                    let afterPart = "";
+                    while (true) {
+                        const batch = this.database.prepare("select id from part where session_id = ? and message_id = ? and id > ? order by id limit 100").all(sessionId, String(message.id), afterPart);
+                        if (!batch.length)
+                            break;
+                        for (const part of batch) {
+                            const rawPart = this.database.prepare("select * from part where session_id = ? and id = ?").get(sessionId, String(part.id));
+                            yield { type: "opencode_part", storage: nativeStorageMetadata(rawPart), role: info.role, timestamp: nativeTimestamp(parseNativeObject(rawPart.data).time) ?? nativeTimestamp(info.time), part: { ...parseNativeObject(rawPart.data), id: part.id, messageID: message.id, sessionID: sessionId } };
+                            afterPart = String(part.id);
+                            parts += 1;
+                        }
+                    }
+                    afterMessage = String(message.id);
+                }
+            }
+            if (Number(this.database.prepare("select count(*) as count from part where session_id = ?").get(sessionId)?.count) !== parts)
+                throw new OpenCodeReadError("opencode_orphan_parts");
+        }
+        catch (error) {
+            if (error instanceof OpenCodeReadError)
+                throw error;
+            throw new OpenCodeReadError("opencode_snapshot_read_failed");
+        }
+        finally {
+            this.database.exec("ROLLBACK");
+        }
+    }
+    /** A read transaction sees the session, messages and parts at one WAL snapshot. No source files are copied. */
+    snapshot(sessionId, maxBytes = Number.MAX_SAFE_INTEGER) {
+        if (!Number.isSafeInteger(maxBytes) || maxBytes < 1)
+            throw new OpenCodeReadError("opencode_byte_limit_invalid");
+        try {
+            this.database.exec("BEGIN");
+        }
+        catch {
+            throw new OpenCodeReadError("opencode_snapshot_begin_failed");
+        }
+        try {
+            const session = this.database.prepare("select * from session where id = ?").get(sessionId);
+            if (!session)
+                throw new OpenCodeReadError("opencode_session_disappeared");
+            const lines = [JSON.stringify({ type: "opencode_session", info: session }) + "\n"];
+            let bytes = Buffer.byteLength(lines[0]);
+            let afterId = "";
+            let messages = 0;
+            let parts = 0;
+            while (true) {
+                // Bound the bytes selected BEFORE decoding content. Oversized messages remain pending, never truncated.
+                const rows = this.database.prepare(`select id, length(cast(data as blob)) as bytes from message
+          where session_id = ? and id > ? order by id limit 100`).all(sessionId, afterId);
+                if (!rows.length)
+                    break;
+                for (const row of rows) {
+                    if (bytes + Number(row.bytes) > maxBytes)
+                        throw new OpenCodeReadError("opencode_session_byte_cap");
+                    const message = this.database.prepare("select * from message where session_id = ? and id = ?").get(sessionId, String(row.id));
+                    const info = { ...parseNativeObject(message.data), id: row.id, sessionID: sessionId };
+                    const nativeParts = [];
+                    const partStorage = {};
+                    const priorBytes = bytes;
+                    let afterPart = "";
+                    while (true) {
+                        const batch = this.database.prepare(`select id, length(cast(data as blob)) as bytes from part
+              where session_id = ? and message_id = ? and id > ? order by id limit 100`).all(sessionId, String(row.id), afterPart);
+                        if (!batch.length)
+                            break;
+                        for (const part of batch) {
+                            bytes += Number(part.bytes);
+                            if (bytes + Number(row.bytes) > maxBytes)
+                                throw new OpenCodeReadError("opencode_session_byte_cap");
+                            const native = this.database.prepare("select * from part where session_id = ? and id = ?").get(sessionId, String(part.id));
+                            partStorage[String(part.id)] = nativeStorageMetadata(native);
+                            nativeParts.push({ ...parseNativeObject(native.data), id: part.id, sessionID: sessionId, messageID: row.id });
+                            afterPart = String(part.id);
+                            parts += 1;
+                        }
+                    }
+                    const line = JSON.stringify({ type: "opencode_message", info, parts: nativeParts, storage: { message: nativeStorageMetadata(message), parts: partStorage } }) + "\n";
+                    // Account for wrapper/identity bytes too, without counting native parts twice.
+                    bytes = priorBytes + Buffer.byteLength(line);
+                    if (bytes > maxBytes)
+                        throw new OpenCodeReadError("opencode_session_byte_cap");
+                    lines.push(line);
+                    messages += 1;
+                    afterId = String(row.id);
+                }
+            }
+            const storedParts = this.database.prepare("select count(*) as count from part where session_id = ?").get(sessionId);
+            if (Number(storedParts?.count) !== parts)
+                throw new OpenCodeReadError("opencode_orphan_parts");
+            const jsonl = lines.join("");
+            return { session: sessionMetadata(session), jsonl, revision: createHash("sha256").update(jsonl).digest("hex"), messages, parts };
+        }
+        catch (error) {
+            if (error instanceof OpenCodeReadError)
+                throw error;
+            throw new OpenCodeReadError("opencode_snapshot_read_failed");
+        }
+        finally {
+            this.database.exec("ROLLBACK");
+        }
+    }
+}
+function sessionMetadata(row) {
+    if (typeof row.id !== "string" || typeof row.directory !== "string" || typeof row.version !== "string" || !Number.isFinite(row.time_updated)) {
+        throw new OpenCodeReadError("opencode_session_schema_unknown");
+    }
+    return { id: row.id, directory: row.directory, version: row.version, parent_id: typeof row.parent_id === "string" ? row.parent_id : null, updated_at_ms: Number(row.time_updated), created_at_ms: Number(row.time_created ?? row.time_updated) };
+}
+function parseNativeObject(raw) {
+    if (typeof raw !== "string")
+        throw new OpenCodeReadError("opencode_record_invalid");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new OpenCodeReadError("opencode_record_invalid");
+    return parsed;
+}
+function nativeTimestamp(value) {
+    const time = value && typeof value === "object" ? value : {};
+    const ms = time.created ?? time.start ?? time.end ?? time.completed;
+    return typeof ms === "number" && Number.isFinite(ms) ? new Date(ms).toISOString() : null;
+}
+/** Keep physical native row metadata without duplicating the JSON content body. */
+function nativeStorageMetadata(row) {
+    return Object.fromEntries(Object.entries(row).filter(([key]) => key !== "data"));
+}

package/dist/adapters/pi-session-facts.js

@@ -0,0 +1,28 @@
+/** Unknown fields stay in the reader's raw evidence; these facts never replace it. */
+export function piRecordFacts(value) {
+    const entry = object(value);
+    const message = object(entry?.message);
+    const content = Array.isArray(message?.content) ? message.content : [];
+    return {
+        type: text(entry?.type), id: text(entry?.id), parentId: text(entry?.parentId),
+        timestamp: typeof entry?.timestamp === 'string' || typeof entry?.timestamp === 'number' ? entry.timestamp : null,
+        role: text(message?.role), provider: text(message?.provider) ?? text(entry?.provider),
+        model: text(message?.model) ?? text(entry?.modelId), usage: object(message?.usage) ?? object(entry?.usage),
+        toolCallIds: content.flatMap(block => {
+            const call = object(block);
+            return call?.type === 'toolCall' && typeof call.id === 'string' ? [call.id] : [];
+        }),
+        toolResultId: text(message?.toolCallId),
+    };
+}
+/** Native headers retain the explicit parent path, including Windows separators. */
+export function piSessionHeader(value) {
+    const entry = object(value);
+    if (entry?.type !== 'session' || typeof entry.id !== 'string' || typeof entry.version !== 'number' || typeof entry.cwd !== 'string')
+        return null;
+    return { id: entry.id, version: entry.version, cwd: entry.cwd, parentSession: text(entry.parentSession) };
+}
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function text(value) { return typeof value === 'string' ? value : null; }

package/dist/adapters/pi-session-reader.js

@@ -0,0 +1,132 @@
+/** Read-only Pi JSONL access. Callers must redact raw bytes before staging or uploading. */
+import path from 'node:path';
+import { open, readdir, stat } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+export class PiReadError extends Error {
+    reason;
+    constructor(reason) { super(reason); this.reason = reason; }
+}
+/** Explicit CLI/session roots supplement the default home so retained history remains discoverable. */
+export function piSessionRoots(homeDir, options = {}) {
+    const paths = options.platform === 'win32' ? path.win32 : path;
+    const expand = (root) => root === '~' ? homeDir : root.startsWith('~/') || root.startsWith('~\\') ? paths.join(homeDir, root.slice(2)) : root;
+    return [...new Set([paths.join(homeDir, '.pi', 'agent', 'sessions'),
+            ...(options.agentDir ? [paths.join(expand(options.agentDir), 'sessions')] : []),
+            ...(options.sessionDir ? [expand(options.sessionDir)] : []), ...(options.additionalRoots ?? []).map(expand)].map(root => paths.resolve(root)))];
+}
+/** Bounded keyset pages enumerate every retained JSONL; errors never masquerade as an empty source. */
+export async function listPiSessions(root, after = '', limit = 100) {
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
+        throw new PiReadError('pi_page_limit_invalid');
+    const files = [];
+    try {
+        const rootInfo = await stat(root);
+        if (!rootInfo.isDirectory())
+            throw new PiReadError('pi_root_not_directory');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { state: 'missing', files, next: null, requested: limit, returned: 0, unique: 0 };
+        throw error instanceof PiReadError ? error : new PiReadError('pi_inventory_unreadable');
+    }
+    try {
+        for await (const key of walkPiFiles(root)) {
+            if (key <= after)
+                continue;
+            if (files.length === limit)
+                return { state: 'more', files, next: files.at(-1).key, requested: limit, returned: files.length, unique: files.length };
+            files.push({ key, filePath: path.join(root, ...key.split('/')) });
+        }
+    }
+    catch (error) {
+        throw error instanceof PiReadError ? error : new PiReadError('pi_inventory_unreadable');
+    }
+    return { state: 'complete', files, next: null, requested: limit, returned: files.length, unique: files.length };
+}
+async function* walkPiFiles(root, prefix = '') {
+    const entries = await readdir(path.join(root, prefix), { withFileTypes: true });
+    const key = (entry) => entry.name + (entry.isDirectory() ? '/' : '');
+    entries.sort((a, b) => key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0);
+    for (const entry of entries) {
+        const relative = prefix + entry.name;
+        if (entry.isDirectory())
+            yield* walkPiFiles(root, relative + '/');
+        else if (entry.isFile() && entry.name.endsWith('.jsonl'))
+            yield relative;
+        // Symlinks are not followed: otherwise aliases/cycles could duplicate or escape this root.
+        else if (entry.isSymbolicLink())
+            throw new PiReadError('pi_inventory_symlink');
+    }
+}
+/** Stream a bounded observed file revision, rehashing its prefix to detect edits, rotation and truncation. */
+export async function* readPiSession(filePath, previousRevision) {
+    let file;
+    try {
+        file = await open(filePath, 'r');
+    }
+    catch (error) {
+        throw new PiReadError(error.code === 'ENOENT' ? 'pi_session_missing' : 'pi_session_unreadable');
+    }
+    try {
+        const before = await file.stat();
+        if (!before.isFile())
+            throw new PiReadError('pi_session_not_file');
+        const hash = createHash('sha256');
+        let position = 0, offset = 0, records = 0, invalidRecords = 0;
+        let fragments = [];
+        let fragmentBytes = 0;
+        // Bound each read to the initial size. Growing files remain pending for the next observation.
+        while (position < before.size) {
+            const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, before.size - position));
+            const { bytesRead } = await file.read(buffer, 0, buffer.length, position);
+            if (!bytesRead)
+                break;
+            const chunk = buffer.subarray(0, bytesRead);
+            hash.update(chunk);
+            position += bytesRead;
+            let start = 0;
+            for (let index = 0; index < chunk.length; index++) {
+                if (chunk[index] !== 10)
+                    continue;
+                const raw = Buffer.concat([...fragments, chunk.subarray(start, index + 1)], fragmentBytes + index + 1 - start);
+                let value = null, valid = true;
+                try {
+                    value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(raw));
+                }
+                catch {
+                    valid = false;
+                    invalidRecords++;
+                }
+                records++;
+                yield { kind: 'record', offset, raw, value, valid };
+                offset += raw.length;
+                fragments = [];
+                fragmentBytes = 0;
+                start = index + 1;
+            }
+            if (start < chunk.length) {
+                fragments.push(chunk.subarray(start));
+                fragmentBytes += chunk.length - start;
+            }
+        }
+        if (fragmentBytes)
+            yield { kind: 'partial', offset, raw: Buffer.concat(fragments, fragmentBytes) };
+        const after = await file.stat();
+        let current;
+        try {
+            current = await stat(filePath);
+        }
+        catch {
+            current = null;
+        }
+        const stable = position === before.size && before.size === after.size && before.mtimeMs === after.mtimeMs && before.ctimeMs === after.ctimeMs && current?.ino === before.ino && current?.dev === before.dev && current?.size === before.size && current?.mtimeMs === before.mtimeMs && current?.ctimeMs === before.ctimeMs;
+        const revision = hash.digest('hex');
+        yield { kind: 'revision', revision, bytes: position, records, invalidRecords, partialBytes: fragmentBytes, stable, changed: previousRevision === undefined ? null : previousRevision !== revision };
+    }
+    catch (error) {
+        throw error instanceof PiReadError ? error : new PiReadError('pi_session_read_failed');
+    }
+    finally {
+        await file.close();
+    }
+}

package/dist/adapters/raw-evidence-attribution-gaps.js

@@ -7,6 +7,11 @@ import { recordScanned, recordSkipCount, recordTruncationCount, } from "./raw-ev
 export function recordCodexAttributionCompleteness(ledger, scan, selectedPaths) {
     recordScanned(ledger, "codex_attribution", scan.scanned_file_count);
     ledger.caps.push(...codexAttributionCaps(scan));
+    if (scan.projection_failure_reason)
+        recordSkipCount(ledger, "codex_attribution", scan.projection_failure_reason, 1);
+    for (const result of scan.results)
+        if (result.t3_projection_failure_reason)
+            recordSkipCount(ledger, "codex_attribution", result.t3_projection_failure_reason, 1);
     recordSkipCount(ledger, "codex_attribution", "session_limit_overflow", Math.max(0, scan.discovered_file_count - scan.scanned_file_count));
     recordSkipCount(ledger, "codex_attribution", "directory_read_failed", scan.directory_read_failed_count);
     recordSkipCount(ledger, "codex_attribution", "file_stat_failed", scan.stat_failed_count);

package/dist/adapters/raw-evidence-codex-reader.js

@@ -10,6 +10,7 @@
  * A session is a transcript first and its attached images second, never the
  * reverse — images are only collected once the transcript itself was accepted.
  */
+import { openCodexSessionRevision } from "./codex-session-revision.js";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -20,6 +21,7 @@ import { isSecretLikePath, safeKeySegment, shortHash, } from "./raw-evidence-key
 import { recordScanned } from "./raw-evidence-completeness.js";
 import { collectOneEvidenceFile } from "./raw-evidence-transcript-file.js";
 import { collectAgentImagesFromTranscript } from "./raw-evidence-image-reader.js";
+import { TranscriptNotStreamable, TranscriptReadError } from "./transcript-text-stream.js";
 export async function collectCodexJsonlFiles(collection, options) {
     for (const candidate of await chooseCodexCandidates(collection, options)) {
         recordScanned(collection, "codex_jsonl");
@@ -37,6 +39,7 @@ async function chooseCodexCandidates(collection, options) {
         ? options.codexSessionFiles.map((file) => ({
             filePath: file.local_path,
             codexSessionId: file.codex_session_id,
+            segmentPaths: file.segment_paths, revisionHash: file.revision_hash, revisionBytes: file.revision_bytes, t3Projection: file.t3_projection,
         }))
         : (await walkRecentCodexJsonlFiles(collection, options)).map((filePath) => ({ filePath, codexSessionId: null }));
     collection.caps.push({
@@ -59,18 +62,47 @@ async function collectOneCodexSession(collection, candidate) {
         // Guard before read/toString: Codex files can exceed the buffered commit
         // ceiling just like Claude mains.
         maxFileBytes: RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES,
+        ...(candidate.segmentPaths ? { sourceProvider: async () => {
+                const revisionOptions = { t3Projection: candidate.t3Projection, maxFileBytes: RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, expectedHash: candidate.revisionHash };
+                const openSource = () => openCodexSessionRevision(candidate.segmentPaths, revisionOptions);
+                let byteLength = candidate.revisionBytes;
+                // Direct native callers may omit attribution's observed revision. Pin a
+                // complete observation before admission, then reopen only that revision;
+                // estimates from native file sizes omit provenance/projection overhead.
+                if (byteLength === undefined || !revisionOptions.expectedHash) {
+                    let source;
+                    try {
+                        source = await openSource();
+                        byteLength = source.length;
+                        revisionOptions.expectedHash = source.sha256;
+                    }
+                    catch (error) {
+                        if (error instanceof TranscriptNotStreamable)
+                            throw new TranscriptReadError(error.reason, error);
+                        throw error;
+                    }
+                    finally {
+                        await source?.close();
+                    }
+                }
+                return { byteLength, source: { bytes: null, stream: {
+                            filePath: candidate.filePath, inputBytes: byteLength, maxFileBytes: RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES,
+                            openSource,
+                        } } };
+            } } : {}),
         redactedSummary: "Raw Codex JSONL transcript with prompts, responses, tool arguments, and tool outputs preserved locally.",
         contentAddress: (hash16) => `codex/${safeKeySegment(codexSessionId)}/${hash16}.jsonl`,
     });
     if (!transcriptAccepted)
         return;
-    await collectAgentImagesFromTranscript(collection, {
-        filePath: candidate.filePath,
-        source: "codex",
-        sessionId: codexSessionId,
-        kind: "codex_image_attachment",
-        contentAddress: (hash16, extension) => `codex/${safeKeySegment(codexSessionId)}/images/${hash16}.${extension}`,
-    });
+    for (const filePath of candidate.segmentPaths ?? [candidate.filePath])
+        await collectAgentImagesFromTranscript(collection, {
+            filePath,
+            source: "codex",
+            sessionId: codexSessionId,
+            kind: "codex_image_attachment",
+            contentAddress: (hash16, extension) => `codex/${safeKeySegment(codexSessionId)}/images/${hash16}.${extension}`,
+        });
 }
 /** The unattributed fallback: every recent Codex transcript on this machine. */
 function walkRecentCodexJsonlFiles(collection, options) {

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

@@ -10,6 +10,8 @@
  * The order stays image replacement, slim, redact.
  */
 import { isUtf8 } from "node:buffer";
+import { openPinnedTranscript } from "./pinned-transcript.js";
+import { TranscriptReadError } from "./transcript-text-stream.js";
 import { mightHoldEmbeddedImages, modeDropsImages, modeStoresImages } from "@bli-cockpit/telemetry-core";
 import { describeError } from "../health-detail.js";
 import { makeCaptureProvenance } from "./common.js";
@@ -17,7 +19,7 @@ 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) {
-    return kind.startsWith("codex") ? "codex" : kind.startsWith("claude") ? "claude_code" : null;
+    return kind === "opencode_jsonl" ? "opencode" : kind.startsWith("codex") ? "codex" : kind.startsWith("claude") ? "claude_code" : null;
 }
 /** Decode once and release the bytes, unless the decoding was lossy and the bytes are the only exact copy. */
 export function holdDecodedText(source) {
@@ -54,6 +56,10 @@ function releaseBackingStore(bytes) {
  * the caller turns into the `file_read_failed` and `file_too_large` skips.
  */
 export async function prepareTranscriptBody(collection, file) {
+    if (file.kind === "opencode_jsonl" && file.source.stream) {
+        const source = file.source.stream;
+        source.openSource ??= () => openPinnedTranscript(source.filePath, { maxFileBytes: source.maxFileBytes });
+    }
     const session = collection.budget.images;
     const agent = agentOfKind(file.kind);
     // BLI-23329: `store_and_drop` talks to the upload doors for the images of this transcript, as this sync.
@@ -67,6 +73,8 @@ export async function prepareTranscriptBody(collection, file) {
         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 }));
         }
+        if (refusal && file.source.stream.openSource)
+            throw new TranscriptReadError("composite_staging_declined", new Error(refusal));
         const streamed = await streamTranscriptBody(session, agent, { ...file.source.stream, sessionId: file.sessionId, kind: file.kind, stageDir: refusal ? undefined : collection.filesDir, ...(provenance ? { provenance } : {}) });
         if (streamed) {
             file.source.readBytes = streamed.readBytes;

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

@@ -56,11 +56,27 @@ export async function collectOneEvidenceFile(collection, options) {
     }
     // BLI-3936: stat BEFORE the read. The same stamp, taken again after the work, proves the file
     // did not move underneath it; only then is the result remembered.
-    const stamp = await statSourceForMemo(options.filePath);
+    const stamp = options.sourceProvider ? null : await statSourceForMemo(options.filePath);
     const recipe = prepareRecipe({ imageMode: collection.budget.images?.mode, kind: options.kind });
     if (await reuseUnchangedTranscript(collection, options, names, stamp, recipe))
         return true;
-    const read = await readEvidenceFileWithinCap(options.filePath, options.maxFileBytes, streamMinBytesFor(collection, options.kind));
+    let read;
+    try {
+        read = options.sourceProvider
+            ? { status: "ok", ...await options.sourceProvider() }
+            : await readEvidenceFileWithinCap(options.filePath, options.maxFileBytes, streamMinBytesFor(collection, options.kind));
+    }
+    catch (error) {
+        if (error instanceof TranscriptTooLargeError) {
+            markCapApplied(collection, options.kind, "max_file_bytes");
+            return skip("file_too_large");
+        }
+        const reason = error instanceof TranscriptReadError ? `file_read_failed:${error.stage}` : "file_read_failed";
+        console.error("[raw-evidence] revision source unavailable", JSON.stringify({ reason, ...describeError(error) }));
+        return skip(reason);
+    }
+    if (read.status === "ok" && options.maxFileBytes && read.byteLength > options.maxFileBytes)
+        read = { status: "too_large" };
     if (read.status === "read_failed")
         return skip("file_read_failed");
     if (read.status === "too_large") {
@@ -80,8 +96,15 @@ export async function collectOneEvidenceFile(collection, options) {
     }
     catch (error) {
         // BLI-23317: a streamed or fallback read that fails ends exactly as a whole-file read that failed.
-        if (error instanceof TranscriptReadError)
-            return skip("file_read_failed");
+        if (error instanceof TranscriptReadError) {
+            const deferred = error.stage === "composite_staging_declined" && error.underlying instanceof Error ? error.underlying.message : null;
+            if (deferred && /^(deferred_(byte|object)_budget|staging_deferred:[a-z_]+)$/.test(deferred)) {
+                markBudgetCapApplied(collection, deferred);
+                return skip(deferred);
+            }
+            const detail = options.sourceProvider ? `:${error.stage}` : "";
+            return skip(`file_read_failed${detail}`);
+        }
         if (error instanceof TranscriptTooLargeError) {
             markCapApplied(collection, options.kind, "max_file_bytes");
             return skip("file_too_large");
@@ -149,6 +172,23 @@ async function prepareTranscriptForUpload(collection, options, names, source) {
             await discardStagedOutput(body.held.staged, "mask_threw");
         throw error;
     }
+    if (options.priorRedaction?.status === "sanitized" && (sanitized.status === "clean" || sanitized.completenessLabel === "secret_content_masked")) {
+        const prior = options.priorRedaction;
+        const final = sanitized.redaction;
+        const rules = new Map(prior.rule_counts.map(rule => [rule.rule_id, { ...rule }]));
+        for (const rule of final.rule_counts) {
+            const combined = rules.get(rule.rule_id) ?? { rule_id: rule.rule_id, match_count: 0, redacted_char_count: 0 };
+            combined.match_count += rule.match_count;
+            combined.redacted_char_count += rule.redacted_char_count;
+            rules.set(rule.rule_id, combined);
+        }
+        sanitized.redaction = { ...prior, ...final, status: "sanitized", mode: "deterministic_text_replacement",
+            applied_by: [...new Set([...prior.applied_by, ...final.applied_by])], rule_counts: [...rules.values()],
+            secret_like_match_count: prior.secret_like_match_count + final.secret_like_match_count,
+            redacted_fields: [...new Set([...prior.redacted_fields, ...final.redacted_fields])] };
+        collection.redacted.splice(redactedBefore);
+        collection.redacted.push({ kind: options.kind, label: names.evidenceLabel, redaction: sanitized.redaction, completenessLabel: "secret_content_masked" });
+    }
     // Only a clean file IS the spool. Anything the mask rewrote has new bytes (a new staged file, or the crash stub's), so the spool is of no use.
     if (body.held.staged && !("staged" in sanitized && sanitized.staged === body.held.staged))
         await discardStagedOutput(body.held.staged, "redaction_rewrote_the_bytes");
@@ -271,6 +311,8 @@ function logDeliveryBackoffHold(kind, 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) {
+    if (kind === "opencode_jsonl")
+        return 1024 * 1024;
     const session = collection.budget.images;
     if (!session?.prepareTranscriptFile || !agentOfKind(kind))
         return null;

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

@@ -12,6 +12,8 @@
  *    read gives (`file_read_failed`, `file_too_large`), never a shorter file.
  */
 import fs from "node:fs/promises";
+import { copyLinesStream } from "../slim/keep-line-copy.js";
+import { openStagedOutput } from "./staged-output.js";
 import { modeDropsImages } from "@bli-cockpit/telemetry-core";
 import { describeError } from "../health-detail.js";
 import { TranscriptNotStreamable, TranscriptReadError, TranscriptTooLargeError, } from "./transcript-text-stream.js";
@@ -32,11 +34,13 @@ export function volatilityOf(mode, prepared) {
 }
 export async function streamTranscriptBody(session, agent, file) {
     if (!session?.prepareTranscriptFile || !agent) {
+        if (file.openSource)
+            return streamCompositeWithoutImages(file);
         console.error(TAG + " streamed read not available, reading the transcript whole", JSON.stringify({ reason: "stream_unavailable", kind: file.kind }));
         return null;
     }
     try {
-        const prepared = await session.prepareTranscriptFile({ filePath: file.filePath, source: agent, sessionId: file.sessionId, maxFileBytes: file.maxFileBytes, stageDir: file.stageDir, omitText: file.stageDir !== undefined, ...(file.provenance ? { provenance: file.provenance } : {}) });
+        const prepared = await session.prepareTranscriptFile({ filePath: file.filePath, ...(file.openSource ? { openSource: file.openSource } : {}), source: agent, sessionId: file.sessionId, maxFileBytes: file.maxFileBytes, stageDir: file.stageDir, omitText: file.stageDir !== undefined, ...(file.provenance ? { provenance: file.provenance } : {}) });
         const { volatile, pendingImages } = volatilityOf(session.mode, prepared);
         console.error(TAG + " transcript streamed through image swap and slim", JSON.stringify({ kind: file.kind, mode: session.mode, byte_size: prepared.readBytes, changed: prepared.changed, images: prepared.imageCount, volatile, staged_bytes: prepared.staged?.byteLength ?? null }));
         // BLI-23344: with a spool the text is not read back; the sanitizer reads the spool line by line.
@@ -45,12 +49,18 @@ export async function streamTranscriptBody(session, agent, file) {
     catch (error) {
         if (error instanceof TranscriptReadError || error instanceof TranscriptTooLargeError)
             throw error;
+        if (file.openSource) {
+            console.error(TAG + " composite revision remains pending", JSON.stringify({ reason: "composite_prepare_failed", kind: file.kind, ...describeError(error) }));
+            throw new TranscriptReadError(error instanceof TranscriptNotStreamable ? error.reason : "composite_prepare_failed", error);
+        }
         console.error(TAG + " streamed read set aside, reading the transcript whole", JSON.stringify({ reason: error instanceof TranscriptNotStreamable ? error.reason : "stream_step_failed", kind: file.kind, ...(error instanceof TranscriptNotStreamable ? {} : describeError(error)) }));
         return null;
     }
 }
 /** The whole-file read the streamed path falls back to: same failures, same labels, as the reader that did not stream. */
 export async function readTranscriptWhole(file) {
+    if (file.openSource)
+        throw new TranscriptReadError("composite_buffering_refused", new Error("composite_buffering_refused"));
     let bytes;
     try {
         bytes = await fs.readFile(file.filePath);
@@ -62,4 +72,29 @@ export async function readTranscriptWhole(file) {
     if (file.maxFileBytes && bytes.byteLength > file.maxFileBytes)
         throw new TranscriptTooLargeError(file.maxFileBytes);
     return bytes;
+}
+/** Keep mode when image preparation is unavailable: same spool/mask/ack, no representative read or whole buffer. */
+async function streamCompositeWithoutImages(file) {
+    if (!file.stageDir)
+        throw new TranscriptReadError("composite_staging_unavailable", new Error("composite_staging_unavailable"));
+    let source;
+    let writer;
+    try {
+        source = await file.openSource();
+        writer = await openStagedOutput(file.stageDir);
+        await copyLinesStream(source.lines(), writer);
+        await source.verifyUnchanged();
+        const staged = await writer.finish();
+        console.error(TAG + " composite revision kept without image preparation", JSON.stringify({ reason: "composite_images_unavailable_kept", kind: file.kind, byte_size: source.length }));
+        return { held: { text: null, exactBytes: null, staged }, volatile: true, pendingImages: null, readBytes: source.length };
+    }
+    catch (error) {
+        await writer?.abandon().catch(() => console.error(TAG + " composite cleanup failed", JSON.stringify({ reason: "composite_staging_cleanup_failed", kind: file.kind })));
+        if (error instanceof TranscriptReadError || error instanceof TranscriptTooLargeError)
+            throw error;
+        throw new TranscriptReadError(error instanceof TranscriptNotStreamable ? error.reason : "composite_prepare_failed", error);
+    }
+    finally {
+        await source?.close().catch(() => console.error(TAG + " composite source cleanup failed", JSON.stringify({ reason: "file_close_failed", kind: file.kind })));
+    }
 }