@bli-cockpit/cli 0.2.293 → 0.2.294

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/commands/backfill-checkpoint.js

@@ -62,7 +62,7 @@ function deliveredCursorEntry(prior, candidate, objectKey, now) {
     const entry = {
         ...prior,
         file_hash_sha256: candidate.content_hash_sha256,
-        uploaded_source_revision: isRedactionStubObjectKey(objectKey) ? prior?.uploaded_source_revision ?? null : 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-issues.js

@@ -48,6 +48,11 @@ async function addCodexStoreScanIssues(issues, codexAttribution) {
     // 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, candidates) {

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

@@ -269,6 +269,8 @@ function normalizeCodexCandidate(result) {
         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,7 @@ 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,

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

@@ -5,9 +5,9 @@ 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) {
+export function codexRevisionFacts(paths, mode, describedKeys, slimAware, t3Projection = false) {
     const form = async (drop) => {
-        const source = await openCodexSessionRevision(paths);
+        const source = await openCodexSessionRevision(paths, { t3Projection });
         try {
             const lines = { async *lines() {
                     const slimmer = createSlimmer("codex");
@@ -46,7 +46,7 @@ export function codexRevisionFacts(paths, mode, describedKeys, slimAware) {
     let full, slim;
     return {
         slimAware,
-        async rawSha256() { const source = await openCodexSessionRevision(paths); try {
+        async rawSha256() { const source = await openCodexSessionRevision(paths, { t3Projection }); try {
             return source.sha256;
         }
         finally {

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-help-commands-tower.js

@@ -251,7 +251,7 @@ export const TOWER_COMMAND_HELP = [
         "usage",
         [
             "Usage: cockpit usage people [--by-repo | --by-topic | --by-subject | --by-task | --by-client] [--min-confidence high|medium|low] [--person <email|me>] [--all] [--since <n>d|<n>h|<iso>] [--detail] [--until <iso>] [--include-automated] [--json]",
-            "  cockpit usage sessions [--person <exact-name>] [--task <BLI-NNNN> | --subject <name>] [--repo <label>] [--tool claude|codex] [--since <window>] [--until <iso>] [--cursor <cursor>] [--limit <n>] [--json]",
+            "  cockpit usage sessions [--person <exact-name>] [--task <BLI-NNNN> | --subject <name>] [--repo <label>] [--tool claude|codex|opencode] [--since <window>] [--until <iso>] [--cursor <cursor>] [--limit <n>] [--json]",
             "  cockpit usage session <id> [--from-window <n>] [--json]",
             "  --by-topic groups work types; --by-subject groups open subjects from session summaries.",
             "",

package/dist/commands/local-help.js

@@ -146,9 +146,9 @@ const COMMAND_SUMMARY_LINES = [
     "  cockpit correct --claim <claimId> --text \"<what is wrong>\" [--for <person>] [--version <pageId>] [--supersedes <id>] [--dashboard-url <url>] [--json]",
     "  cockpit notes [list|show <id>|shelf|shelves|folders|mkdir <path>|rmdir <path>|rename <path>|upload <paths...> [--wait]|paste|share <id>|unshare <id>|summarize <id>|move <id>|place <id>] [--folder <path>] [--series <shelf>] [--kind <kind>] [--since <YYYY-MM-DD>] [--until <YYYY-MM-DD>] [--limit <n>] [--file <path>] [--name <n>] [--exclude \"<sentence>\"] [--to \"<shelf>\"|--clear-shelf] [--apply] [--yes] [--dashboard-url <url>] [--json]",
     "  cockpit notes [accounts [--show-webhook <account-id>]|connect --provider fellow --workspace <sub> --key-stdin [--name <n>]|connect --provider wisprflow|recordings <note-id>|recording <id>|webhook <account-id> --secret-stdin|detach <account-id>|sync <account-id>] [--json]   (the key and the signing secret are read from stdin, never a flag)",
-    "  cockpit backfill (--since-days <n>|--all) [--source codex|claude] [--dry-run] [--max-files <n>] [--max-depth <n>] [--max-repos <n>] [--lock-wait <seconds>] [--yes] [--workspace <path>] [--json]",
+    "  cockpit backfill (--since-days <n>|--all) [--source codex|claude|opencode] [--dry-run] [--max-files <n>] [--max-depth <n>] [--max-repos <n>] [--lock-wait <seconds>] [--yes] [--workspace <path>] [--json]",
     "  cockpit status [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
-    "  cockpit sessions [--source codex|claude] [--since-days <n>|--all] [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
+    "  cockpit sessions [--source codex|claude|opencode] [--since-days <n>|--all] [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
     "  cockpit serve [--port <port>] [--workspace <path>]",
     "  cockpit autostart [install|uninstall|status] [--workspace <path>] [--dashboard-url <url>] [--interval-seconds <n>] [--json]",
     "  cockpit agent-rules [install|uninstall|status] [--host codex|claude|all] [--workspace <path>] [--json]",
@@ -190,7 +190,7 @@ const COMMAND_SUMMARY_LINES = [
     "  cockpit manager <clients|client <client>|run <run-id>|list <client>|queue <client>|show <id>|add <client> --title <t>|edit <id> --version <v>|done|reopen|link|approve|dismiss|proposal|archive|unarchive> [--timeline] [--dashboard-url <url>] [--json]",
     "  cockpit image <describe <file> [--session <id>]|show <sha256-or-prefix>> [--dashboard-url <url>] [--json]",
     "  cockpit setup [--since <duration|date>] [--until <date>] [--machines] [--details] [--person <name|email>] [--compare <name,name>] [--json]",
-    "  cockpit usage sessions [--person <exact-name>] [--task <BLI-NNNN> | --subject <name>] [--repo <label>] [--tool claude|codex] [--since <window>] [--until <iso>] [--cursor <cursor>] [--limit <n>] [--json]",
+    "  cockpit usage sessions [--person <exact-name>] [--task <BLI-NNNN> | --subject <name>] [--repo <label>] [--tool claude|codex|opencode] [--since <window>] [--until <iso>] [--cursor <cursor>] [--limit <n>] [--json]",
     "  cockpit usage session <id> [--from-window <n>] [--json]",
     "  --by-topic groups work types; --by-subject groups open subjects from session summaries.",
     "  cockpit ticket mutation-status <request-uuid> [--json] (check a lost write response)",

package/dist/commands/opencode-sync.js

@@ -0,0 +1,163 @@
+/** Route OpenCode'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 { openCodeCollectionPolicy } from "../opencode-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 { readOpenCodeInventory, acknowledgeOpenCodeUsage, OPENCODE_CURSOR_FILENAME } from "../opencode-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 syncOpenCodeSessions(options) {
+    const paths = getCollectorRuntimePaths(options.homeDir);
+    const now = new Date();
+    const summary = { source: "opencode", 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 openCodeCollectionPolicy(options);
+        if (!policy.enabled) {
+            const held = await readOpenCodeInventory({ 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: "opencode", attemptedAt: now.toISOString(), reason: held.failures[0]?.reason ?? policy.reason });
+            console.error("[opencode 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: OPENCODE_CURSOR_FILENAME, sessionsOnly: true });
+        const inventory = await readOpenCodeInventory({ 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)));
+        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: `opencode:${file.session.id}`, source: "opencode", reason: "drawer_shelf", facts: file.facts, recencyMs: file.session.updated_at_ms })) });
+            if (shelfReport.failed || shelfReport.not_counted)
+                summary.reasons.push("opencode_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("opencode_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: "opencode", 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 === "opencode_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 ?? "opencode_delivery_pending");
+                return { source: "opencode", 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 ?? "opencode_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;
+                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();
+            await writeRawEvidenceCursor(paths, cursor, { filename: OPENCODE_CURSOR_FILENAME, sessionsOnly: true });
+        }
+        const report = await flushPendingCodexSessionReports({ homeDir: options.homeDir, fetch: options.fetchImpl });
+        if (report.posted && report.failed_count === 0) {
+            await acknowledgeOpenCodeUsage(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: "opencode", attemptedAt: now.toISOString(), reason: summary.reasons[0] ?? "opencode_delivery_pending" });
+        else
+            await clearSourceRetryFailure(paths, "opencode", now.toISOString());
+    }
+    catch (error) {
+        summary.pending = Math.max(summary.pending, summary.eligible - summary.delivered);
+        summary.coverage = "partial";
+        summary.reasons.push("opencode_sync_failed");
+        await recordSourceRetryFailure(paths, { source: "opencode", attemptedAt: now.toISOString(), reason: "opencode_sync_failed" });
+        console.error("[opencode sync] pass failed; native sessions remain retryable", JSON.stringify({ reason: "opencode_sync_failed", ...describeError(error) }));
+    }
+    finally {
+        if (!options.dryRun) {
+            try {
+                await writeJsonFileAtomic(path.join(paths.state_dir, "opencode-collection-status.json"), { observed_at: now.toISOString(), ...summary });
+            }
+            catch (error) {
+                summary.coverage = "partial";
+                summary.reasons.push("opencode_coverage_receipt_write_failed");
+                console.error("[opencode sync] coverage receipt not written", JSON.stringify({ reason: "opencode_coverage_receipt_write_failed", ...describeError(error) }));
+            }
+        }
+    }
+    console.error("[opencode 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.294");
     return 0;
   }
 

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

@@ -170,4 +170,8 @@ 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");
 }

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 } 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,8 @@ 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 { 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 +109,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 +144,22 @@ 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 failures = createSyncFailureLedger();
+    for (const failure of run.failure_records)
+        failures.add(failure);
+    recordOpenCodeFailures(failures, opencode);
     return {
         ...run,
+        opencode,
+        summary: { ...run.summary, opencode },
+        sessions_new_this_tick: run.sessions_new_this_tick + opencode.new_since_last_scan,
+        sessions_outside_root: run.sessions_outside_root + opencode.outside_roots,
+        ok: run.ok && opencode.coverage !== "partial",
+        failure_reasons: [...run.failure_reasons, ...(opencode.coverage === "partial" ? opencode.reasons.length ? opencode.reasons : ["opencode_delivery_pending"] : [])],
+        failure_records: failures.sortedRecords(),
+        sessions_observed: run.sessions_observed + opencode.eligible,
+        sessions_pending_upload: run.sessions_pending_upload + opencode.pending,
         sessions_shelved: shelfSplit.shelved.length,
         packs_refused: worktreePass.packsRefused ?? 0,
         shelf_reports: shelfReports,