@bli-cockpit/cli 0.2.293 → 0.2.295

package/dist/commands/pi-sync.js

@@ -0,0 +1,167 @@
+/** Route Pi's third native format through the existing evidence pack, spool, report queue and durable cursor. */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getCollectorRuntimePaths, readLocalCollectorConfig, readLocalCollectorSessionFile, startLocalWorkContext, startLocalWorkContextForAttributedTarget } from "../local-state.js";
+import { writeJsonFileAtomic } from "../local-state-files.js";
+import { reportShelvedSessions } from "../shelf-reports.js";
+import { piCollectionPolicy } from "../pi-policy.js";
+import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET } from "../adapters/raw-evidence.js";
+import { cwdInsideRoots } from "../collection-scope.js";
+import { scoreSignalsAgainstWorktrees, sha256 } from "../adapters/attribution-core.js";
+import { outsideRootsWorkspace, isOutsideRootsWorkspace } from "./backfill-outside-roots.js";
+import { syncLocalAmbientEnvelope } from "../upload.js";
+import { readRawEvidenceCursor, writeRawEvidenceCursor } from "../cursors/raw-evidence-cursor.js";
+import { readPiInventory, acknowledgePiUsage, PI_CURSOR_FILENAME } from "../pi-inventory.js";
+import { queueCodexSessionReport, flushPendingCodexSessionReports } from "../upload-session-reports.js";
+import { recordSourceRetryFailure, clearSourceRetryFailure } from "../spool/local-spool.js";
+import { describeError } from "../health-detail.js";
+/** The all-history inventory is resumable through existing per-object acknowledgments, never a second delivery engine. */
+export async function syncPiSessions(options) {
+    const paths = getCollectorRuntimePaths(options.homeDir);
+    const now = new Date();
+    const summary = { source: "pi", new_since_last_scan: 0, outside_roots: 0, discovered: 0, eligible: 0, delivered: 0, pending: 0, withheld: 0, unique: 0, coverage: "complete", reasons: [] };
+    try {
+        const policy = await piCollectionPolicy(options);
+        if (!policy.enabled) {
+            const held = await readPiInventory({ homeDir: options.homeDir, stateDir: paths.state_dir, metadataOnly: true, include: () => false, sinceMs: options.sinceMs });
+            summary.discovered = held.discovered;
+            summary.unique = held.discovered;
+            summary.withheld = held.withheld;
+            summary.coverage = held.failures.length || policy.reason === "owner_check_unavailable" ? "partial" : held.absent ? "absent" : "withheld";
+            summary.reasons.push(policy.reason, ...held.failures.map(failure => failure.reason));
+            if (summary.coverage === "partial")
+                await recordSourceRetryFailure(paths, { source: "pi", attemptedAt: now.toISOString(), reason: held.failures[0]?.reason ?? policy.reason });
+            console.error("[pi sync] source withheld", JSON.stringify(summary));
+            return summary;
+        }
+        const attributed = (directory) => scoreSignalsAgainstWorktrees({ cwds: [directory], workspaceRoots: [], originUrls: [], branches: [], headShas: [] }, options.worktrees, { collectionRoots: options.collectionRoots });
+        const cursor = await readRawEvidenceCursor(paths, { filename: PI_CURSOR_FILENAME, sessionsOnly: true });
+        const inventory = await readPiInventory({ homeDir: options.homeDir, stateDir: paths.state_dir, metadataOnly: options.dryRun, sinceMs: options.sinceMs, deliveredSessionIds: new Set(Object.entries(cursor.sessions).filter(([, entry]) => entry.uploaded_object_key).map(([id]) => id)), include: policy.include, countOnly: policy.drawer });
+        summary.discovered = inventory.discovered;
+        summary.withheld = inventory.withheld;
+        summary.eligible = inventory.eligible;
+        summary.pending = inventory.eligible - inventory.files.length;
+        summary.unique = inventory.discovered;
+        summary.reasons.push(...new Set(inventory.failures.map((failure) => failure.reason)), ...new Set(inventory.files.flatMap(file => file.pending_reasons)));
+        if (inventory.absent)
+            summary.coverage = "absent";
+        if (options.dryRun) {
+            summary.pending = inventory.eligible;
+            if (inventory.failures.length)
+                summary.coverage = "partial";
+            return summary;
+        }
+        if (inventory.shelved.length) {
+            const [device, config] = await Promise.all([readLocalCollectorSessionFile(paths), readLocalCollectorConfig(paths)]);
+            const shelfReport = await reportShelvedSessions({ paths, dashboardUrl: options.dashboardUrl ?? config?.dashboard_url ?? null,
+                deviceToken: device?.device_token ?? null, fetchImpl: options.fetchImpl, allow: config?.shelf_metrics_allow ?? [], now,
+                shelved: inventory.shelved.map(file => ({ key: `pi:${file.session.id}`, source: "pi", reason: "drawer_shelf", facts: file.facts, recencyMs: file.session.updated_at_ms })) });
+            if (shelfReport.failed || shelfReport.not_counted)
+                summary.reasons.push("pi_shelf_metrics_pending");
+        }
+        summary.new_since_last_scan = inventory.files.filter((file) => !cursor.sessions[file.session.id]).length;
+        summary.outside_roots = inventory.files.filter((file) => !cwdInsideRoots(file.session.directory, options.collectionRoots)).length;
+        const durableSessions = new Set();
+        const groups = new Map();
+        for (const file of inventory.files) {
+            const worktree = attributed(file.session.directory).worktree ?? outsideRootsWorkspace(options.homeDir);
+            const group = groups.get(worktree.worktree_fingerprint) ?? { worktree, files: [] };
+            group.files.push(file);
+            groups.set(worktree.worktree_fingerprint, group);
+        }
+        const budget = options.budget ?? { remainingBytes: RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, remainingObjects: RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET };
+        for (const { worktree, files } of groups.values()) {
+            if (options.deadlineMs && Date.now() >= options.deadlineMs) {
+                summary.reasons.push("pi_deadline_deferred");
+                summary.pending = summary.eligible - summary.delivered;
+                break;
+            }
+            if (isOutsideRootsWorkspace(worktree))
+                await fs.mkdir(worktree.repo_root, { recursive: true, mode: 0o700 });
+            const contextOptions = { homeDir: options.homeDir, repoRoot: worktree.repo_root, branch: worktree.branch, leaveActiveContext: true };
+            const context = isOutsideRootsWorkspace(worktree) ? await startLocalWorkContextForAttributedTarget(contextOptions, worktree) : await startLocalWorkContext(contextOptions);
+            const sync = await syncLocalAmbientEnvelope({ homeDir: options.homeDir, repoRoot: worktree.repo_root, dashboardUrl: options.dashboardUrl,
+                rawEvidenceBudget: budget, codexSessionFiles: [], claudeSessionFiles: [], nativeSessionFiles: files.map((file) => ({ local_path: file.local_path, session_id: file.session.id, source: "pi", redaction: file.redaction })), fetch: options.fetchImpl });
+            if (sync.status !== "uploaded")
+                summary.reasons.push(sync.failure_reason);
+            const rows = files.map((file) => {
+                const attribution = attributed(file.session.directory);
+                const outcome = sync.raw_evidence_outcomes.find((item) => item.kind === "pi_jsonl" && item.codex_session_id === file.session.id);
+                const pointer = outcome && (outcome.upload_state === "uploaded" || outcome.upload_state === "reused_existing") ? outcome.raw_evidence_pointer_id : null;
+                if (!pointer)
+                    summary.reasons.push(outcome?.reason ?? "pi_delivery_pending");
+                return { source: "pi", codex_session_id: file.session.id, observed_at: now.toISOString(), attribution_state: attribution.state,
+                    attribution_reason: attribution.reason, attribution_score: attribution.attribution_score, path_score: attribution.path_score, signals: attribution.signals,
+                    session_file_hash_sha256: file.revision, session_file_byte_size: file.byte_size, session_file_mtime: new Date(file.session.updated_at_ms).toISOString(), session_facts: file.facts,
+                    repo_fingerprint: attribution.worktree?.repo_fingerprint, worktree_fingerprint: attribution.worktree?.worktree_fingerprint,
+                    repo_label: attribution.worktree?.repo_label, branch: attribution.worktree?.branch, cwd_basename: path.basename(file.session.directory), cwd_hash: sha256(Buffer.from(file.session.directory)),
+                    root_scope: cwdInsideRoots(file.session.directory, options.collectionRoots) ? "inside" : "outside",
+                    raw_evidence_pointer_id: pointer ?? undefined, upload_state: pointer ? "uploaded" : "not_uploaded", upload_reason: pointer ? "durable_evidence_acknowledged" : outcome?.reason ?? "pi_delivery_pending" };
+            });
+            // Durable metadata queue precedes cursor movement; an unavailable report endpoint cannot age sessions out.
+            await queueCodexSessionReport({ homeDir: options.homeDir, dashboardUrl: sync.dashboard_url, generatedAt: now.toISOString(), workContextId: context.work_context_id,
+                repoLabel: worktree.repo_label, branch: worktree.branch, repoFingerprint: worktree.repo_fingerprint, repoOriginUrl: worktree.repo_origin_url,
+                worktreeLabel: worktree.worktree_label, worktreeFingerprint: worktree.worktree_fingerprint, worktreeIsPrimary: worktree.worktree_is_primary, sessions: rows });
+            for (const [index, file] of files.entries()) {
+                const row = rows[index];
+                const pointer = row.raw_evidence_pointer_id ?? null;
+                if (pointer) {
+                    summary.delivered += 1;
+                    durableSessions.add(file.session.id);
+                }
+                else
+                    summary.pending += 1;
+                // Acknowledged bytes can be retained while a partial or racing native observation stays retryable.
+                if (file.pending_reasons.some(reason => reason === "pi_source_changed_during_read" || reason === "pi_partial_native_record"))
+                    continue;
+                cursor.sessions[file.session.id] = { file_hash_sha256: file.revision, file_mtime_ms: file.session.updated_at_ms, byte_size: file.byte_size, byte_offset: pointer ? file.byte_size : 0,
+                    state: row.attribution_state, reason: row.attribution_reason, worktree_fingerprint: row.worktree_fingerprint ?? null, uploaded_object_key: pointer,
+                    uploaded_at: pointer ? now.toISOString() : null, uploaded_byte_size: pointer ? file.byte_size : null, last_seen_at: now.toISOString() };
+            }
+            cursor.updated_at = now.toISOString();
+            // Metadata acknowledgment below owns cursor promotion.
+        }
+        const report = await flushPendingCodexSessionReports({ homeDir: options.homeDir, fetch: options.fetchImpl });
+        if (report.posted && report.failed_count === 0) {
+            await writeRawEvidenceCursor(paths, cursor, { filename: PI_CURSOR_FILENAME, sessionsOnly: true });
+            await acknowledgePiUsage(paths.state_dir, durableSessions);
+            // The shared pack/spool owns acknowledged bytes now; these are disposable redacted reader derivatives.
+            for (const file of inventory.files)
+                if (durableSessions.has(file.session.id))
+                    await fs.unlink(file.local_path).catch(() => undefined);
+        }
+        if (inventory.files.length && (!report.posted || report.failed_count > 0)) {
+            summary.reasons.push(report.reason);
+            summary.pending += summary.delivered;
+            summary.delivered = 0;
+        }
+        summary.reasons = [...new Set(summary.reasons)];
+        if (summary.pending || summary.reasons.length)
+            summary.coverage = "partial";
+        if (summary.coverage === "partial")
+            await recordSourceRetryFailure(paths, { source: "pi", attemptedAt: now.toISOString(), reason: summary.reasons[0] ?? "pi_delivery_pending" });
+        else
+            await clearSourceRetryFailure(paths, "pi", now.toISOString());
+    }
+    catch (error) {
+        summary.pending = Math.max(summary.pending, summary.eligible - summary.delivered);
+        summary.coverage = "partial";
+        summary.reasons.push("pi_sync_failed");
+        await recordSourceRetryFailure(paths, { source: "pi", attemptedAt: now.toISOString(), reason: "pi_sync_failed" });
+        console.error("[pi sync] pass failed; native sessions remain retryable", JSON.stringify({ reason: "pi_sync_failed", ...describeError(error) }));
+    }
+    finally {
+        if (!options.dryRun) {
+            try {
+                await writeJsonFileAtomic(path.join(paths.state_dir, "pi-collection-status.json"), { observed_at: now.toISOString(), ...summary });
+            }
+            catch (error) {
+                summary.coverage = "partial";
+                summary.reasons.push("pi_coverage_receipt_write_failed");
+                console.error("[pi sync] coverage receipt not written", JSON.stringify({ reason: "pi_coverage_receipt_write_failed", ...describeError(error) }));
+            }
+        }
+    }
+    console.error("[pi sync] pass finished", JSON.stringify(summary));
+    return summary;
+}

