@bli-cockpit/cli 0.2.292 → 0.2.294

package/dist/commands/sessions.js

@@ -9,6 +9,8 @@
  */
 import os from "node:os";
 import path from "node:path";
+import { readOpenCodeInventory } from "../opencode-inventory.js";
+import { scoreSignalsAgainstWorktrees } from "../adapters/attribution-core.js";
 import { writeLine } from "./cli-io.js";
 import { discoverCommandWorktrees } from "./local-discovery.js";
 import { scanAndAttributeClaudeSessions } from "../adapters/claude-attribution.js";
@@ -30,19 +32,35 @@ export async function runSessions(command, io) {
     const window = await sessionsScanWindow(command, now);
     const { codex, claude } = await scanSessionSources(command, homeDir, worktrees, now, window);
     const { codexRows, claudeRows } = sessionRows(codex, claude);
+    const native = !command.source || command.source === "opencode" ? await readOpenCodeInventory({ homeDir,
+        stateDir: getCollectorRuntimePaths(homeDir).state_dir, metadataOnly: true,
+        sinceMs: window.since_minutes === null ? undefined : now.getTime() - window.since_minutes * 60_000 }) : null;
+    const opencode = native && (!native.absent || native.failures.length) ? { counts: { observed_count: native.discovered, read_failed: native.failures.length },
+        reasons: [...new Set(native.failures.map(failure => failure.reason))], sessions: native.sessions.map(session => {
+            const attributed = scoreSignalsAgainstWorktrees({ cwds: [session.directory], workspaceRoots: [], originUrls: [], branches: [], headShas: [] }, worktrees);
+            return { source: "opencode", session_id: session.id, state: attributed.state, reason: attributed.reason, attribution_score: attributed.attribution_score,
+                path_score: attributed.path_score, signals: attributed.signals, repo_label: attributed.worktree?.repo_label ?? null };
+        }) } : null;
     // BLI-3483: the scanners have always counted the folders and files they
     // could not read, and this command has always thrown those counts away
     // except for one field in `--json`. So "No sessions observed" was printed on
     // a machine where the scan had been blocked from looking — the operator's
     // one diagnostic tool answering the question with the failure removed.
     const readFailures = countReadFailures(codex, claude);
+    readFailures.total += native?.failures.length ?? 0;
     if (command.json) {
-        return writeSessionJson(io, window, readFailures, codex, claude, codexRows, claudeRows);
+        return writeSessionJson(io, window, readFailures, codex, claude, codexRows, claudeRows, opencode);
     }
-    return writeSessionText(io, window, readFailures, codexRows, claudeRows);
+    if (opencode) {
+        for (const row of opencode.sessions)
+            writeLine(io.stdout, sessionRowLine(row));
+        for (const reason of opencode.reasons)
+            writeLine(io.stdout, `OpenCode read incomplete: ${reason}`);
+    }
+    return writeSessionText(io, window, readFailures, codexRows, claudeRows, opencode?.sessions.length ?? 0);
 }
