@bli-cockpit/cli 0.2.292 → 0.2.294

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, "opencode_jsonl");
+        await collectOneEvidenceFile(collection, {
+            filePath: file.local_path, kind: "opencode_jsonl", sessionId: file.session_id, priorRedaction: file.redaction,
+            mediaType: "application/jsonl", maxFileBytes: RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES,
+            redactedSummary: "OpenCode native session with retained messages, tools, usage and unknown records.",
+            contentAddress: (hash16) => `opencode/${safeKeySegment(file.session_id)}/${hash16}.jsonl`,
+        });
+    }
     await collectGitDiffFiles(collection, options.repoRoot);
 }
 // ---------------------------------------------------------------------------

package/dist/adapters/t3-projection-source.js

@@ -0,0 +1,96 @@
+/** Bounded session-only SQLite projections. No settings, credentials, DB copies or long-lived transactions. */
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { createHash } from "node:crypto";
+const MAX_ROWS = 10_000;
+const MAX_TEXT_BYTES = 32 * 1024 * 1024;
+const sha = (text) => createHash("sha256").update(text).digest("hex");
+function withDatabase(homeDir, absent, read) {
+    const file = path.join(homeDir, ".t3", "userdata", "statev2.sqlite");
+    if (!existsSync(file))
+        return absent;
+    let db;
+    try {
+        const { DatabaseSync } = createRequire(import.meta.url)("node:sqlite");
+        db = new DatabaseSync(file, { readOnly: true });
+        return read(db);
+    }
+    catch (error) {
+        const reason = error instanceof Error && error.message.startsWith("t3_projection_") ? error.message : "t3_projection_unreadable";
+        console.error("[t3-projection] source unavailable", JSON.stringify({ reason }));
+        throw new Error(reason);
+    }
+    finally {
+        db?.close();
+    }
+}
+/** The small identity inventory lets singleton native sessions use the same composite path. */
+export function t3CodexProjectionSessionIds(homeDir = os.homedir()) {
+    return withDatabase(homeDir, new Set(), db => {
+        const rows = db.prepare(`SELECT DISTINCT json_extract(payload_json, '$.nativeThreadRef.nativeId') AS native_id
+      FROM orchestration_v2_projection_provider_threads WHERE driver = 'codex'
+      AND json_extract(payload_json, '$.nativeThreadRef.driver') = 'codex'
+      AND json_extract(payload_json, '$.nativeThreadRef.strength') = 'strong'
+      ORDER BY native_id LIMIT ${MAX_ROWS + 1}`).all();
+        if (rows.length > MAX_ROWS)
+            throw new Error("t3_projection_inventory_capped");
+        return new Set(rows.flatMap(r => typeof r["native_id"] === "string" && r["native_id"] ? [r["native_id"]] : []));
+    });
+}
+/** One SELECT pins the WAL snapshot; only explicit observed assistant and strong native identity fields leave SQLite. */
+export function readT3CodexProjection(nativeSessionId, homeDir = os.homedir()) {
+    return withDatabase(homeDir, [], db => {
+        const rows = db.prepare(`SELECT m.message_id, m.thread_id, m.created_at, m.updated_at,
+      CASE WHEN length(CAST(json_extract(m.payload_json, '$.text') AS BLOB)) <= ${MAX_TEXT_BYTES}
+        THEN json_extract(m.payload_json, '$.text') END AS text,
+      length(CAST(json_extract(m.payload_json, '$.text') AS BLOB)) AS text_bytes,
+      json_extract(i.payload_json, '$.nativeItemRef.nativeId') AS item_id,
+      json_extract(t.payload_json, '$.nativeTurnRef.nativeId') AS turn_id
+      FROM orchestration_v2_projection_provider_threads AS p
+      CROSS JOIN orchestration_v2_projection_turn_items AS i ON i.thread_id = p.thread_id AND i.provider_thread_id = p.provider_thread_id
+      JOIN orchestration_v2_projection_provider_turns AS t ON t.provider_turn_id = i.provider_turn_id AND t.provider_thread_id = p.provider_thread_id
+      JOIN orchestration_v2_projection_messages AS m ON m.message_id = json_extract(i.payload_json, '$.messageId') AND m.thread_id = i.thread_id AND m.run_id = i.run_id
+      WHERE p.driver = 'codex' AND json_extract(p.payload_json, '$.nativeThreadRef.nativeId') = ?
+      AND json_extract(p.payload_json, '$.nativeThreadRef.driver') = 'codex'
+      AND json_extract(p.payload_json, '$.nativeThreadRef.strength') = 'strong'
+      AND i.type = 'assistant_message' AND m.role = 'assistant' AND m.streaming = 0
+      AND json_extract(i.payload_json, '$.nativeItemRef.driver') = 'codex'
+      AND json_extract(i.payload_json, '$.nativeItemRef.strength') = 'strong'
+      AND json_extract(t.payload_json, '$.nativeTurnRef.driver') = 'codex'
+      AND json_extract(t.payload_json, '$.nativeTurnRef.strength') = 'strong'
+      ORDER BY m.created_at, m.message_id, turn_id, item_id LIMIT ${MAX_ROWS + 1}`).iterate(nativeSessionId);
+        const messages = [];
+        // CROSS JOIN pins the small provider-thread inventory outermost; otherwise
+        // installed SQLite scans every unrelated turn-item payload before filtering.
+        let textBytes = 0, projectionBytes = 0, returned = 0;
+        for (const r of rows) {
+            if (++returned > MAX_ROWS)
+                throw new Error("t3_projection_messages_capped");
+            if (typeof r["text_bytes"] === "number" && r["text_bytes"] > MAX_TEXT_BYTES)
+                throw new Error("t3_projection_bytes_capped");
+            if (typeof r["text"] !== "string" || !r["text"].trim())
+                continue;
+            textBytes += Buffer.byteLength(r["text"]);
+            if (textBytes > MAX_TEXT_BYTES)
+                throw new Error("t3_projection_bytes_capped");
+            for (const field of ["message_id", "thread_id", "item_id", "turn_id", "created_at", "updated_at"]) {
+                if (typeof r[field] !== "string" || !r[field])
+                    throw new Error("t3_projection_mapping_invalid");
+            }
+            const message = { schema_version: "t3-message.v1", native_session_id: nativeSessionId,
+                native_turn_id: r["turn_id"], native_item_id: r["item_id"],
+                t3_thread_id: r["thread_id"], t3_message_id: r["message_id"],
+                role: "assistant", created_at: r["created_at"], updated_at: r["updated_at"],
+                text_sha256: sha(r["text"]), text: r["text"], provenance: "t3-0.1.7:orchestration_v2_projection_messages" };
+            projectionBytes += Buffer.byteLength(JSON.stringify(message));
+            if (projectionBytes > MAX_TEXT_BYTES)
+                throw new Error("t3_projection_bytes_capped");
+            messages.push(message);
+        }
+        return messages;
+    });
+}
+/** Hashes include source identity, timestamps and original text revisions, not database/WAL file stamps. */
+export function t3ProjectionRevision(messages) { return sha(JSON.stringify(messages)); }