package/dist/commands/public-root.js

@@ -21,7 +21,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.293");
+    writeLine(io?.stdout ?? process.stdout, "0.2.295");
     return 0;
   }
 

package/dist/commands/session-sync-failures.js

@@ -170,4 +170,12 @@ export function recordUnexplainedFailure(ledger) {
         label: SYNC_FAILED_WITHOUT_REASON,
         rendered: SYNC_FAILED_WITHOUT_REASON,
     });
+}
+/** Keep native partial outcomes in the same closed failure ledger as legacy sources. */
+export function recordOpenCodeFailures(ledger, native) {
+    ledger.fail(native.coverage === "partial", "opencode_scan_read_failed", native.reasons[0] ?? "opencode_delivery_pending");
+}
+/** Keep Pi's named partial outcomes inside the single failure vocabulary writer. */
+export function recordPiFailures(ledger, native) {
+    ledger.fail(native.coverage === "partial", "pi_scan_read_failed", native.reasons[0] ?? "pi_delivery_pending");
 }

package/dist/commands/session-sync-record.js

@@ -322,7 +322,7 @@ function recordSourceObservation(options, result) {
         : (prior?.uploaded_byte_size ?? (durableThisSync ? result.byte_size : null));
     const entry = {
         file_hash_sha256: result.content_hash_sha256,
-        uploaded_source_revision: durableThisSync && !isRedactionStubObjectKey(uploadedObjectKey)
+        uploaded_source_revision: durableThisSync && !("t3_projection_incomplete" in result && result.t3_projection_incomplete) && !isRedactionStubObjectKey(uploadedObjectKey)
             ? result.content_hash_sha256 : prior?.uploaded_source_revision ?? null,
         file_mtime_ms: result.session_file_mtime_ms,
         byte_size: result.byte_size,

package/dist/commands/session-sync-upload.js

@@ -39,7 +39,7 @@ export async function syncEveryTargetWorktree(options) {
     // sessionId -> prior durable pointer for damped sessions (drives the
     // growth_damped count + the skip_main decision).
     const dampedClaudePointers = new Map();
-    const rawEvidenceBudget = {
+    const rawEvidenceBudget = run.rawEvidenceBudget ?? {
         remainingBytes: RAW_EVIDENCE_DEFAULT_BYTE_BUDGET,
         remainingObjects: RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET,
     };
@@ -180,6 +180,7 @@ function ambientEnvelopeForWorktree(options) {
             .map((result) => ({
             local_path: result.file_path,
             codex_session_id: result.codex_session_id,
+            ...(result.t3_projection ? { t3_projection: true } : {}),
             ...(result.segment_paths ? { segment_paths: result.segment_paths, revision_hash: result.content_hash_sha256 ?? undefined, revision_bytes: result.byte_size } : {}),
         })),
         codexAttributionScan: scan.codexAttribution,

package/dist/commands/session-sync.js

@@ -1,3 +1,4 @@
+import { createSyncFailureLedger, recordOpenCodeFailures, recordPiFailures } from "./session-sync-failures.js";
 import { readLocalWorkContextForRepo } from "../local-state.js";
 /**
  * One attributed sync pass: scan both session stores, attribute what they hold,
@@ -39,6 +40,9 @@ import { readLocalWorkContextForRepo } from "../local-state.js";
  * `runtimeFiles`, or the repo tests stay green while the packed CLI breaks.
  */
 import os from "node:os";
+import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET } from "../adapters/raw-evidence.js";
+import { syncPiSessions } from "./pi-sync.js";
+import { syncOpenCodeSessions } from "./opencode-sync.js";
 import { getCollectorRuntimePaths, readLocalCollectorConfig, readLocalCollectorSessionFile } from "../local-state.js";
 import { reportShelvedSessions } from "../shelf-reports.js";
 import { splitScanByShelf } from "./session-sync-shelf.js";
@@ -106,7 +110,7 @@ export async function runAttributedWorktreeSync(requested) {
         return heldSyncRun(scannedAll);
     const shelfSplit = splitScanByShelf({ scan: scannedAll, worktrees: requested.worktrees, decision: shelfDecision });
     const scanned = shelfSplit.scan;
-    const options = { ...requested, worktrees: shelfSplit.worktrees };
+    const options = { ...requested, worktrees: shelfSplit.worktrees, rawEvidenceBudget: requested.rawEvidenceBudget ?? { remainingBytes: RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, remainingObjects: RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET } };
     // BLI-17916: roots are a label, never a gate. Outside-root sessions ride this
     // tick's upload under the synthetic workspace, a few per tick, newest first.
     const scan = await admitOutsideRootSessions({
@@ -141,8 +145,24 @@ export async function runAttributedWorktreeSync(requested) {
     reportCountedSessionFacts(sessions);
     const shelfReports = await sendShelfReports(options, paths, shelfSplit, now);
     const run = await finishAttributedSync(options, { paths, now, plan, scan, sessions, worktreePass });
+    const opencode = await syncOpenCodeSessions({ homeDir, worktrees: requested.worktrees, collectionRoots: plan.collectionRoots, dashboardUrl: requested.dashboardUrl, fetchImpl: requested.fetchImpl, budget: options.rawEvidenceBudget });
+    const pi = await syncPiSessions({ homeDir, worktrees: requested.worktrees, collectionRoots: plan.collectionRoots, dashboardUrl: requested.dashboardUrl, fetchImpl: requested.fetchImpl, budget: options.rawEvidenceBudget });
+    const failures = createSyncFailureLedger();
+    recordPiFailures(failures, pi);
+    for (const failure of run.failure_records)
+        failures.add(failure);
+    recordOpenCodeFailures(failures, opencode);
     return {
         ...run,
+        opencode, pi,
+        summary: { ...run.summary, opencode, pi },
+        sessions_new_this_tick: run.sessions_new_this_tick + opencode.new_since_last_scan + pi.new_since_last_scan,
+        sessions_outside_root: run.sessions_outside_root + opencode.outside_roots + pi.outside_roots,
+        ok: run.ok && opencode.coverage !== "partial" && pi.coverage !== "partial",
+        failure_reasons: [...run.failure_reasons, ...(pi.coverage === "partial" ? pi.reasons : []), ...(opencode.coverage === "partial" ? opencode.reasons.length ? opencode.reasons : ["opencode_delivery_pending"] : [])],
+        failure_records: failures.sortedRecords(),
+        sessions_observed: run.sessions_observed + opencode.eligible + pi.eligible,
+        sessions_pending_upload: run.sessions_pending_upload + opencode.pending + pi.pending,
         sessions_shelved: shelfSplit.shelved.length,
         packs_refused: worktreePass.packsRefused ?? 0,
         shelf_reports: shelfReports,

package/dist/commands/sessions.js

@@ -9,6 +9,9 @@
  */
 import os from "node:os";
 import path from "node:path";
+import { readPiInventory } from "../pi-inventory.js";
+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 +33,50 @@ 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;
+    const piNative = !command.source || command.source === "pi" ? await readPiInventory({ homeDir,
+        stateDir: getCollectorRuntimePaths(homeDir).state_dir, metadataOnly: true,
+        sinceMs: window.since_minutes === null ? undefined : now.getTime() - window.since_minutes * 60_000 }) : null;
+    const pi = piNative && (!piNative.absent || piNative.failures.length) ? { counts: { observed_count: piNative.discovered, read_failed: piNative.failures.length },
+        reasons: [...new Set(piNative.failures.map(failure => failure.reason))], sessions: piNative.sessions.map(session => {
+            const attributed = scoreSignalsAgainstWorktrees({ cwds: [session.directory], workspaceRoots: [], originUrls: [], branches: [], headShas: [] }, worktrees);
+            return { source: "pi", 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) + (piNative?.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, pi);
     }
-    return writeSessionText(io, window, readFailures, codexRows, claudeRows);
+    if (pi) {
+        for (const row of pi.sessions)
+            writeLine(io.stdout, sessionRowLine(row));
+        for (const reason of pi.reasons)
+            writeLine(io.stdout, `Pi read incomplete: ${reason}`);
+    }
+    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) + (pi?.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 +87,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 +100,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" && command.source !== "pi"
         ? await scanAndAttributeCodexSessions({
             sessionsDirs: defaultCodexSessionDirs(homeDir),
             worktrees,
@@ -75,7 +109,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" && command.source !== "pi"
         ? await scanAndAttributeClaudeSessions({
             projectsDir: path.join(homeDir, ".claude", "projects"),
             worktrees,
@@ -86,10 +120,12 @@ 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, pi) {
     writeLine(io.stdout, JSON.stringify({
         window,
         read_failures: readFailures,
+        ...(opencode ? { opencode } : {}),
+        ...(pi ? { pi } : {}),
         ...(codex ? { codex: { counts: codex.counts, sessions: codexRows } } : {}),
         ...(claude
             ? {

package/dist/commands/sources-check.js

@@ -28,6 +28,8 @@ 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 { PI_CURSOR_FILENAME } from "../pi-inventory.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 +57,67 @@ 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 = {
+            pi: await readRawEvidenceCursor(paths, { filename: PI_CURSOR_FILENAME, sessionsOnly: true }),
+            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", "pi"] : 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", "pi/agent/sessions"], 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 +138,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,5 +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).
@@ -23,7 +24,14 @@ import { nativeSessionRoots } from "../native-session-roots.js";
  * This module reads files and never writes, moves or deletes one.
  */
 import fs from "node:fs/promises";
+import { getCollectorRuntimePaths } from "../local-state.js";
+import { piCollectionPolicy } from "../pi-policy.js";
+import { readPiInventory } from "../pi-inventory.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";
@@ -140,7 +148,43 @@ export async function discoverLocalTranscripts(options) {
     const recordFailure = (error) => { firstFailure ??= describeError(error); };
     const found = await findTranscriptFiles(options, roots, result, recordFailure);
     await nameTranscriptFiles(found, result, recordFailure);
-    await groupCodexRevisions(result);
+    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 }) });
+        }
+    }
+    if (!options.skipAll) {
+        const policy = await piCollectionPolicy({ homeDir: options.homeDir });
+        const scratch = policy.enabled ? await fs.mkdtemp(path.join(os.tmpdir(), "tower-pi-reconcile-")) : null;
+        const previousCleanup = result.cleanup;
+        if (scratch)
+            result.cleanup = async () => { await previousCleanup?.(); await fs.rm(scratch, { recursive: true, force: true }); };
+        const inventory = policy.enabled ? await readPiInventory({ 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 (file.pending_reasons.length)
+                result.file_read_failed++;
+            if (options.olderThanMs !== null && file.session.updated_at_ms >= options.olderThanMs) {
+                result.newer_count++;
+                continue;
+            }
+            result.files.push({ source: "pi", kind: "pi_main", source_locator: `pi:${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: "pi", 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({
@@ -247,7 +291,14 @@ async function nameTranscriptFiles(found, result, recordFailure) {
     }
 }
 /** One source row/pointer names the complete native session revision, never an arbitrary segment. */
-async function groupCodexRevisions(result) {
+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") {
@@ -257,14 +308,15 @@ async function groupCodexRevisions(result) {
         }
     const replacements = new Map();
     for (const [id, files] of groups) {
-        if (files.length < 2)
+        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);
+            const source = await openCodexSessionRevision(combined.segment_paths, { t3Projection: combined.t3_projection });
             try {
                 combined.byte_size = source.length;
             }