@bli-cockpit/cli 0.2.293 → 0.2.295

package/dist/adapters/codex-attribution.js

@@ -7,6 +7,7 @@ import { existsSync } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { describeError } from "../health-detail.js";
+import { TranscriptReadError } from "./transcript-text-stream.js";
 import { extractCodexSessionSignals, } from "./codex-session-signals.js";
 import { readCodexMetadataMemoized } from "./codex-attribution-memoized-reads.js";
 import { sanitizeSessionId, scoreSignalsAgainstWorktrees, sessionIdFromFileName, shortHash, } from "./attribution-core.js";
@@ -48,6 +49,9 @@ export async function scanAndAttributeCodexSessions(options) {
     for (const file of files) {
         results.push(await attributeOneSession(file, options.worktrees, options.collectionRoots ?? [], options.readMemo));
     }
+    if (retained.projectionFailureReason)
+        for (const result of results)
+            result.t3_projection_incomplete = true;
     // Collector stdout is `--json`, so the line goes to stderr; counts only (BLI-23623).
     console.error("[hands-on] codex scan", JSON.stringify({ client: "codex", ...summarizeHandsOn(results.map((r) => r.session_facts)) }));
     return {
@@ -60,6 +64,7 @@ export async function scanAndAttributeCodexSessions(options) {
         max_file_bytes: 0,
         directory_read_failed_count: discovery.directoryReadFailedCount,
         stat_failed_count: discovery.statFailedCount + retained.readFailed,
+        ...(retained.projectionFailureReason ? { projection_failure_reason: retained.projectionFailureReason } : {}),
         secret_path_skipped_count: discovery.secretPathSkippedCount,
         counts: {
             attributed: results.filter((entry) => entry.state === "attributed").length,
@@ -172,18 +177,34 @@ function dedupePaths(values) {
     return out;
 }
 async function attributeOneSession(file, worktrees, collectionRoots, readMemo) {
-    const base = { ...createSessionBase(file), ...(file.segmentPaths ? { segment_paths: file.segmentPaths } : {}) };
+    const base = { ...createSessionBase(file), ...(file.segmentPaths ? { segment_paths: file.segmentPaths } : {}), ...(file.t3Projection ? { t3_projection: true } : {}) };
+    const readComposite = async (includeT3) => {
+        const source = await openCodexSessionRevision(file.segmentPaths, { t3Projection: includeT3 });
+        try {
+            base.local_cwds = source.segmentCwds;
+            const metadata = await readCodexMetadataSignals(file.file, pinnedBytes(source));
+            await source.verifyUnchanged();
+            return metadata;
+        }
+        finally {
+            await source.close();
+        }
+    };
     let read;
     try {
         if (file.segmentPaths) {
-            const source = await openCodexSessionRevision(file.segmentPaths);
             try {
-                base.local_cwds = source.segmentCwds;
-                read = await readCodexMetadataSignals(file.file, pinnedBytes(source));
-                await source.verifyUnchanged();
+                read = await readComposite(file.t3Projection === true);
             }
-            finally {
-                await source.close();
+            catch (error) {
+                if (!file.t3Projection || !(error instanceof TranscriptReadError) || !error.stage.startsWith("t3_"))
+                    throw error;
+                // Available native content still flows; the missing projection remains a
+                // named retry and cannot promote a partial snapshot as the full revision.
+                base.t3_projection = false;
+                base.t3_projection_incomplete = true;
+                base.t3_projection_failure_reason = error.stage;
+                read = await readComposite(false);
             }
         }
         else

package/dist/adapters/codex-segment-discovery.js

@@ -2,6 +2,7 @@
 import { createReadStream } from "node:fs";
 import readline from "node:readline";
 import path from "node:path";
+import { t3CodexProjectionSessionIds } from "./t3-projection-source.js";
 import { sanitizeSessionId, sessionIdFromFileName, shortHash } from "./attribution-core.js";
 export async function codexFileIdentity(file) {
     const stream = createReadStream(file, { encoding: "utf8" });
@@ -55,12 +56,20 @@ export async function retainedCodexSegments(files, seeds) {
                 readFailed++;
             }
         }
-    const sessions = [...wanted.values()].map(group => {
+    let projectionIds = new Set(), projectionFailureReason;
+    try {
+        projectionIds = t3CodexProjectionSessionIds();
+    }
+    catch (error) {
+        projectionFailureReason = error instanceof Error ? error.message : "t3_projection_unreadable";
+    }
+    const sessions = [...wanted.entries()].map(([id, group]) => {
         // A deterministic representative keeps existing cursor/source-path identity.
         const representative = [...group].sort((a, b) => a.file.localeCompare(b.file))[0];
         const mtimeMs = Math.max(...group.map(f => f.mtimeMs));
         return { ...representative, mtimeMs, byteSize: group.reduce((n, f) => n + f.byteSize, 0),
-            ...(group.length > 1 ? { segmentPaths: group.map(f => f.file).sort() } : {}) };
+            ...(projectionIds.has(id) ? { t3Projection: true } : {}),
+            ...(group.length > 1 || projectionIds.has(id) ? { segmentPaths: group.map(f => f.file).sort() } : {}) };
     });
-    return { sessions, readFailed, selectedFiles: [...wanted.values()].reduce((n, f) => n + f.length, 0) };
+    return { sessions, readFailed, selectedFiles: [...wanted.values()].reduce((n, f) => n + f.length, 0), ...(projectionFailureReason ? { projectionFailureReason } : {}) };
 }

package/dist/adapters/codex-session-revision.js

@@ -10,8 +10,10 @@
  */
 import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
+import { createNativeT3MessageIndex } from "@bli-cockpit/telemetry-core";
+import { readT3CodexProjection, t3ProjectionRevision } from "./t3-projection-source.js";
 import { openPinnedTranscript } from "./pinned-transcript.js";
-import { TranscriptNotStreamable, TranscriptTooLargeError } from "./transcript-text-stream.js";
+import { TranscriptNotStreamable, TranscriptReadError, TranscriptTooLargeError } from "./transcript-text-stream.js";
 const newline = Buffer.from("\n");
 const hashOf = (bytes) => createHash("sha256").update(bytes).digest("hex");
 const stampOf = async (file) => {
@@ -38,6 +40,8 @@ export async function openCodexSessionRevision(filePaths, options = {}) {
     const close = async () => { await Promise.all(segments.map(s => s.source.close())); };
     try {
         let nativeBytes = 0;
+        const nativeMessages = createNativeT3MessageIndex();
+        const nativeIds = new Set();
         for (const filePath of [...new Set(filePaths)]) {
             const stamp = await stampOf(filePath);
             const source = await openPinnedTranscript(filePath, { maxFileBytes: options.maxFileBytes });
@@ -54,6 +58,10 @@ export async function openCodexSessionRevision(filePaths, options = {}) {
                 // Timestamp metadata only. Record bodies never leave this process.
                 try {
                     const r = JSON.parse(line.bytes.toString("utf8"));
+                    if (options.t3Projection)
+                        nativeMessages.observe(r, hashOf(line.bytes));
+                    if (r.type === "session_meta" && typeof r.payload?.id === "string")
+                        nativeIds.add(r.payload.id);
                     if ((r.type === "session_meta" || r.type === "turn_context") && typeof r.payload?.cwd === "string")
                         segment.cwds.add(r.payload.cwd);
                     const time = r.type === "session_meta" ? NaN : Date.parse(r.timestamp ?? "");
@@ -62,7 +70,11 @@ export async function openCodexSessionRevision(filePaths, options = {}) {
                         segment.lastTimestamp = Math.max(segment.lastTimestamp, time);
                     }
                 }
-                catch { /* Broken/partial lines stay verbatim in the logical revision. */ }
+                catch (error) {
+                    if (error instanceof Error && error.message === "t3_native_identity_index_capped")
+                        throw error;
+                    /* Broken/partial lines stay verbatim in the logical revision. */
+                }
             }
             segment.sha256 = hash.digest("hex");
             segment.terminalNewline = source.length > 0 && (await source.read(source.length - 1, 1))[0] === 10;
@@ -78,10 +90,27 @@ export async function openCodexSessionRevision(filePaths, options = {}) {
                 } }) + "\n");
             length += s.header.length + s.source.length + (s.terminalNewline || s.source.length === 0 ? 0 : 1);
         }
+        // Projection bytes are bounded, pinned in memory, and use the SAME governed
+        // staging/redaction stream. No native transcript aggregate or unmanaged raw copy.
+        const nativeId = options.t3Projection && nativeIds.size === 1 ? [...nativeIds][0] : null;
+        const projection = nativeId ? readT3CodexProjection(nativeId, options.projectionHomeDir) : [];
+        const projectionRevision = t3ProjectionRevision(projection);
+        const supplementalCwds = projection.flatMap(message => nativeMessages.turnCwds(message));
+        const extra = projection.map(message => {
+            const nativeCopy = nativeMessages.copyOf(message);
+            return Buffer.from(JSON.stringify({ type: "tower_t3_message", timestamp: message.created_at,
+                payload: { ...message, ...(nativeCopy ? { native_copy: nativeCopy } : {}) } }) + "\n");
+        });
+        const supplementalStart = length;
+        const extraOffsets = [];
+        for (const bytes of extra) {
+            extraOffsets.push(length);
+            length += bytes.length;
+        }
         if (options.maxFileBytes && length > options.maxFileBytes)
             throw new TranscriptTooLargeError(options.maxFileBytes);
         const logical = {
-            length, sha256: "", segmentCount: segments.length, segmentCwds: segments.flatMap(s => s.cwds.size ? [...s.cwds] : [null]),
+            length, sha256: "", segmentCount: segments.length, segmentCwds: [...segments.flatMap(s => s.cwds.size ? [...s.cwds] : [null]), ...supplementalCwds],
             async *lines() {
                 for (const s of segments) {
                     yield { start: s.start, bytes: s.header.subarray(0, -1) };
@@ -91,6 +120,8 @@ export async function openCodexSessionRevision(filePaths, options = {}) {
                         yield { start: s.start + s.header.length + line.start, bytes: line.bytes };
                     }
                 }
+                for (const [i, bytes] of extra.entries())
+                    yield { start: extraOffsets[i], bytes: bytes.subarray(0, -1) };
                 yield { start: length, bytes: Buffer.alloc(0) };
             },
             async read(offset, size) {
@@ -113,6 +144,15 @@ export async function openCodexSessionRevision(filePaths, options = {}) {
                         done += bytes.length;
                     }
                 }
+                if (offset + size > supplementalStart)
+                    for (const [i, bytes] of extra.entries()) {
+                        const start = extraOffsets[i], from = Math.max(offset, start), to = Math.min(offset + size, start + bytes.length);
+                        if (to <= from)
+                            continue;
+                        const part = bytes.subarray(from - start, to - start);
+                        part.copy(output, done);
+                        done += part.length;
+                    }
                 if (done !== size)
                     throw new TranscriptNotStreamable("composite_range_invalid");
                 return output;
@@ -123,6 +163,19 @@ export async function openCodexSessionRevision(filePaths, options = {}) {
                     if (await stampOf(s.filePath) !== s.stamp || await digest(s.source) !== s.sha256)
                         throw new TranscriptNotStreamable("file_changed_during_pass");
                 }
+                if (nativeId) {
+                    let currentProjection;
+                    try {
+                        currentProjection = readT3CodexProjection(nativeId, options.projectionHomeDir);
+                    }
+                    catch (error) {
+                        if (error instanceof Error && error.message.startsWith("t3_"))
+                            throw new TranscriptReadError(error.message, error);
+                        throw error;
+                    }
+                    if (t3ProjectionRevision(currentProjection) !== projectionRevision)
+                        throw new TranscriptNotStreamable("composite_revision_changed");
+                }
             },
             close,
         };
@@ -134,6 +187,8 @@ export async function openCodexSessionRevision(filePaths, options = {}) {
     }
     catch (error) {
         await close();
+        if (error instanceof Error && error.message.startsWith("t3_"))
+            throw new TranscriptReadError(error.message, error);
         throw error;
     }
 }

package/dist/adapters/local-sources.js

@@ -76,6 +76,7 @@ async function collectConfiguredRawEvidence(context, options) {
             includeClaudeJsonl: options.rawEvidenceIncludeClaudeJsonl,
             codexSessionFiles: options.rawEvidenceCodexSessionFiles,
             codexAttributionScan: options.rawEvidenceCodexAttributionScan,
+            nativeSessionFiles: options.rawEvidenceNativeSessionFiles,
             claudeSessionFiles: options.rawEvidenceClaudeSessionFiles,
             claudeAttributionScan: options.rawEvidenceClaudeAttributionScan,
             skipContentHashes: options.rawEvidenceSkipContentHashes,

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/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

@@ -21,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");
@@ -38,7 +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,
+            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({
@@ -62,10 +63,31 @@ async function collectOneCodexSession(collection, candidate) {
         // ceiling just like Claude mains.
         maxFileBytes: RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES,
         ...(candidate.segmentPaths ? { sourceProvider: async () => {
-                const byteLength = candidate.revisionBytes ?? (await Promise.all(candidate.segmentPaths.map(p => fs.stat(p)))).reduce((n, s) => n + s.size + 1024, 0);
+                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: () => openCodexSessionRevision(candidate.segmentPaths, { maxFileBytes: RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, expectedHash: candidate.revisionHash }),
+                            openSource,
                         } } };
             } } : {}),
         redactedSummary: "Raw Codex JSONL transcript with prompts, responses, tool arguments, and tool outputs preserved locally.",

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

@@ -9,8 +9,9 @@
  * bytes cannot be rebuilt, and the old path uploaded the original bytes when nothing changed.
  * The order stays image replacement, slim, redact.
  */
-import { TranscriptReadError } from "./transcript-text-stream.js";
 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";
@@ -18,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 === "pi_jsonl" ? "pi" : 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) {
@@ -55,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.kind === "pi_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.

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

@@ -172,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");
@@ -294,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" || kind === "pi_jsonl"))
+        return 1024 * 1024;
     const session = collection.budget.images;
     if (!session?.prepareTranscriptFile || !agentOfKind(kind))
         return null;

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

@@ -77,9 +77,10 @@ export async function readTranscriptWhole(file) {
 async function streamCompositeWithoutImages(file) {
     if (!file.stageDir)
         throw new TranscriptReadError("composite_staging_unavailable", new Error("composite_staging_unavailable"));
-    const source = await file.openSource();
+    let source;
     let writer;
     try {
+        source = await file.openSource();
         writer = await openStagedOutput(file.stageDir);
         await copyLinesStream(source.lines(), writer);
         await source.verifyUnchanged();
@@ -88,10 +89,12 @@ async function streamCompositeWithoutImages(file) {
         return { held: { text: null, exactBytes: null, staged }, volatile: true, pendingImages: null, readBytes: source.length };
     }
     catch (error) {
-        await writer?.abandon();
+        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();
+        await source?.close().catch(() => console.error(TAG + " composite source cleanup failed", JSON.stringify({ reason: "file_close_failed", kind: file.kind })));
     }
 }

package/dist/adapters/raw-evidence.js

@@ -61,6 +61,10 @@ import { DEFAULT_SESSION_LIMIT, DEFAULT_SINCE_MINUTES, newStagingDir, openCollec
 import { finishWithEmptyPack, finishWithFailedPack, finishWithPromotedPack, } from "./raw-evidence-facts.js";
 import { collectCodexJsonlFiles } from "./raw-evidence-codex-reader.js";
 import { collectClaudeJsonlFiles } from "./raw-evidence-claude-reader.js";
+import { collectOneEvidenceFile } from "./raw-evidence-transcript-file.js";
+import { recordScanned } from "./raw-evidence-completeness.js";
+import { safeKeySegment } from "./raw-evidence-keys.js";
+import { RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES } from "@bli-cockpit/telemetry-core";
 import { collectGitDiffFiles } from "./raw-evidence-git-diff-reader.js";
 // Re-exported so every consumer keeps importing from `adapters/raw-evidence`.
 export { RAW_EVIDENCE_BUCKET, RAW_EVIDENCE_RETENTION_MODE, } from "./raw-evidence-manifest.js";
@@ -140,6 +144,15 @@ async function collectEverySource(collection, options, sinceMinutes) {
     if (options.includeClaudeJsonl !== false && options.claudeSessionFiles) {
         await collectClaudeJsonlFiles(collection, options.claudeSessionFiles);
     }
+    for (const file of options.nativeSessionFiles ?? []) {
+        recordScanned(collection, file.source === "pi" ? "pi_jsonl" : "opencode_jsonl");
+        await collectOneEvidenceFile(collection, {
+            filePath: file.local_path, kind: file.source === "pi" ? "pi_jsonl" : "opencode_jsonl", sessionId: file.session_id, priorRedaction: file.redaction,
+            mediaType: "application/jsonl", maxFileBytes: RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES,
+            redactedSummary: "Native coding session with retained messages, tools, usage and unknown records.",
+            contentAddress: (hash16) => `${file.source}/${safeKeySegment(file.session_id)}/${hash16}.jsonl`,
+        });
+    }
     await collectGitDiffFiles(collection, options.repoRoot);
 }
 // ---------------------------------------------------------------------------