-function writeSessionText(io, window, readFailures, codexRows, claudeRows) {
-    writeLine(io.stdout, "Tower sessions (read-only attribution)");
+function writeSessionText(io, window, readFailures, codexRows, claudeRows, nativeCount = 0) {
+    writeLine(io.stdout, "TOWER sessions (read-only attribution)");
     writeLine(io.stdout, `window: ${sessionsWindowLine(window)}`);
     for (const row of codexRows) {
         writeLine(io.stdout, sessionRowLine(row));
@@ -53,7 +71,7 @@ function writeSessionText(io, window, readFailures, codexRows, claudeRows) {
             writeLine(io.stdout, `    sidecar ${sidecar.file_name}: ${sidecar.reason}`);
         }
     }
-    if (codexRows.length === 0 && claudeRows.length === 0) {
+    if (codexRows.length === 0 && claudeRows.length === 0 && nativeCount === 0) {
         writeLine(io.stdout, readFailures.total > 0
             ? `No sessions listed, but ${readFailures.total} read failure(s) mean the scan could not see everywhere — this is not proof there were none.`
             : "No sessions observed in the scan window.");
@@ -66,7 +84,7 @@ function writeSessionText(io, window, readFailures, codexRows, claudeRows) {
     return 0;
 }
 async function scanSessionSources(command, homeDir, worktrees, now, window) {
-    const codex = command.source !== "claude"
+    const codex = command.source !== "claude" && command.source !== "opencode"
         ? await scanAndAttributeCodexSessions({
             sessionsDirs: defaultCodexSessionDirs(homeDir),
             worktrees,
@@ -75,7 +93,7 @@ async function scanSessionSources(command, homeDir, worktrees, now, window) {
             limit: window.limit,
         })
         : null;
-    const claude = command.source !== "codex"
+    const claude = command.source !== "codex" && command.source !== "opencode"
         ? await scanAndAttributeClaudeSessions({
             projectsDir: path.join(homeDir, ".claude", "projects"),
             worktrees,
@@ -86,10 +104,11 @@ async function scanSessionSources(command, homeDir, worktrees, now, window) {
         : null;
     return { codex, claude };
 }
-function writeSessionJson(io, window, readFailures, codex, claude, codexRows, claudeRows) {
+function writeSessionJson(io, window, readFailures, codex, claude, codexRows, claudeRows, opencode) {
     writeLine(io.stdout, JSON.stringify({
         window,
         read_failures: readFailures,
+        ...(opencode ? { opencode } : {}),
         ...(codex ? { codex: { counts: codex.counts, sessions: codexRows } } : {}),
         ...(claude
             ? {

package/dist/commands/sources-check.js

@@ -28,6 +28,7 @@ import { CLAUDE_CURSOR_FILENAME, readRawEvidenceCursor, } from "../cursors/raw-e
 import { fetchTranscriptObjects } from "../evidence-transcripts-client.js";
 import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, readLocalCollectorConfig, readLocalCollectorSessionFile, } from "../local-state.js";
 import { discoverLocalTranscripts } from "./sources-discovery.js";
+import { OPENCODE_CURSOR_FILENAME } from "../opencode-inventory.js";
 import { fileFacts, judgeSource } from "./sources-verdict.js";
 const VERDICTS = ["stored_full", "stored_slim", "stored_partial", "not_stored"];
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -55,60 +56,66 @@ export async function runSourcesCheck(command, io, now = new Date()) {
     const switches = await readSourceSwitches(config, paths, "sources_check", { fetch: io.fetch });
     const optOutClaude = command.reconcile === true && !switches.claude;
     const optOutCodex = command.reconcile === true && !switches.codex;
-    const optOutAll = optOutClaude && optOutCodex;
+    const optOutAll = optOutClaude && optOutCodex && !switches.opencode;
     if (optOutClaude || optOutCodex) {
         console.error("[collector sources] reconcile skips opted-out sources", JSON.stringify({ codex_reason: optOutCodex ? switches.codexReason : null, claude_reason: optOutClaude ? switches.claudeReason : null }));
     }
-    const local = await discoverLocalTranscripts({ homeDir, olderThanMs, skipAll: optOutAll, skipClaude: optOutClaude, skipCodex: optOutCodex });
-    const cursors = {
-        codex: await readRawEvidenceCursor(paths),
-        claude_code: await readRawEvidenceCursor(paths, { filename: CLAUDE_CURSOR_FILENAME, sessionsOnly: true }),
-    };
-    const describedKeys = new Set(await readDescribedImageKeys(paths.state_dir));
-    // BLI-17273: judge against THIS machine's mode (the cache the sync-start receipt wrote, else the
-    // fleet default), never the bare constant. A machine that runs or ever ran slim holds slim server
-    // copies, which must never read as safe to delete.
-    const imageMode = await resolveImageHandlingMode(paths.state_dir);
-    console.error("[collector sources] judging against this machine's image mode", JSON.stringify({ reason: `image_mode_from_${imageMode.source}`, mode: imageMode.mode, slim_aware: imageMode.slimAware }));
-    const report = emptyReport(command, remote, local.newer_count, local.file_read_failed + local.directory_read_failed);
-    await judgeLocalTranscripts(local.files, remote, cursors, imageMode, describedKeys, report);
-    if (command.reconcile) {
-        const inventory = await fetchSourceInventory({ dashboardUrl, deviceToken: session.device_token, fetchImpl: io.fetch });
-        const { rows: _rows, ...inventoryCounts } = inventory;
-        const counts = { missing_row: 0, missing_pointer: 0, stale_revision: 0, unavailable_evidence: 0, explicit_opt_out: 0, unverifiable: 0, revision_verified: 0 };
-        const optOutSources = optOutAll ? ["codex", "claude_code"] : optOutClaude ? ["claude_code"] : [];
-        counts.explicit_opt_out = optOutSources.length;
-        for (const file of local.files) {
-            const finding = await reconcileSource({ file, inventory, remote,
-                cursor: file.kind === "claude_subagent" ? null : cursors[file.source].sessions[file.session_id] ?? null,
-                facts: fileFacts(file, undefined, { mode: imageMode.mode, describedKeys, slimAware: imageMode.slimAware }),
-            }).catch(() => ({ state: "unavailable_evidence", reason: "local_revision_unreadable" }));
-            counts[finding.state]++;
-            const entry = report.files.find(entry => entry.path === file.file_path);
-            if (entry)
-                entry.reconciliation = finding;
-        }
-        report.reconciliation = { counts, inventory: inventoryCounts,
-            scan: { started_at: new Date(startedAt).toISOString(), finished_at: new Date().toISOString(),
-                roots: ["codex/sessions", "codex/archived_sessions", "claude/projects"], older_than_days: command.olderThanDays, opt_out_sources: optOutSources },
-            limitations: ["Snapshot scan, not a live completeness guarantee; absent local sources cannot be discovered.", "Missing historical source identifiers remain unverifiable.", "Pointer metadata does not prove bucket bytes are readable; no storage bodies fetched.", "explicit_opt_out counts sources, not undiscovered files; opted-out stores are not scanned."],
+    const local = await discoverLocalTranscripts({ homeDir, olderThanMs, skipAll: optOutAll, skipClaude: optOutClaude, skipCodex: optOutCodex, skipOpenCode: !switches.opencode });
+    try {
+        const cursors = {
+            opencode: await readRawEvidenceCursor(paths, { filename: OPENCODE_CURSOR_FILENAME, sessionsOnly: true }),
+            codex: await readRawEvidenceCursor(paths),
+            claude_code: await readRawEvidenceCursor(paths, { filename: CLAUDE_CURSOR_FILENAME, sessionsOnly: true }),
         };
-        if (inventory.status !== "exhausted" || report.local.unreadable > 0 || counts.unavailable_evidence > 0) {
+        const describedKeys = new Set(await readDescribedImageKeys(paths.state_dir));
+        // BLI-17273: judge against THIS machine's mode (the cache the sync-start receipt wrote, else the
+        // fleet default), never the bare constant. A machine that runs or ever ran slim holds slim server
+        // copies, which must never read as safe to delete.
+        const imageMode = await resolveImageHandlingMode(paths.state_dir);
+        console.error("[collector sources] judging against this machine's image mode", JSON.stringify({ reason: `image_mode_from_${imageMode.source}`, mode: imageMode.mode, slim_aware: imageMode.slimAware }));
+        const report = emptyReport(command, remote, local.newer_count, local.file_read_failed + local.directory_read_failed);
+        await judgeLocalTranscripts(local.files, remote, cursors, imageMode, describedKeys, report);
+        if (command.reconcile) {
+            const inventory = await fetchSourceInventory({ dashboardUrl, deviceToken: session.device_token, fetchImpl: io.fetch });
+            const { rows: _rows, ...inventoryCounts } = inventory;
+            const counts = { missing_row: 0, missing_pointer: 0, stale_revision: 0, unavailable_evidence: 0, explicit_opt_out: 0, unverifiable: 0, revision_verified: 0 };
+            const optOutSources = optOutAll ? ["codex", "claude_code", "opencode"] : optOutClaude ? ["claude_code"] : [];
+            counts.explicit_opt_out = optOutSources.length;
+            for (const file of local.files) {
+                const finding = await reconcileSource({ file, inventory, remote,
+                    cursor: file.kind === "claude_subagent" ? null : cursors[file.source].sessions[file.session_id] ?? null,
+                    facts: fileFacts(file, undefined, { mode: imageMode.mode, describedKeys, slimAware: imageMode.slimAware }),
+                }).catch(() => ({ state: "unavailable_evidence", reason: "local_revision_unreadable" }));
+                counts[finding.state]++;
+                const entry = report.files.find(entry => entry.path === file.file_path);
+                if (entry)
+                    entry.reconciliation = finding;
+            }
+            report.reconciliation = { counts, inventory: inventoryCounts,
+                scan: { started_at: new Date(startedAt).toISOString(), finished_at: new Date().toISOString(),
+                    roots: ["codex/sessions", "codex/archived_sessions", "claude/projects", "opencode/opencode.db"], older_than_days: command.olderThanDays, opt_out_sources: optOutSources },
+                limitations: ["Snapshot scan, not a live completeness guarantee; absent local sources cannot be discovered.", "Missing historical source identifiers remain unverifiable.", "Pointer metadata does not prove bucket bytes are readable; no storage bodies fetched.", "explicit_opt_out counts sources, not undiscovered files; opted-out stores are not scanned."],
+            };
+            if (inventory.status !== "exhausted" || report.local.unreadable > 0 || counts.unavailable_evidence > 0) {
+                report.status = "incomplete";
+                report.reason = "reconciliation_partial";
+            }
+        }
+        if (report.local.unreadable > 0) {
             report.status = "incomplete";
-            report.reason = "reconciliation_partial";
+            report.reason = "local_scan_incomplete";
         }
+        reportSourcesCheck(report, remote, startedAt);
+        if (command.json)
+            writeLine(io.stdout, JSON.stringify(report, null, 2));
+        else
+            for (const line of sourcesCheckLines(report))
+                writeLine(io.stdout, line);
+        return 0;
     }
-    if (report.local.unreadable > 0) {
-        report.status = "incomplete";
-        report.reason = "local_scan_incomplete";
+    finally {
+        await local.cleanup?.();
     }
-    reportSourcesCheck(report, remote, startedAt);
-    if (command.json)
-        writeLine(io.stdout, JSON.stringify(report, null, 2));
-    else
-        for (const line of sourcesCheckLines(report))
-            writeLine(io.stdout, line);
-    return 0;
 }
 async function judgeLocalTranscripts(files, remote, cursors, imageMode, describedKeys, report) {
     for (const file of files) {
@@ -129,7 +136,7 @@ async function judgeLocalTranscripts(files, remote, cursors, imageMode, describe
         report.counts[judged.verdict].bytes += file.byte_size;
         report.reasons[judged.reason] = (report.reasons[judged.reason] ?? 0) + 1;
         report.files.push({
-            path: file.file_path,
+            path: file.source_locator ?? file.file_path,
             source: file.source,
             kind: file.kind,
             session_id: file.session_id,

package/dist/commands/sources-discovery.js

@@ -1,3 +1,6 @@
+import { openCodexSessionRevision } from "../adapters/codex-session-revision.js";
+import { nativeSessionRoots } from "../native-session-roots.js";
+import { t3CodexProjectionSessionIds } from "../adapters/t3-projection-source.js";
 /**
  * Every agent transcript on this machine, named the way the collector names
  * its upload (BLI-11122).
@@ -21,7 +24,12 @@
  * This module reads files and never writes, moves or deletes one.
  */
 import fs from "node:fs/promises";
+import { getCollectorRuntimePaths } from "../local-state.js";
+import { openCodeCollectionPolicy } from "../opencode-policy.js";
+import { readOpenCodeInventory } from "../opencode-inventory.js";
 import path from "node:path";
+import os from "node:os";
+import { openCodeDatabasePath } from "../adapters/opencode-store.js";
 import { createReadStream } from "node:fs";
 import readline from "node:readline";
 import { transcriptFileKey } from "@bli-cockpit/telemetry-core";
@@ -29,13 +37,7 @@ import { SESSION_FILE_UUID_PATTERN, sanitizeSessionId, sessionIdFromFileName, sh
 import { isSecretLikePath, safeKeySegment } from "../adapters/raw-evidence-keys.js";
 import { describeError } from "../health-detail.js";
 export function sourcesRoots(homeDir, pathApi = path) {
-    return {
-        codex: [
-            pathApi.join(homeDir, ".codex", "sessions"),
-            pathApi.join(homeDir, ".codex", "archived_sessions"),
-        ],
-        claudeProjects: pathApi.join(homeDir, ".claude", "projects"),
-    };
+    return nativeSessionRoots(homeDir, pathApi);
 }
 /** Which kind of transcript a path is, or null for anything the collector does not upload as one. */
 export function classifyTranscriptPath(filePath, roots, pathApi = path) {
@@ -46,7 +48,13 @@ export function classifyTranscriptPath(filePath, roots, pathApi = path) {
         if (rel && !rel.startsWith("..") && !pathApi.isAbsolute(rel))
             return { kind: "codex_rollout" };
     }
-    const rel = pathApi.relative(roots.claudeProjects, filePath);
+    const claudeRoot = (roots.claudeProjectDirs ?? [roots.claudeProjects]).find((root) => {
+        const relative = pathApi.relative(root, filePath);
+        return relative && !relative.startsWith("..") && !pathApi.isAbsolute(relative);
+    });
+    if (!claudeRoot)
+        return null;
+    const rel = pathApi.relative(claudeRoot, filePath);
     if (!rel || rel.startsWith("..") || pathApi.isAbsolute(rel))
         return null;
     const parts = rel.split(pathApi.sep);
@@ -128,15 +136,35 @@ function trimmed(value) {
 }
 /**
  * Walk every root, name every transcript. `olderThanMs` keeps only files whose
- * mtime is before it; the rest are counted, never read.
+ * revision mtime is before it. Native identities are read before that filter
+ * so an older segment cannot be misreported as the whole retained session.
  */
 export async function discoverLocalTranscripts(options) {
     const roots = sourcesRoots(options.homeDir);
-    const result = { files: [], newer_count: 0, directory_read_failed: 0, file_read_failed: 0 };
+    const result = { files: [], newer_count: 0, directory_read_failed: roots.discoveryFailed ? 1 : 0, file_read_failed: 0 };
     let firstFailure = null;
     const recordFailure = (error) => { firstFailure ??= describeError(error); };
     const found = await findTranscriptFiles(options, roots, result, recordFailure);
     await nameTranscriptFiles(found, result, recordFailure);
+    if (!options.skipAll && !options.skipOpenCode) {
+        const policy = await openCodeCollectionPolicy({ homeDir: options.homeDir });
+        const scratch = policy.enabled ? await fs.mkdtemp(path.join(os.tmpdir(), "tower-opencode-reconcile-")) : null;
+        if (scratch)
+            result.cleanup = () => fs.rm(scratch, { recursive: true, force: true });
+        const inventory = policy.enabled ? await readOpenCodeInventory({ homeDir: options.homeDir, stateDir: getCollectorRuntimePaths(options.homeDir).state_dir,
+            include: policy.include, readOnlyAccounting: true, exportDirectory: scratch }) : { files: [], failures: [] };
+        result.directory_read_failed += inventory.failures.length;
+        for (const file of inventory.files) {
+            if (options.olderThanMs !== null && file.session.updated_at_ms >= options.olderThanMs) {
+                result.newer_count += 1;
+                continue;
+            }
+            result.files.push({ source: "opencode", kind: "opencode_main", source_locator: `${process.env.OPENCODE_DB ?? openCodeDatabasePath(options.homeDir, process.env.XDG_DATA_HOME)}#${file.session.id}`, file_path: file.local_path, byte_size: file.byte_size, mtime_ms: file.session.updated_at_ms,
+                session_id: file.session.id, session_id_source: "content", key: transcriptFileKey({ source: "opencode", session_id: file.session.id, sidecar: null }) });
+        }
+    }
+    await groupCodexRevisions(result, options.homeDir);
+    result.files = result.files.filter(f => options.olderThanMs === null || f.mtime_ms < options.olderThanMs);
     if (result.directory_read_failed > 0 || result.file_read_failed > 0) {
         console.error("[collector sources] some transcripts could not be read; they are left out of the answer", JSON.stringify({
             reason: "sources_discovery_incomplete",
@@ -153,12 +181,17 @@ function shapeOrder(shape) {
 }
 async function findTranscriptFiles(options, roots, result, recordFailure) {
     const found = [];
-    const stack = options.skipAll ? [] : [...(options.skipCodex ? [] : roots.codex), ...(options.skipClaude ? [] : [roots.claudeProjects])];
+    const stack = options.skipAll ? [] : [...(options.skipCodex ? [] : roots.codex), ...(options.skipClaude ? [] : (roots.claudeProjectDirs ?? [roots.claudeProjects]))];
     const seen = new Set();
+    const visitedDirectories = new Set();
     while (stack.length > 0) {
         const dir = stack.pop();
         let entries;
         try {
+            const directoryIdentity = await fs.realpath(dir);
+            if (visitedDirectories.has(directoryIdentity))
+                continue;
+            visitedDirectories.add(directoryIdentity);
             entries = await fs.readdir(dir, { withFileTypes: true });
         }
         catch (error) {
@@ -187,10 +220,8 @@ async function findTranscriptFiles(options, roots, result, recordFailure) {
             });
             if (!stat)
                 continue;
-            if (options.olderThanMs !== null && stat.mtimeMs >= options.olderThanMs) {
+            if (options.olderThanMs !== null && stat.mtimeMs >= options.olderThanMs)
                 result.newer_count += 1;
-                continue;
-            }
             found.push({ file: full, size: stat.size, mtimeMs: stat.mtimeMs, shape });
         }
     }
@@ -237,4 +268,53 @@ async function nameTranscriptFiles(found, result, recordFailure) {
             key: transcriptKeyFor(source, named.session_id, item.shape.kind === "claude_subagent" ? item.shape.sidecar_stem : null),
         });
     }
+}
+/** One source row/pointer names the complete native session revision, never an arbitrary segment. */
+async function groupCodexRevisions(result, homeDir) {
+    let projectionIds = new Set();
+    try {
+        projectionIds = t3CodexProjectionSessionIds(homeDir);
+    }
+    catch {
+        result.file_read_failed++;
+    } // The reader logs the exact capped/unavailable reason; native files remain available.
+    const groups = new Map();
+    for (const file of result.files)
+        if (file.source === "codex") {
+            const group = groups.get(file.session_id) ?? [];
+            group.push(file);
+            groups.set(file.session_id, group);
+        }
+    const replacements = new Map();
+    for (const [id, files] of groups) {
+        if (files.length < 2 && !projectionIds.has(id))
+            continue;
+        const representative = [...files].sort((a, b) => a.file_path.localeCompare(b.file_path))[0];
+        const combined = { ...representative, segment_paths: files.map(f => f.file_path).sort(),
+            ...(projectionIds.has(id) ? { t3_projection: true } : {}),
+            segment_stamps: files.map(f => ({ path: f.file_path, size: f.byte_size, mtime: f.mtime_ms })),
+            byte_size: files.reduce((n, f) => n + f.byte_size, 0), mtime_ms: Math.max(...files.map(f => f.mtime_ms)) };
+        try {
+            const source = await openCodexSessionRevision(combined.segment_paths, { t3Projection: combined.t3_projection });
+            try {
+                combined.byte_size = source.length;
+            }
+            finally {
+                await source.close();
+            }
+        }
+        catch {
+            result.file_read_failed++;
+        }
+        replacements.set(id, combined);
+    }
+    const emitted = new Set();
+    result.files = result.files.flatMap(file => {
+        if (file.source !== "codex" || !replacements.has(file.session_id))
+            return [file];
+        if (emitted.has(file.session_id))
+            return [];
+        emitted.add(file.session_id);
+        return [replacements.get(file.session_id)];
+    });
 }

package/dist/commands/sources-reconciliation.js

@@ -22,7 +22,7 @@ export async function fetchSourceInventory(options) {
                 throw new Error("invalid_response");
             const valid = body.rows.every((row) => row && typeof row.id === "string" && uuid.test(row.id) &&
                 typeof row.source === "string" && (row.codex_session_id === null || typeof row.codex_session_id === "string") &&
-                (row.raw_evidence_pointer_id === null || (typeof row.raw_evidence_pointer_id === "string" && uuid.test(row.raw_evidence_pointer_id))));
+                (row.raw_evidence_pointer_id === null || (typeof row.raw_evidence_pointer_id === "string" && row.raw_evidence_pointer_id.trim().length > 0)));
             if (!valid)
                 throw new Error("invalid_response");
             const next = body.next_after;
@@ -67,14 +67,16 @@ export async function reconcileSource(input) {
         return inventory.status === "exhausted"
             ? answer("missing_pointer", "source_rows_without_pointer") : answer("unavailable_evidence", `row_inventory_${inventory.status}`);
     const objects = (remote.files.get(file.key) ?? []).filter(object => !object.stub &&
-        (file.kind === "claude_subagent" || (object.ref_id && pointers.has(object.ref_id))));
+        (file.kind === "claude_subagent" || ((object.ref_id && pointers.has(object.ref_id)) || pointers.has(object.object_key))));
     if (!objects.length)
         return answer("unavailable_evidence", remote.status === "exhausted" ? "pointer_not_in_current_transcripts_or_stub" : `transcripts_${remote.status}`);
     const split = facts.slimSplit ? await facts.slimSplit() : null;
     const form = split?.slim ?? (facts.slimAware && facts.wholeForm ? await facts.wholeForm() : await facts.sanitized());
-    const stat = await fs.stat(file.file_path);
-    if (stat.size !== file.byte_size || stat.mtimeMs !== file.mtime_ms)
-        return answer("unavailable_evidence", "local_file_changed_during_check");
+    for (const observed of file.segment_stamps ?? [{ path: file.file_path, size: file.byte_size, mtime: file.mtime_ms }]) {
+        const stat = await fs.stat(observed.path);
+        if (stat.size !== observed.size || stat.mtimeMs !== observed.mtime)
+            return answer("unavailable_evidence", "local_file_changed_during_check");
+    }
     if (form && objects.some(object => object.content_hash_sha256 === form.sha256 || object.content_hash_sha256 === split?.full.sha256))
         return answer("revision_verified", "current_redacted_hash_matches_pointer");
     // Sync refreshes the observed file hash even when growth damping retains an older

package/dist/commands/sources-verdict.js

@@ -32,6 +32,7 @@
  *
  * Read-only: this module reads the file and never writes, moves or deletes it.
  */
+import { codexRevisionFacts } from "./codex-revision-facts.js";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -162,6 +163,8 @@ upload = {}) {
     const mode = upload.mode ?? IMAGE_HANDLING_MODE;
     const describedKeys = upload.describedKeys ?? new Set();
     const slimAware = upload.slimAware ?? modeDropsImages(mode);
+    if (file.segment_paths)
+        return codexRevisionFacts(file.segment_paths, mode, describedKeys, slimAware, file.t3_projection);
     const redactForUpload = (text, original) => redactTranscriptForm(file, text, original);
     let split = null;
     let whole = null;
@@ -183,7 +186,7 @@ upload = {}) {
                 if (!buffer)
                     return null;
                 // Compare against what the uploader sends: in drop mode that is the slim form, not the disk bytes.
-                const uploadText = uploadFormOfTranscript(buffer.toString("utf8"), file.source === "codex" ? "codex" : "claude_code", mode, describedKeys);
+                const uploadText = file.source === "opencode" ? buffer.toString("utf8") : uploadFormOfTranscript(buffer.toString("utf8"), file.source, mode, describedKeys);
                 return redactForUpload(uploadText, buffer);
             });
             return sanitized;
@@ -199,7 +202,7 @@ upload = {}) {
                 if (!buffer)
                     return null;
                 const text = buffer.toString("utf8");
-                const slimText = uploadFormOfTranscript(text, file.source === "codex" ? "codex" : "claude_code", "describe_and_drop", describedKeys);
+                const slimText = uploadFormOfTranscript(text, file.source, "describe_and_drop", describedKeys);
                 // Slimming changes nothing: one form, and `sanitized()` is the answer.
                 if (slimText === text)
                     return null;

package/dist/cursors/raw-evidence-cursor.js

@@ -204,6 +204,7 @@ function parseSessionEntry(value) {
         return null;
     return {
         file_hash_sha256: optionalString(record["file_hash_sha256"]),
+        ...(typeof record["uploaded_source_revision"] === "string" ? { uploaded_source_revision: record["uploaded_source_revision"] } : {}),
         file_mtime_ms: optionalNumber(record["file_mtime_ms"]),
         byte_size: optionalNumber(record["byte_size"]),
         byte_offset: optionalNumber(record["byte_offset"]),

package/dist/image-description-session.js

@@ -16,7 +16,7 @@ import { sha256OfBase64Run } from "./image-byte-scan.js";
 import { addPdfsToFinds, mergeOccurrences, pdfsOfText } from "./pdf-transcript-step.js";
 import { openPinnedTranscript } from "./adapters/pinned-transcript.js";
 import { openStagedOutput, readStagedText } from "./adapters/staged-output.js";
-import { TranscriptNotStreamable } from "./adapters/transcript-text-stream.js";
+import { TranscriptNotStreamable, TranscriptTooLargeError } from "./adapters/transcript-text-stream.js";
 import { copyLinesStream } from "./slim/keep-line-copy.js";
 import { LineBytesSink, slimLineStream } from "./slim/slim-stream.js";
 import { logSlimmed, slimOrKeep, slimPassOrNull, slimTranscript } from "./slim/slim-transcript.js";
@@ -133,9 +133,11 @@ async function prepareFileInTwoPasses(run, input) {
     const startedAt = Date.now();
     // The file is opened once and its length pinned: the census offsets, the describe payload reads and the swap
     // pass all read these bytes, and a source that stopped being them is set aside (`verifyUnchanged`).
-    const source = await openPinnedTranscript(input.filePath, { maxFileBytes: input.maxFileBytes });
+    const source = input.openSource ? await input.openSource() : await openPinnedTranscript(input.filePath, { maxFileBytes: input.maxFileBytes });
     let writer;
     try {
+        if (input.maxFileBytes && source.length > input.maxFileBytes)
+            throw new TranscriptTooLargeError(input.maxFileBytes);
         // Pass one: discover. Nothing of the text is kept; only where each image is and what it is.
         const census = await censusOfLines(source.lines());
         // Describe attempts finish and the swap decisions are settled before a single line is swapped, as with the whole text.

package/dist/local-state-status.js

@@ -1,3 +1,4 @@
+import { readFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { readStagingInventory } from "./disk-usage.js";
@@ -18,7 +19,23 @@ import { readLocalWorkContextForRepo, workDisplayLabel, } from "./local-state-wo
 export async function inspectLocalCollectorStatus(options = {}) {
     const now = options.now ?? new Date();
     const reading = await readCollectorStatus(options, now);
-    return collectorStatusFromReading(reading, now);
+    const status = collectorStatusFromReading(reading, now);
+    try {
+        const native = JSON.parse(await readFile(path.join(reading.paths.state_dir, "opencode-collection-status.json"), "utf8"));
+        if (native.source === "opencode" && ["complete", "partial", "absent", "withheld"].includes(native.coverage)
+            && [native.discovered, native.eligible, native.delivered, native.pending, native.withheld, native.unique].every(value => typeof value === "number" && Number.isFinite(value) && value >= 0)) {
+            const at = typeof native.observed_at === "string" && Number.isFinite(Date.parse(native.observed_at)) ? new Date(native.observed_at).toISOString() : "unknown";
+            const reasons = Array.isArray(native.reasons) ? native.reasons.filter((reason) => typeof reason === "string" && /^[a-z0-9_:-]{1,100}$/.test(reason)).join(", ") : "";
+            status.details.push(`OpenCode: ${native.coverage}; discovered ${native.discovered}, eligible ${native.eligible}, delivered ${native.delivered}, pending ${native.pending}, withheld ${native.withheld}, unique ${native.unique}; as of ${at}${reasons ? ` (${reasons})` : ""}.`);
+        }
+        else
+            status.details.push("OpenCode coverage unavailable: opencode_status_invalid.");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            status.details.push("OpenCode coverage unavailable: opencode_status_unreadable.");
+    }
+    return status;
 }
 function collectorStatusFromReading(reading, now) {
     const { paths, config, session, identity, context, branch } = reading;

package/dist/native-session-roots.js

@@ -0,0 +1,31 @@
+/** Shared native homes keep sync, backfill and reconciliation on the same inventory. */
+import path from "node:path";
+import { t3ImportedNativeHomes } from "./t3-native-homes.js";
+export function nativeSessionRoots(homeDir, pathApi = path, environment = process.env) {
+    let importedHomes = [];
+    let discoveryFailed = false;
+    try {
+        importedHomes = t3ImportedNativeHomes(homeDir);
+    }
+    catch {
+        discoveryFailed = true;
+    } // The reader logged its reason; existing native homes remain available.
+    const expandHome = (value) => value === "~"
+        ? homeDir
+        : /^~[/\\]/u.test(value) ? pathApi.join(homeDir, value.slice(2)) : value;
+    const homes = (source, defaultHome, configured) => {
+        const extra = configured?.trim();
+        // Relative environment values depend on the launching app's cwd. Never guess it.
+        return [...new Set([defaultHome, ...importedHomes.filter((entry) => entry.source === source).map((entry) => entry.home), ...(extra && pathApi.isAbsolute(expandHome(extra)) ? [expandHome(extra)] : [])]
+                .map((home) => pathApi.normalize(home)))];
+    };
+    const claudeProjectDirs = homes("claude_code", pathApi.join(homeDir, ".claude"), environment.CLAUDE_CONFIG_DIR)
+        .map((home) => pathApi.join(home, "projects"));
+    return {
+        discoveryFailed,
+        codex: homes("codex", pathApi.join(homeDir, ".codex"), environment.CODEX_HOME)
+            .flatMap((home) => [pathApi.join(home, "sessions"), pathApi.join(home, "archived_sessions")]),
+        claudeProjects: claudeProjectDirs[0],
+        claudeProjectDirs,
+    };
+}