package/dist/collection-scope.js

@@ -146,6 +146,8 @@ export function cwdInsideRoots(cwd, roots) {
  * it cannot be proven inside, so it is withheld.
  */
 export function sessionInsideRoots(result, roots) {
+    if (result.local_cwds)
+        return result.local_cwds.length > 0 && result.local_cwds.every(cwd => cwdInsideRoots(cwd, roots) || Boolean(result.worktree && cwdInsideRoots(cwd, [result.worktree.repo_root])));
     if (cwdInsideRoots(result.local_cwd, roots))
         return true;
     return Boolean(result.worktree && cwdInsideRoots(result.local_cwd, [result.worktree.repo_root]));

package/dist/commands/backfill-checkpoint.js

@@ -37,7 +37,8 @@ export async function recordBackfillDurableSessionPointers(options) {
             // delivery, so a real pointer replaces it and the mark clears.
             // BLI-11119: an entry the cursor itself knows is `stubbed` counts too.
             const replacesStub = Boolean(prior?.stub_reoffer || prior?.stubbed) && prior?.uploaded_object_key !== objectKey;
-            if (!objectKey || !prior || (prior.uploaded_object_key && !replacesStub))
+            const replacesRevision = candidate.source === "codex" && prior?.uploaded_source_revision !== candidate.content_hash_sha256;
+            if (!objectKey || (prior?.uploaded_object_key && !replacesStub && !replacesRevision))
                 continue;
             if (replacesStub && !isRedactionStubObjectKey(objectKey))
                 stubsReplaced += 1;
@@ -61,6 +62,7 @@ function deliveredCursorEntry(prior, candidate, objectKey, now) {
     const entry = {
         ...prior,
         file_hash_sha256: candidate.content_hash_sha256,
+        uploaded_source_revision: candidate.t3_projection_incomplete || isRedactionStubObjectKey(objectKey) ? prior?.uploaded_source_revision ?? null : candidate.content_hash_sha256,
         file_mtime_ms: candidate.session_file_mtime_ms,
         byte_size: candidate.byte_size,
         // The whole file was delivered, so the incremental reader starts at its end.

package/dist/commands/backfill-history-scan.js

@@ -0,0 +1,38 @@
+/** Keep complete-history rescans separate from candidate selection and cursor policy. */
+import { scanAndAttributeCodexSessions } from "../adapters/codex-attribution.js";
+import { scanAndAttributeClaudeSessions } from "../adapters/claude-attribution.js";
+/**
+ * The adapter's own limit is a memory guard, not permission to silently leave
+ * history undiscovered. When it fires, re-scan the exact discovered population
+ * so a user-facing `--max-files` cap can resume from a truthful ordering.
+ */
+export async function scanCodexHistory(request, sessionsDirs, scanLimit) {
+    const scan = (limit) => scanAndAttributeCodexSessions({
+        sessionsDirs,
+        worktrees: request.worktrees,
+        now: request.now,
+        sinceMinutes: request.window.since_minutes,
+        limit,
+        collectionRoots: request.collectionRoots,
+    });
+    const firstPass = await scan(scanLimit);
+    if (!firstPass.session_limit_applied)
+        return firstPass;
+    return scan(Math.max(scanLimit + 1, firstPass.discovered_file_count));
+}
+/** Same rule for the Claude store: a capped first pass is rescanned in full. */
+export async function scanClaudeHistory(request, projectsDirs, scanLimit) {
+    const scan = (limit) => scanAndAttributeClaudeSessions({
+        projectsDir: projectsDirs[0],
+        projectsDirs,
+        worktrees: request.worktrees,
+        now: request.now,
+        sinceMinutes: request.window.since_minutes,
+        limit,
+        collectionRoots: request.collectionRoots,
+    });
+    const firstPass = await scan(scanLimit);
+    if (!firstPass.session_limit_applied)
+        return firstPass;
+    return scan(Math.max(scanLimit + 1, firstPass.discovered_session_count));
+}

package/dist/commands/backfill-issues.js

@@ -29,36 +29,38 @@ import { candidateCursorKey } from "./backfill-candidates.js";
 export async function backfillScanIssues(options) {
     const issues = [];
     if (options.codexAttribution) {
-        await addCodexStoreScanIssues(issues, options.codexAttribution, options.codexSessionDirs);
+        await addCodexStoreScanIssues(issues, options.codexAttribution);
     }
     if (options.claudeAttribution) {
-        await addClaudeStoreScanIssues(issues, options.claudeAttribution, options.claudeProjectsDir, options.candidates);
+        await addClaudeStoreScanIssues(issues, options.claudeAttribution, options.candidates);
     }
     addCandidateScanIssues(issues, options.candidates, options.omittedCandidateCount);
     sortScanIssuesByPriority(issues);
     return issues;
 }
 /** What the archived Codex store could not tell us — every one of these hides history. */
-async function addCodexStoreScanIssues(issues, codexAttribution, codexSessionDirs) {
+async function addCodexStoreScanIssues(issues, codexAttribution) {
     countScanIssue(issues, "codex_session_limit_applied", codexAttribution.session_limit_applied
         ? Math.max(1, codexAttribution.discovered_file_count -
             codexAttribution.scanned_file_count)
         : 0, "global");
-    // A session directory that simply does not exist on this machine is not a
-    // read failure; subtract those before reporting one.
-    const missingTopLevelDirs = (await Promise.all(codexSessionDirs.map(isMissingPath))).filter(Boolean).length;
-    countScanIssue(issues, "codex_directory_read_failed", Math.max(0, codexAttribution.directory_read_failed_count - missingTopLevelDirs), "global");
+    // The reader already excludes ENOENT. Subtracting absent default roots
+    // here would erase a failure in another configured home or T3 discovery.
+    countScanIssue(issues, "codex_directory_read_failed", codexAttribution.directory_read_failed_count, "global");
     countScanIssue(issues, "codex_session_stat_failed", codexAttribution.stat_failed_count, "global");
+    if (codexAttribution.projection_failure_reason)
+        countScanIssue(issues, codexAttribution.projection_failure_reason, 1, "global");
+    for (const result of codexAttribution.results)
+        if (result.t3_projection_failure_reason)
+            countScanIssue(issues, result.t3_projection_failure_reason, 1, "global");
 }
 /** The same census for the Claude store, which also has sidecars to account for. */
-async function addClaudeStoreScanIssues(issues, claudeAttribution, claudeProjectsDir, candidates) {
+async function addClaudeStoreScanIssues(issues, claudeAttribution, candidates) {
     countScanIssue(issues, "claude_session_limit_applied", claudeAttribution.session_limit_applied
         ? Math.max(1, claudeAttribution.discovered_session_count -
             claudeAttribution.scanned_session_count)
         : 0, "global");
-    const projectsDirMissing = await isMissingPath(claudeProjectsDir);
-    countScanIssue(issues, "claude_project_dir_read_failed", Math.max(0, claudeAttribution.project_dir_read_failed_count -
-        (projectsDirMissing ? 1 : 0)), "global");
+    countScanIssue(issues, "claude_project_dir_read_failed", claudeAttribution.project_dir_read_failed_count, "global");
     countScanIssue(issues, "claude_session_stat_failed", claudeAttribution.session_stat_failed_count, "global");
     countScanIssue(issues, "claude_sidecar_stat_failed", claudeAttribution.sidecar_stat_failed_count, "global");
     countScanIssue(issues, "claude_sidecar_dir_read_failed", await countUnreadableClaudeSidecarDirs(candidates), "global");
@@ -151,15 +153,6 @@ async function countUnreadableClaudeSidecarDirs(candidates) {
     }
     return unreadable;
 }
-async function isMissingPath(filePath) {
-    try {
-        await fs.stat(filePath);
-        return false;
-    }
-    catch (error) {
-        return isMissingFsError(error);
-    }
-}
 function isMissingFsError(error) {
     if (!error || typeof error !== "object")
         return false;

package/dist/commands/backfill-output.js

@@ -16,6 +16,12 @@ export function writeDryRunSummary(io, options) {
     writeLine(io.stdout, `Verify after upload: ${options.dashboardUrl}/my-work`);
 }
 export function writeHumanBackfillResult(result, io) {
+    if (result.opencode) {
+        const source = result.opencode;
+        writeLine(io.stdout, `OpenCode: ${source.discovered} discovered, ${source.eligible} eligible, ${source.delivered} delivered, ${source.pending} pending, ${source.withheld} withheld (${source.coverage}).`);
+        for (const reason of source.reasons)
+            writeLine(io.stderr, `OpenCode: ${reason}`);
+    }
     if (result.status === "complete") {
         writeLine(io.stdout, `PASS: ${result.counts.backfilled} backfilled, ${result.counts.skipped} skipped (table). Verify: ${result.verify_url}`);
         writeReasonTable(io, result.counts.reasons);

package/dist/commands/backfill-report.js

@@ -18,7 +18,7 @@ import { summarizeStubReoffer } from "./backfill-stub-reoffer.js";
  * blocks completion on its own — every completion-gating computation below
  * excludes it explicitly via `oversizedCandidateKeys`/`blockingScanIssues`.
  */
-export async function reportBackfillOutcome(command, io, ctx, upload) {
+export async function reportBackfillOutcome(command, io, ctx, upload, nativePartial = false) {
     let { blockedAt, failureReason } = upload;
     const posted = await postBackfillSessionReport(command, io, ctx, upload);
     if (!posted.acknowledged && !blockedAt) {
@@ -36,8 +36,8 @@ export async function reportBackfillOutcome(command, io, ctx, upload) {
         ctx,
         upload,
         posted,
-        stoppedEarly: Boolean(blockedAt),
-        failureReason,
+        stoppedEarly: Boolean(blockedAt) || nativePartial,
+        failureReason: failureReason ?? (nativePartial ? "opencode_backfill_pending" : undefined),
     });
     if (completion.status === "complete" && command.all && !command.stubPass) {
         await writeAllHistoryCompletionMarker(ctx);

package/dist/commands/backfill-scan.js

@@ -1,3 +1,5 @@
+import { scanCodexHistory, scanClaudeHistory } from "./backfill-history-scan.js";
+import { nativeSessionRoots } from "../native-session-roots.js";
 /**
  * SCAN: read both archived session stores and turn them into the candidates
  * this run will consider, then census what could not be accounted for.
@@ -9,9 +11,6 @@
  * on what was missed before what merely arrived.
  */
 import os from "node:os";
-import path from "node:path";
-import { scanAndAttributeClaudeSessions, } from "../adapters/claude-attribution.js";
-import { defaultCodexSessionDirs, scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
 import { emptyBackfillCursorState, prepareBackfillCursorForScope, readBackfillCursor, } from "../cursors/backfill-cursor.js";
 import { CLAUDE_CURSOR_FILENAME, readRawEvidenceCursor, } from "../cursors/raw-evidence-cursor.js";
 import { liveWindowMsFor, scopeBackfillCandidates } from "./backfill-live-window.js";
@@ -136,10 +135,15 @@ async function auditScannedCandidates(scan, discoveryIncompleteReasons) {
  */
 async function scanBackfillSessions(options) {
     const scanLimit = options.command.maxFiles ?? 10_000;
-    const codexSessionDirs = defaultCodexSessionDirs(options.homeDir);
-    const claudeProjectsDir = path.join(options.homeDir, ".claude", "projects");
+    const { codex: codexSessionDirs, claudeProjects: claudeProjectsDir, claudeProjectDirs, discoveryFailed } = nativeSessionRoots(options.homeDir);
     const codexScanned = options.sources.includes("codex") ? await scanCodexHistory(options, codexSessionDirs, scanLimit) : null;
-    const claudeScanned = options.sources.includes("claude_code") ? await scanClaudeHistory(options, claudeProjectsDir, scanLimit) : null;
+    const claudeScanned = options.sources.includes("claude_code") ? await scanClaudeHistory(options, claudeProjectDirs, scanLimit) : null;
+    if (discoveryFailed) {
+        if (codexScanned)
+            codexScanned.directory_read_failed_count += 1;
+        if (claudeScanned)
+            claudeScanned.project_dir_read_failed_count += 1;
+    }
     // BLI-23590 withholds sessions outside the approved roots first; BLI-23478 then keeps drawer sessions home.
     const scoped = scopeHistoryScans(options, codexScanned, claudeScanned);
     const { codexAttribution, claudeAttribution } = shelveBackfillScan(scoped.codex, scoped.claude, options.shelfDecision);
@@ -155,6 +159,13 @@ async function scanBackfillSessions(options) {
         sinceMinutes: options.window.since_minutes,
     });
     const liveWindowMs = liveWindowMsFor(options.command);
+    const durableCodex = await readRawEvidenceCursor(getCollectorRuntimePaths(options.homeDir));
+    for (const c of scanned) {
+        const prior = durableCodex.sessions[c.session_id];
+        if (c.source === "codex" && (c.segment_paths || prior?.uploaded_source_revision) &&
+            prior?.uploaded_source_revision !== c.content_hash_sha256)
+            options.pointerlessTerminalSessions.codex.add(c.session_id);
+    }
     const selection = selectBackfillCandidates({
         scanned,
         cursor: options.cursor,
@@ -188,40 +199,6 @@ async function scanBackfillSessions(options) {
         live_window_ms: liveWindowMs,
     };
 }
-/**
- * The adapter's own limit is a memory guard, not permission to silently leave
- * history undiscovered. When it fires, re-scan the exact discovered population
- * so a user-facing `--max-files` cap can resume from a truthful ordering.
- */
-async function scanCodexHistory(request, sessionsDirs, scanLimit) {
-    const scan = (limit) => scanAndAttributeCodexSessions({
-        sessionsDirs,
-        worktrees: request.worktrees,
-        now: request.now,
-        sinceMinutes: request.window.since_minutes,
-        limit,
-        collectionRoots: request.collectionRoots,
-    });
-    const firstPass = await scan(scanLimit);
-    if (!firstPass.session_limit_applied)
-        return firstPass;
-    return scan(Math.max(scanLimit + 1, firstPass.discovered_file_count));
-}
-/** Same rule for the Claude store: a capped first pass is rescanned in full. */
-async function scanClaudeHistory(request, projectsDir, scanLimit) {
-    const scan = (limit) => scanAndAttributeClaudeSessions({
-        projectsDir,
-        worktrees: request.worktrees,
-        now: request.now,
-        sinceMinutes: request.window.since_minutes,
-        limit,
-        collectionRoots: request.collectionRoots,
-    });
-    const firstPass = await scan(scanLimit);
-    if (!firstPass.session_limit_applied)
-        return firstPass;
-    return scan(Math.max(scanLimit + 1, firstPass.discovered_session_count));
-}
 /**
  * Which scanned sessions this run will actually work on. A session is in play
  * if the cursor has not passed it, or if it is a terminal session that never
@@ -291,6 +268,9 @@ function normalizeCodexCandidate(result) {
     return {
         source: "codex",
         session_id: result.codex_session_id,
+        ...(result.segment_paths ? { segment_paths: result.segment_paths } : {}),
+        ...(result.t3_projection ? { t3_projection: true } : {}),
+        ...(result.t3_projection_incomplete ? { t3_projection_incomplete: true } : {}),
         session_id_source: result.session_id_source,
         file_path: result.file_path,
         state: result.state,

package/dist/commands/backfill-scope.js

@@ -98,6 +98,8 @@ async function discoverBackfillWorktrees(roots, command) {
     });
 }
 export function selectedSources(source) {
+    if (source === "opencode")
+        return []; // Native inventory and cursor are handled by the shared native pass.
     if (source === "codex")
         return ["codex"];
     if (source === "claude")

package/dist/commands/backfill-upload.js

@@ -19,10 +19,10 @@ const BACKFILL_MAX_CONSECUTIVE_FAILURES = 3;
  * missing" would fail every batch it happens to share with genuinely uploaded
  * siblings, so it is excluded via `oversizedCandidateKeys` throughout.
  */
-export async function uploadBackfillBatches(command, io, lock, ctx) {
+export async function uploadBackfillBatches(command, io, lock, ctx, sharedBudget) {
     const uploadable = uploadableCandidates(ctx.scan.candidates);
     const batches = planUploadBatches(command, uploadable);
-    const rawEvidenceBudget = {
+    const rawEvidenceBudget = sharedBudget ?? {
         remainingBytes: RAW_EVIDENCE_DEFAULT_BYTE_BUDGET,
         remainingObjects: RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET,
     };
@@ -231,6 +231,8 @@ function backfillBatchSyncOptions(options) {
             .map((candidate) => ({
             local_path: candidate.file_path,
             codex_session_id: candidate.session_id,
+            ...(candidate.t3_projection ? { t3_projection: true } : {}),
+            ...(candidate.segment_paths ? { segment_paths: candidate.segment_paths, revision_hash: candidate.content_hash_sha256 ?? undefined, revision_bytes: candidate.byte_size } : {}),
         })),
         codexAttributionScan: options.codexAttribution ?? undefined,
         claudeSessionFiles: options.batch.candidates

package/dist/commands/backfill.js

@@ -37,6 +37,8 @@
  * both earned a durable pointer and were acknowledged by the server, so a
  * misjudged "resolved" loses that history for good.
  */
+import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET } from "../adapters/raw-evidence.js";
+import { syncOpenCodeSessions } from "./opencode-sync.js";
 import { acquireBackfillLock } from "../backfill-lock.js";
 import { writeBackfillCursor } from "../cursors/backfill-cursor.js";
 import { DEFAULT_BACKFILL_SINCE_DAYS, backfillRetryCommand, defaultBackfillWindowNotice, } from "./backfill-command-line.js";
@@ -105,8 +107,16 @@ export async function runBackfill(command, io) {
     if (scanned.kind === "blocked")
         return scanned.result;
     const plan = await planBackfillRun(command, io, scanned);
-    if (plan.kind === "result")
+    if (plan.kind === "result") {
+        if (command.dryRun && (!command.source || command.source === "opencode") && plan.result.status !== "blocked") {
+            plan.result.opencode = await syncOpenCodeSessions({ homeDir: scanned.paths.home_dir, worktrees: scanned.worktrees, collectionRoots: scanned.collectionRoots,
+                dashboardUrl: scanned.dashboardUrl, fetchImpl: io.fetch ?? globalThis.fetch, dryRun: true,
+                sinceMs: command.all ? undefined : now.getTime() - (command.sinceDays ?? DEFAULT_BACKFILL_SINCE_DAYS) * 86400000 });
+            if (plan.result.opencode.coverage === "partial")
+                plan.result.status = "partial";
+        }
         return plan.result;
+    }
     const { paths } = scanned;
     // BLI-11112: the sync's stub pass does not take the backfill lock. It runs
     // under the collection lock, which already serialises it against any
@@ -144,8 +154,15 @@ export async function runBackfill(command, io) {
         // BLI-11102: mark server-named stubs as not delivered, under the lock
         // because sync writes the same cursor files.
         await markStubReoffers(paths, scanned.stubReoffer, now);
-        const upload = await uploadBackfillBatches(command, io, lock, scanned);
-        return await reportBackfillOutcome(command, io, scanned, upload);
+        const budget = { remainingBytes: RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, remainingObjects: RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET };
+        const upload = await uploadBackfillBatches(command, io, lock, scanned, budget);
+        const opencode = (!command.source || command.source === "opencode") ? await syncOpenCodeSessions({ homeDir: paths.home_dir, worktrees: scanned.worktrees, collectionRoots: scanned.collectionRoots,
+            dashboardUrl: scanned.dashboardUrl, fetchImpl: io.fetch ?? globalThis.fetch, budget, deadlineMs: command.deadlineMs,
+            sinceMs: command.all ? undefined : now.getTime() - (command.sinceDays ?? DEFAULT_BACKFILL_SINCE_DAYS) * 86400000 }) : undefined;
+        const result = await reportBackfillOutcome(command, io, scanned, upload, opencode?.coverage === "partial");
+        if (opencode)
+            result.opencode = opencode;
+        return result;
     }
     finally {
         await collectionLock.handle.release();

package/dist/commands/codex-revision-facts.js

@@ -0,0 +1,64 @@
+/** Compare a composite revision with the SAME line/slim/redaction rules as upload. No raw bundle or network. */
+import { createHash } from "node:crypto";
+import { findEmbeddedImages, modeDropsImages, replaceImagesWithMarkers } from "@bli-cockpit/telemetry-core";
+import { imageStateKey } from "../image-description-state.js";
+import { openCodexSessionRevision } from "../adapters/codex-session-revision.js";
+import { createSlimmer } from "../slim/slim-transcript.js";
+import { scanLines, decideLinePlan, writeLinePlan } from "../adapters/raw-evidence-sanitize-lines.js";
+export function codexRevisionFacts(paths, mode, describedKeys, slimAware, t3Projection = false) {
+    const form = async (drop) => {
+        const source = await openCodexSessionRevision(paths, { t3Projection });
+        try {
+            const lines = { async *lines() {
+                    const slimmer = createSlimmer("codex");
+                    for await (const line of source.lines()) {
+                        if (line.start === source.length)
+                            continue;
+                        let text = new TextDecoder("utf-8", { fatal: true }).decode(line.bytes);
+                        if (drop) {
+                            const images = findEmbeddedImages(text);
+                            text = replaceImagesWithMarkers(text, images, image => describedKeys.has(imageStateKey(image.sha256))).text;
+                            text = slimmer.slimLine(text);
+                        }
+                        yield text + "\n";
+                    }
+                } };
+            const options = { redactedFields: ["codex_jsonl.body"], secretLikeFileName: false };
+            const plan = decideLinePlan(await scanLines(lines, options), options);
+            if (plan.kind === "whole_mask" || plan.kind === "guard_line")
+                return null;
+            const hash = createHash("sha256");
+            let byte_size = 0;
+            const write = async (text) => { hash.update(text); byte_size += Buffer.byteLength(text); };
+            if (plan.kind === "clean") {
+                for await (const line of lines.lines())
+                    await write(line);
+            }
+            else
+                await writeLinePlan(lines, plan, options, write);
+            await source.verifyUnchanged();
+            return { sha256: hash.digest("hex"), byte_size };
+        }
+        finally {
+            await source.close();
+        }
+    };
+    let full, slim;
+    return {
+        slimAware,
+        async rawSha256() { const source = await openCodexSessionRevision(paths, { t3Projection }); try {
+            return source.sha256;
+        }
+        finally {
+            await source.close();
+        } },
+        wholeForm: () => full ??= form(false),
+        sanitized: () => modeDropsImages(mode) ? slim ??= form(true) : full ??= form(false),
+        async slimSplit() {
+            if (!slimAware)
+                return null;
+            const [a, b] = await Promise.all([full ??= form(false), slim ??= form(true)]);
+            return a && b && a.sha256 !== b.sha256 ? { full: a, slim: b } : null;
+        },
+    };
+}

package/dist/commands/collection-report.js

@@ -32,6 +32,12 @@ function attributionReportLine(summary) {
 export function writeAgentSessionSummary(io, summary) {
     writeLine(io.stdout, sourceFunnelLine("Codex", summary.codex));
     writeLine(io.stdout, sourceFunnelLine("Claude", summary.claude));
+    if (summary.opencode) {
+        const source = summary.opencode;
+        writeLine(io.stdout, `OpenCode sessions: ${source.discovered} discovered, ${source.eligible} eligible, ${source.delivered} delivered, ${source.pending} pending, ${source.withheld} withheld (${source.coverage}).`);
+        for (const reason of source.reasons)
+            writeLine(io.stdout, `OpenCode: ${reason}`);
+    }
     const claudeDiagnostics = claudeDiagnosticsLine(summary);
     if (claudeDiagnostics)
         writeLine(io.stdout, claudeDiagnostics);

package/dist/commands/local-args-collector-status.js

@@ -69,8 +69,8 @@ export function parseSessionsArgs(args) {
     });
     assertNoPositionals(values.positionals, "sessions");
     const source = values.flags.get("--source");
-    if (source !== undefined && source !== "codex" && source !== "claude") {
-        throw new Error("--source must be 'codex' or 'claude'. Omit it to scan both.");
+    if (source !== undefined && source !== "codex" && source !== "claude" && source !== "opencode") {
+        throw new Error("--source must be 'codex', 'claude' or 'opencode'. Omit it to scan all sources.");
     }
     const sinceDays = optionalPositiveInteger(values.flags.get("--since-days"), "--since-days");
     const all = values.booleans.has("--all");

package/dist/commands/local-args-collector-work.js

@@ -151,8 +151,8 @@ export function parseBackfillArgs(args) {
     });
     assertNoPositionals(values.positionals, "backfill");
     const source = values.flags.get("--source");
-    if (source !== undefined && source !== "codex" && source !== "claude") {
-        throw new Error("--source must be 'codex' or 'claude'. Omit it to scan both.");
+    if (source !== undefined && source !== "codex" && source !== "claude" && source !== "opencode") {
+        throw new Error("--source must be 'codex', 'claude' or 'opencode'. Omit it to scan all sources.");
     }
     const sinceDays = optionalPositiveInteger(values.flags.get("--since-days"), "--since-days");
     const all = values.booleans.has("--all");

package/dist/commands/local-args-notes-targets.js

@@ -0,0 +1,35 @@
+/**
+ * The `--to` readers of `cockpit notes`: `move --to "<shelf>"` and, since BLI-24437,
+ * `correct <id> --from "<misheard>" --to "<right>" [--transcript]`. Sibling of
+ * `local-args-tower-notes.ts`, which calls both; split out so that file stays a table of contents.
+ */
+import { optionalNonEmpty } from "./local-arg-values.js";
+export function readNotesShelfTarget(action, values) {
+    const to = optionalNonEmpty(values.flags.get("--to"));
+    const clearShelf = values.booleans.has("--clear-shelf");
+    if (action !== "move")
+        return { to, clearShelf };
+    if (to && clearShelf) {
+        throw new Error("notes move accepts either --to or --clear-shelf, not both.");
+    }
+    if (!to && !clearShelf && !values.flags.get("--folder")) {
+        throw new Error('notes move needs --to "<shelf>", --clear-shelf, or --folder "<path>".');
+    }
+    return { to, clearShelf };
+}
+/** BLI-24437: `correct` needs both terms; `--from` and `--transcript` mean nothing on any other verb. */
+export function readNotesCorrection(action, values) {
+    const from = optionalNonEmpty(values.flags.get("--from"));
+    const transcript = values.booleans.has("--transcript");
+    if (action !== "correct") {
+        if (from !== undefined)
+            throw new Error("--from belongs to `cockpit notes correct <note-id> --from <term> --to <term>`.");
+        if (transcript)
+            throw new Error("--transcript belongs to `cockpit notes correct <note-id> --from <term> --to <term> --transcript`.");
+        return {};
+    }
+    if (!from || !optionalNonEmpty(values.flags.get("--to"))) {
+        throw new Error('notes correct needs --from "<misheard term>" and --to "<right term>".');
+    }
+    return { from, ...(transcript ? { transcript: true } : {}) };
+}