@phnx-labs/agents-cli 1.22.29 → 1.22.31

package/dist/lib/session/discover.js

@@ -18,7 +18,7 @@ import { getAgentsDir, getUserAgentsDir, getHistoryDir, getRunsDir } from '../st
 import { shortCodexHome } from '../codex-home.js';
 import { parseTimeFilter } from './relative-time.js';
 const execFileAsync = promisify(execFile);
-import { AGENTS, agentConfigDirName, getCliVersion } from '../agents.js';
+import { AGENTS, agentConfigDirName, getCliVersion, resolveOpenCodeAccountId } from '../agents.js';
 import { walkForFilesWithStat } from '../fs-walk.js';
 import { hasCommand } from '../cli-resources.js';
 import { execFileShellSpec } from '../platform/exec.js';
@@ -28,7 +28,7 @@ import { deriveShortId } from './short-id.js';
 import { buildClaudeAccountIndex, resolveClaudeAccount } from './claude-accounts.js';
 import { extractSessionTopic, extractSlashCommandName, extractSlashCommandFromToolInput } from './prompt.js';
 import { isSkillInvocation, extractSkills, extractSlashCommands } from './highlights.js';
-import { parseAntigravity, parseCursor } from './parse.js';
+import { parseAntigravity, parseCursor, splitSessionFilePath } from './parse.js';
 import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand, detectSpawnedTeam, isTicketCreateTool, extractCreatedTicket, extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
 import { costOfUsage, costOfUsageNoCache } from '../pricing/index.js';
 import { machineForSessionFile } from './origin-machine.js';
@@ -335,6 +335,15 @@ export function isManagedSessionFile(filePath) {
     // someone's dotfile dir, so scoping must not silently swallow them.
     if (!filePath || !path.isAbsolute(filePath))
         return true;
+    // A composite file_path (`<container>#<id>`) names a row inside a single shared
+    // DB the scanner reads from one fixed location (OpenCode's `opencode.db`) — that
+    // store is never a per-install dotfile under a version home, so the managed-vs-
+    // unmanaged split does not apply: there is exactly one store, not a "your own"
+    // copy to hide. Classifying it as unmanaged hid every OpenCode row from default
+    // listings once any agent was managed (RUSH-2357). Keyed off the composite FORM,
+    // so any future single-DB harness inherits this.
+    if (splitSessionFilePath(filePath).fragment !== undefined)
+        return true;
     const roots = [
         ...VERSIONS_ROOTS.map((root) => path.join(root, 'versions')),
         path.join(getHistoryDir(), 'backups'),
@@ -1838,39 +1847,24 @@ function readAntigravityMeta(filePath, currentVersion) {
 const OPENCODE_DB = path.join(HOME, '.local', 'share', 'opencode', 'opencode.db');
 let cachedOpenCodeAccount;
 /**
- * Query the active OpenCode account email from its SQLite database.
+ * The active OpenCode account: the provider ids with a valid credential in
+ * `auth.json`, joined (e.g. `"anthropic+muse-spark"`) — see
+ * `resolveOpenCodeAccountId` in `../agents.js`, the single source of truth
+ * `agents view`/`agents doctor` also read.
  *
- * Takes the scan's already-open handle so a scan opens `opencode.db` exactly
- * once (RUSH-2210); opens its own only when called without one.
+ * OpenCode's `opencode.db` also carries `account`/`account_state`/
+ * `control_account` tables that look like the obvious source, but on a real,
+ * actively-used install (yosemite-s1, 1.16.0, 35 applied migrations) all
+ * three are permanently empty — no migration populates them and no session
+ * has ever written a row. Querying them (the pre-fix behavior here) always
+ * returned undefined, credential or not; `auth.json` is what OpenCode
+ * actually reads at runtime.
  */
-function getOpenCodeAccount(handle) {
+function getOpenCodeAccount() {
     if (cachedOpenCodeAccount !== undefined)
         return cachedOpenCodeAccount || undefined;
-    // Read through the node/bun SQLite wrapper (not the `sqlite3` CLI) so this
-    // works on every OS — the CLI is absent on Windows.
-    let owned;
-    try {
-        const db = handle ?? (fs.existsSync(OPENCODE_DB) ? (owned = new Database(OPENCODE_DB)) : undefined);
-        if (db) {
-            const row = db
-                .prepare('SELECT email FROM control_account WHERE active=1 LIMIT 1;')
-                .get();
-            const out = typeof row?.email === 'string' ? row.email.trim() : '';
-            if (out) {
-                cachedOpenCodeAccount = out;
-                return out;
-            }
-        }
-    }
-    catch { /* DB not accessible, sqlite module unavailable, or query failed */ }
-    finally {
-        try {
-            owned?.close();
-        }
-        catch { /* best-effort close */ }
-    }
-    cachedOpenCodeAccount = '';
-    return undefined;
+    cachedOpenCodeAccount = resolveOpenCodeAccountId(HOME) ?? '';
+    return cachedOpenCodeAccount || undefined;
 }
 /**
  * The per-session ledger stamp for an OpenCode row: the newest write time across
@@ -1945,12 +1939,28 @@ async function scanOpenCodeIncremental() {
     // works on every OS — the CLI is absent on Windows.
     let db;
     try {
+        db = new Database(OPENCODE_DB);
+        // OpenCode's `session` schema varies by version: `cost` and `model` are newer
+        // columns. Probe once and select NULL where absent, so an older opencode.db
+        // still scans instead of throwing "no such column" and dropping every session.
+        const sessionCols = new Set(db.prepare('PRAGMA table_info(session);').all()
+            .map(c => (typeof c.name === 'string' ? c.name : '')));
+        const costExpr = sessionCols.has('cost') ? 's.cost' : 'NULL';
+        const modelExpr = sessionCols.has('model') ? 's.model' : 'NULL';
+        // Every `json_extract` / `json_type` below is guarded by `json_valid`.
+        // SQLite raises "malformed JSON" on a non-JSON value, and that aborts the
+        // WHOLE query — so a single unparseable `part`/`message` row anywhere in the
+        // shared DB would drop EVERY OpenCode session from the index, silently in a
+        // non-TTY run (the handler below only prints when stderr is a TTY). A
+        // poisoned row must cost that row, not the harness.
         const query = `
       SELECT
         s.id AS id,
         s.title AS title,
         s.directory AS directory,
         s.version AS version,
+        ${costExpr} AS cost,
+        ${modelExpr} AS model,
         s.time_created AS time_created,
         s.time_updated AS time_updated,
         COALESCE(stats.message_count, 0) AS message_count,
@@ -1958,15 +1968,20 @@ async function scanOpenCodeIncremental() {
         COALESCE(stats.message_bytes, 0) AS message_bytes,
         COALESCE(parts.last_part_at, 0) AS last_part_at,
         COALESCE(parts.part_bytes, 0) AS part_bytes,
+        COALESCE(parts.tool_call_count, 0) AS tool_call_count,
         stats.token_count AS token_count,
         stats.output_tokens AS output_tokens,
+        stats.input_tokens AS input_tokens,
+        stats.cache_read_tokens AS cache_read_tokens,
+        stats.cache_write_tokens AS cache_write_tokens,
         COALESCE(stats.has_token_data, 0) AS has_token_data
       FROM session s
       LEFT JOIN (
         SELECT
           session_id,
           MAX(time_created) AS last_part_at,
-          SUM(LENGTH(CAST(data AS BLOB))) AS part_bytes
+          SUM(LENGTH(CAST(data AS BLOB))) AS part_bytes,
+          SUM(CASE WHEN json_valid(data) AND json_extract(data, '$.type') = 'tool' THEN 1 ELSE 0 END) AS tool_call_count
         FROM part
         GROUP BY session_id
       ) parts ON parts.session_id = s.id
@@ -1976,15 +1991,18 @@ async function scanOpenCodeIncremental() {
           COUNT(*) AS message_count,
           MAX(time_created) AS last_message_at,
           SUM(LENGTH(CAST(data AS BLOB))) AS message_bytes,
-          SUM(
+          SUM(CASE WHEN json_valid(data) THEN
             COALESCE(json_extract(data, '$.tokens.input'), 0) +
             COALESCE(json_extract(data, '$.tokens.output'), 0) +
             COALESCE(json_extract(data, '$.tokens.reasoning'), 0) +
             COALESCE(json_extract(data, '$.tokens.cache.read'), 0) +
             COALESCE(json_extract(data, '$.tokens.cache.write'), 0)
-          ) AS token_count,
-          SUM(COALESCE(json_extract(data, '$.tokens.output'), 0)) AS output_tokens,
-          MAX(CASE WHEN json_type(data, '$.tokens') IS NOT NULL THEN 1 ELSE 0 END) AS has_token_data
+          ELSE 0 END) AS token_count,
+          SUM(CASE WHEN json_valid(data) THEN COALESCE(json_extract(data, '$.tokens.output'), 0) ELSE 0 END) AS output_tokens,
+          SUM(CASE WHEN json_valid(data) THEN COALESCE(json_extract(data, '$.tokens.input'), 0) ELSE 0 END) AS input_tokens,
+          SUM(CASE WHEN json_valid(data) THEN COALESCE(json_extract(data, '$.tokens.cache.read'), 0) ELSE 0 END) AS cache_read_tokens,
+          SUM(CASE WHEN json_valid(data) THEN COALESCE(json_extract(data, '$.tokens.cache.write'), 0) ELSE 0 END) AS cache_write_tokens,
+          MAX(CASE WHEN json_valid(data) AND json_type(data, '$.tokens') IS NOT NULL THEN 1 ELSE 0 END) AS has_token_data
         FROM message
         GROUP BY session_id
       ) stats ON stats.session_id = s.id
@@ -1992,8 +2010,7 @@ async function scanOpenCodeIncremental() {
       ORDER BY time_created DESC
       LIMIT 1000;
     `.replace(/\n/g, ' ');
-        db = new Database(OPENCODE_DB);
-        const account = getOpenCodeAccount(db);
+        const account = getOpenCodeAccount();
         const rows = db.prepare(query).all();
         // Two passes. First derive each row's identity + per-session stamp, then
         // bulk-load the prior stamps in ONE query and keep only the rows that
@@ -2034,13 +2051,40 @@ async function scanOpenCodeIncremental() {
             const messageCount = asInt(row.message_count);
             const tokenCount = asInt(row.token_count);
             const outputTokens = asInt(row.output_tokens);
+            const inputTokens = asInt(row.input_tokens);
+            const cacheReadTokens = asInt(row.cache_read_tokens);
+            const cacheWriteTokens = asInt(row.cache_write_tokens);
             const hasTokenData = asInt(row.has_token_data) === 1;
+            const toolCallCount = asInt(row.tool_call_count);
             const timestamp = isNaN(timeCreated) ? new Date().toISOString() : new Date(timeCreated).toISOString();
             // OpenCode is one shared DB, not one file per session — its row carries a
             // per-session updated time. Set lastActivity explicitly (falling back to
             // creation, never the whole-DB mtime the ScanStamp would otherwise supply).
             const lastActivity = Number.isNaN(timeUpdated) ? timestamp : new Date(timeUpdated).toISOString();
             const topic = title || undefined;
+            // Duration is the session-row span; a missing/degenerate pair yields no value
+            // rather than a negative or NaN.
+            const durationMs = Number.isFinite(timeCreated) && Number.isFinite(timeUpdated) && timeUpdated > timeCreated
+                ? timeUpdated - timeCreated
+                : undefined;
+            // OpenCode stores the model as JSON (`{"id":"…","providerID":"…"}`); the
+            // index tracks the model id.
+            let model;
+            if (typeof row.model === 'string' && row.model.trim()) {
+                try {
+                    const parsed = JSON.parse(row.model);
+                    if (typeof parsed?.id === 'string' && parsed.id.trim())
+                        model = parsed.id;
+                }
+                catch { /* non-JSON model string — leave unset */ }
+            }
+            // `cost` is a REAL rollup OpenCode maintains on the session row (0 for a
+            // zero-priced provider, which is a real value, not "unknown").
+            const costUsd = typeof row.cost === 'number' ? row.cost : undefined;
+            // Worktree slug is a pure function of cwd (`.agents/worktrees/<slug>/`),
+            // so it derives for OpenCode exactly as it does for every other harness.
+            const cwd = directory ? normalizeCwd(directory) : undefined;
+            const worktreeSlug = detectWorktree(cwd)?.slug;
             const meta = {
                 id,
                 shortId: deriveShortId(id, /^ses_/),
@@ -2048,14 +2092,22 @@ async function scanOpenCodeIncremental() {
                 timestamp,
                 lastActivity,
                 project: directory ? path.basename(directory) : undefined,
-                cwd: directory ? normalizeCwd(directory) : undefined,
+                cwd,
                 filePath,
                 version: resolveSessionVersion('opencode', OPENCODE_DB, version || undefined, currentVersion),
                 account,
                 topic,
+                model,
+                costUsd,
+                durationMs,
+                worktreeSlug,
+                toolCallCount: Number.isNaN(toolCallCount) ? undefined : toolCallCount,
                 messageCount: Number.isNaN(messageCount) ? undefined : messageCount,
                 tokenCount: hasTokenData && !Number.isNaN(tokenCount) ? tokenCount : undefined,
                 outputTokens: hasTokenData && !Number.isNaN(outputTokens) ? outputTokens : undefined,
+                inputTokens: hasTokenData && !Number.isNaN(inputTokens) ? inputTokens : undefined,
+                cacheReadTokens: hasTokenData && !Number.isNaN(cacheReadTokens) ? cacheReadTokens : undefined,
+                cacheWriteTokens: hasTokenData && !Number.isNaN(cacheWriteTokens) ? cacheWriteTokens : undefined,
             };
             entries.push({ meta, content: topic || '', scan });
         }

package/dist/lib/session/parse.d.ts

@@ -103,6 +103,33 @@ export declare function parseGemini(filePath: string): SessionEvent[];
  * request step and a completion step that share the id).
  */
 export declare function parseAntigravity(dbPath: string): SessionEvent[];
+/**
+ * Separator between a container file and the id it holds inside a *composite*
+ * session `file_path`. Some harnesses keep every session in ONE file (OpenCode's
+ * single `opencode.db`), so the index stores `<container>#<session-id>` rather
+ * than one path per session — e.g.
+ * `/home/u/.local/share/opencode/opencode.db#ses_02410a2c…`.
+ */
+export declare const SESSION_FILE_PATH_SEP = "#";
+/**
+ * Split a stored session `file_path` into its on-disk container and the optional
+ * in-container fragment. For a plain per-session file the container is the path
+ * itself and `fragment` is undefined; for a composite path it is the part before
+ * the first `#` and the id after it.
+ */
+export declare function splitSessionFilePath(filePath: string): {
+    container: string;
+    fragment: string | undefined;
+};
+/**
+ * The filesystem path whose existence/stat decides whether a session row is
+ * stale. For a composite `file_path` this is the CONTAINER file — the row is a
+ * record inside it, never a filesystem entry of its own — so a composite session
+ * is stale only when its container is gone. For a plain path it is the path
+ * itself. Keying off the composite FORM (a `#` fragment), not any harness name,
+ * means any future single-file-DB harness inherits the correct behavior.
+ */
+export declare function sessionFilePathContainer(filePath: string): string;
 /**
  * Parse an OpenCode session from its SQLite database.
  * filePath format: "/path/to/opencode.db#session_id"
@@ -130,6 +157,42 @@ export declare function parseAntigravity(dbPath: string): SessionEvent[];
  * (from summary.json), falling back to the transcript's mtime.
  */
 export declare function parseGrok(filePath: string): SessionEvent[];
+/**
+ * The transcript query {@link parseOpenCode} runs, exported so a test can assert
+ * the projection's real cost against a database instead of re-typing the SQL.
+ *
+ * A tool part is PROJECTED to exactly the fields the `case 'tool'` branch below
+ * reads — `tool`, `callID`, `state.status`, `state.input`, `state.output` —
+ * rather than carried whole. Two things this has to get right at once:
+ *
+ *   - Keep `state.input`. It carries `filePath` / `command`, and losing it is
+ *     what left `recentDirectoriesTouched` empty (RUSH-2358).
+ *   - Stay bounded. A tool part is not bounded by its output: on a real
+ *     `opencode.db` the largest part is 1,346,068 bytes of which
+ *     `state.attachments` (a base64 data URL from `read`) is 1,345,674, while
+ *     `state.output` is 23. Truncating only `state.output` therefore bounded
+ *     nothing — it took one session's loaded tool payload from 299,365 to
+ *     1,911,209 bytes. The projection drops `attachments` (and every other
+ *     unread key) outright, caps `state.output`, and collapses an oversized
+ *     `state.input` to just its addressing fields. Those are the keys the
+ *     enrichment reads — `filePath`/`path` for an edit and `cwd`/`workdir`/
+ *     `working_directory` for a shell (`extractRecentDirectoriesTouched` in
+ *     state.ts), plus `command`/`description`, themselves capped since a command
+ *     can be arbitrarily long. Above the cap every other input key (an `edit`'s
+ *     `oldString`/`newString`) is gone, deliberately — nothing downstream reads
+ *     them, and they are the weight.
+ *
+ * `json_valid` guards every `json_extract`: SQLite raises "malformed JSON" on a
+ * non-JSON value, which aborts the WHOLE query, so one bad `part` row would
+ * otherwise cost the entire transcript. Note the single-argument form is
+ * RFC-8259-strict — it rejects a JSONB blob that `json_extract` would accept.
+ * That is correct for today's schema (`part.data` / `message.data` are TEXT on
+ * a real database); if OpenCode ever migrates them to JSONB, these guards must
+ * move to `json_valid(data, 6)` or they will drop every row.
+ *
+ * The session id is bound as a parameter; the two caps are numeric literals.
+ */
+export declare const OPENCODE_TRANSCRIPT_QUERY: string;
 export declare function parseOpenCode(filePath: string): SessionEvent[];
 /** Parse a Rush JSONL session file into normalized events. */
 export declare function parseRush(filePath: string): SessionEvent[];

package/dist/lib/session/parse.js

@@ -1125,6 +1125,40 @@ export function parseAntigravity(dbPath) {
     return events;
 }
 // ---------------------------------------------------------------------------
+// Composite session file paths
+// ---------------------------------------------------------------------------
+/**
+ * Separator between a container file and the id it holds inside a *composite*
+ * session `file_path`. Some harnesses keep every session in ONE file (OpenCode's
+ * single `opencode.db`), so the index stores `<container>#<session-id>` rather
+ * than one path per session — e.g.
+ * `/home/u/.local/share/opencode/opencode.db#ses_02410a2c…`.
+ */
+export const SESSION_FILE_PATH_SEP = '#';
+/**
+ * Split a stored session `file_path` into its on-disk container and the optional
+ * in-container fragment. For a plain per-session file the container is the path
+ * itself and `fragment` is undefined; for a composite path it is the part before
+ * the first `#` and the id after it.
+ */
+export function splitSessionFilePath(filePath) {
+    const hash = filePath.indexOf(SESSION_FILE_PATH_SEP);
+    if (hash < 0)
+        return { container: filePath, fragment: undefined };
+    return { container: filePath.slice(0, hash), fragment: filePath.slice(hash + 1) || undefined };
+}
+/**
+ * The filesystem path whose existence/stat decides whether a session row is
+ * stale. For a composite `file_path` this is the CONTAINER file — the row is a
+ * record inside it, never a filesystem entry of its own — so a composite session
+ * is stale only when its container is gone. For a plain path it is the path
+ * itself. Keying off the composite FORM (a `#` fragment), not any harness name,
+ * means any future single-file-DB harness inherits the correct behavior.
+ */
+export function sessionFilePathContainer(filePath) {
+    return splitSessionFilePath(filePath).container;
+}
+// ---------------------------------------------------------------------------
 // OpenCode parser
 // ---------------------------------------------------------------------------
 /**
@@ -1279,36 +1313,124 @@ export function parseGrok(filePath) {
     }
     return events;
 }
+/**
+ * Byte/char caps for the OpenCode tool-part projection below. Numeric
+ * constants, interpolated into the SQL — never user input.
+ */
+const OPENCODE_OUTPUT_MAX_CHARS = 2000;
+const OPENCODE_INPUT_MAX_BYTES = 4000;
+/**
+ * The transcript query {@link parseOpenCode} runs, exported so a test can assert
+ * the projection's real cost against a database instead of re-typing the SQL.
+ *
+ * A tool part is PROJECTED to exactly the fields the `case 'tool'` branch below
+ * reads — `tool`, `callID`, `state.status`, `state.input`, `state.output` —
+ * rather than carried whole. Two things this has to get right at once:
+ *
+ *   - Keep `state.input`. It carries `filePath` / `command`, and losing it is
+ *     what left `recentDirectoriesTouched` empty (RUSH-2358).
+ *   - Stay bounded. A tool part is not bounded by its output: on a real
+ *     `opencode.db` the largest part is 1,346,068 bytes of which
+ *     `state.attachments` (a base64 data URL from `read`) is 1,345,674, while
+ *     `state.output` is 23. Truncating only `state.output` therefore bounded
+ *     nothing — it took one session's loaded tool payload from 299,365 to
+ *     1,911,209 bytes. The projection drops `attachments` (and every other
+ *     unread key) outright, caps `state.output`, and collapses an oversized
+ *     `state.input` to just its addressing fields. Those are the keys the
+ *     enrichment reads — `filePath`/`path` for an edit and `cwd`/`workdir`/
+ *     `working_directory` for a shell (`extractRecentDirectoriesTouched` in
+ *     state.ts), plus `command`/`description`, themselves capped since a command
+ *     can be arbitrarily long. Above the cap every other input key (an `edit`'s
+ *     `oldString`/`newString`) is gone, deliberately — nothing downstream reads
+ *     them, and they are the weight.
+ *
+ * `json_valid` guards every `json_extract`: SQLite raises "malformed JSON" on a
+ * non-JSON value, which aborts the WHOLE query, so one bad `part` row would
+ * otherwise cost the entire transcript. Note the single-argument form is
+ * RFC-8259-strict — it rejects a JSONB blob that `json_extract` would accept.
+ * That is correct for today's schema (`part.data` / `message.data` are TEXT on
+ * a real database); if OpenCode ever migrates them to JSONB, these guards must
+ * move to `json_valid(data, 6)` or they will drop every row.
+ *
+ * The session id is bound as a parameter; the two caps are numeric literals.
+ */
+export const OPENCODE_TRANSCRIPT_QUERY = `
+  SELECT
+    CASE WHEN json_valid(m.data) THEN json_extract(m.data, '$.role') END AS role,
+    CASE WHEN json_valid(p.data) THEN json_extract(p.data, '$.type') END AS part_type,
+    CASE
+      WHEN json_valid(p.data) AND json_extract(p.data, '$.type') = 'tool'
+      THEN json_object(
+        'type', 'tool',
+        'tool', json_extract(p.data, '$.tool'),
+        'callID', json_extract(p.data, '$.callID'),
+        'state', json_object(
+          'status', json_extract(p.data, '$.state.status'),
+          'input', CASE
+            WHEN LENGTH(CAST(COALESCE(json_extract(p.data, '$.state.input'), '') AS BLOB)) > ${OPENCODE_INPUT_MAX_BYTES}
+            THEN json_object(
+              'filePath', json_extract(p.data, '$.state.input.filePath'),
+              'path', json_extract(p.data, '$.state.input.path'),
+              'command', substr(COALESCE(json_extract(p.data, '$.state.input.command'), ''), 1, ${OPENCODE_OUTPUT_MAX_CHARS}),
+              'description', substr(COALESCE(json_extract(p.data, '$.state.input.description'), ''), 1, ${OPENCODE_OUTPUT_MAX_CHARS}),
+              'cwd', json_extract(p.data, '$.state.input.cwd'),
+              'workdir', json_extract(p.data, '$.state.input.workdir'),
+              'working_directory', json_extract(p.data, '$.state.input.working_directory')
+            )
+            ELSE json_extract(p.data, '$.state.input')
+          END,
+          'output', substr(COALESCE(json_extract(p.data, '$.state.output'), ''), 1, ${OPENCODE_OUTPUT_MAX_CHARS})
+        )
+      )
+      ELSE p.data
+    END AS part_data,
+    m.time_created AS time_created
+  FROM message m
+  JOIN part p ON p.message_id = m.id AND p.session_id = m.session_id
+  WHERE m.session_id = ?
+  ORDER BY m.time_created ASC, p.time_created ASC;
+`.replace(/\n/g, ' ');
 export function parseOpenCode(filePath) {
-    const [dbPath, sessionId] = filePath.split('#');
+    const { container: dbPath, fragment: sessionId } = splitSessionFilePath(filePath);
     if (!dbPath || !sessionId)
         return [];
     const events = [];
     // Read through the node/bun SQLite wrapper (not the `sqlite3` CLI) so this
     // works on every OS — the CLI is absent on Windows.
     let rows;
+    // OpenCode stores the session's checklist in its own `todo` table (the current
+    // snapshot, not a history). Emitted below as one `todo_write` tool_use event so
+    // the shared enrichment (`extractTodoProgressFromEvents`) computes `todos`
+    // uniformly with every other harness (RUSH-2358).
+    let todoRows = [];
     let db;
     try {
-        // Query messages with their parts, ordered chronologically. Tool parts are
-        // truncated to keep large tool outputs from bloating memory; the session id
-        // is bound as a parameter rather than interpolated.
-        const query = `
-      SELECT
-        json_extract(m.data, '$.role') AS role,
-        json_extract(p.data, '$.type') AS part_type,
-        CASE
-          WHEN json_extract(p.data, '$.type') = 'tool'
-          THEN substr(p.data, 1, 2000)
-          ELSE p.data
-        END AS part_data,
-        m.time_created AS time_created
-      FROM message m
-      JOIN part p ON p.message_id = m.id AND p.session_id = m.session_id
-      WHERE m.session_id = ?
-      ORDER BY m.time_created ASC, p.time_created ASC;
-    `.replace(/\n/g, ' ');
+        // Messages with their parts, ordered chronologically. The query — and why
+        // the tool part is projected rather than carried whole — is documented on
+        // OPENCODE_TRANSCRIPT_QUERY above.
         db = new Database(dbPath);
-        rows = db.prepare(query).all(sessionId);
+        rows = db.prepare(OPENCODE_TRANSCRIPT_QUERY).all(sessionId);
+        // The `todo` table is a newer OpenCode addition. Probe for it the same way
+        // the scanner probes newer `session` columns, rather than wrapping the read
+        // in a blanket catch — a catch there reported a locked, corrupt, or
+        // permission-denied database as "this session has no todos".
+        //
+        // Row COUNT, not an empty-`get()` sentinel: the two production runtimes
+        // disagree on what `get()` returns for no row — node:sqlite gives
+        // `undefined`, bun:sqlite gives `null` (both ship; see sqlite.ts). A check
+        // written against either sentinel is always-true on the other runtime,
+        // which would run the `todo` SELECT on a schema that has no such table,
+        // throw, and hand the whole transcript to the outer catch — an empty
+        // session, silently, and only in the shipped Bun binary. `.all().length`
+        // cannot express that disagreement.
+        const hasTodoTable = db
+            .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'todo';`)
+            .all().length > 0;
+        if (hasTodoTable) {
+            todoRows = db
+                .prepare('SELECT content, status, time_updated FROM todo WHERE session_id = ? ORDER BY position ASC;')
+                .all(sessionId);
+        }
     }
     catch {
         /* DB not accessible, sqlite module unavailable, or query failed */
@@ -1400,6 +1522,29 @@ export function parseOpenCode(filePath) {
     catch {
         /* malformed row payload — return what we parsed so far */
     }
+    // Emit the OpenCode `todo` table as one `todo_write` snapshot so the shared
+    // enrichment layer derives `todos` the same way it does for every harness that
+    // records a checklist tool. `todo_write` is in SNAPSHOT_TODO_TOOLS, and the
+    // enrichment reads `args.todos`, so the shape matches without special-casing.
+    const todos = todoRows
+        .map(t => ({
+        content: typeof t.content === 'string' ? t.content : '',
+        status: typeof t.status === 'string' ? t.status : 'pending',
+    }))
+        .filter(t => t.content.trim());
+    if (todos.length) {
+        const lastTodoMs = todoRows.reduce((max, t) => {
+            const ms = typeof t.time_updated === 'number' ? t.time_updated : parseInt(String(t.time_updated), 10);
+            return Number.isFinite(ms) && ms > max ? ms : max;
+        }, 0);
+        events.push({
+            type: 'tool_use',
+            agent: 'opencode',
+            timestamp: lastTodoMs > 0 ? new Date(lastTodoMs).toISOString() : new Date().toISOString(),
+            tool: 'todo_write',
+            args: { todos },
+        });
+    }
     return events;
 }
 // ---------------------------------------------------------------------------

package/dist/lib/session/session-cache.d.ts

@@ -2,13 +2,14 @@ import type { ActiveSession } from './active.js';
 /**
  * How long a snapshot may be served before a reader re-gathers.
  * Short on purpose: live status (running/idle/waiting) must not go stale.
- * The daemon warm tick uses the same cadence (see {@link SESSION_CACHE_WARM_INTERVAL_MS}).
+ * The daemon warms more frequently than this ceiling so normal readers hit a
+ * fresh snapshot while expiry still forces a live gather after a missed tick.
  */
-export declare const DEFAULT_ACTIVE_CACHE_MAX_AGE_MS: number;
-/** Daemon warm interval — keep in sync with the setInterval in `lib/daemon.ts`. */
-export declare const SESSION_CACHE_WARM_INTERVAL_MS: number;
-/** Kick off the first warm 30s after daemon start (staggered off other ticks). */
-export declare const SESSION_CACHE_WARM_KICKOFF_MS = 30000;
+export declare const DEFAULT_ACTIVE_CACHE_MAX_AGE_MS = 15000;
+/** Daemon warm interval — below the freshness ceiling to avoid an expiry gap. */
+export declare const SESSION_CACHE_WARM_INTERVAL_MS = 10000;
+/** Kick off the first warm shortly after daemon start, staggered off bootstrap. */
+export declare const SESSION_CACHE_WARM_KICKOFF_MS = 5000;
 /** Snapshot scope: this host only, or a fleet-wide merge written by a reader. */
 export type ActiveCacheScope = 'local' | 'fleet';
 export interface ActiveSessionsSnapshot {
@@ -56,6 +57,8 @@ export declare const IMMUTABLE_FIELD_KEYS: readonly ["topic", "label", "name", "
 export declare const LIVE_STATUS_KEYS: readonly ["status", "activity", "preview", "tokPerSec", "awaitingReason", "question", "todos", "tail", "lastActivityMs", "hostLink", "presence", "pidAlive", "tmuxClients", "windowHeartbeatMs", "provenance", "rateLimited", "plan"];
 /** Test seam: redirect the snapshot file. Returns the previous override. */
 export declare function setActiveSessionsSnapshotPathForTest(p: string | null): string | null;
+/** Test seam: isolate process-local entries between fixtures. */
+export declare function clearActiveSnapshotMemoryForTest(): void;
 /** Test seam: redirect the immutable-memo file. Returns the previous override. */
 export declare function setImmutableMemoPathForTest(p: string | null): string | null;
 /** Read one scope from the snapshot file (best-effort; missing/corrupt → null). */

package/dist/lib/session/session-cache.js

@@ -24,6 +24,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { createMemoryCache } from '../memory-cache.js';
 import { getCacheDir } from '../state.js';
 /** Snapshot file under `getCacheDir()` (regenerable, gitignored). */
 const SNAPSHOT_FILE = '.active-sessions.json';
@@ -32,13 +33,19 @@ const IMMUTABLE_FILE = '.active-session-immutable.json';
 /**
  * How long a snapshot may be served before a reader re-gathers.
  * Short on purpose: live status (running/idle/waiting) must not go stale.
- * The daemon warm tick uses the same cadence (see {@link SESSION_CACHE_WARM_INTERVAL_MS}).
+ * The daemon warms more frequently than this ceiling so normal readers hit a
+ * fresh snapshot while expiry still forces a live gather after a missed tick.
  */
-export const DEFAULT_ACTIVE_CACHE_MAX_AGE_MS = 4 * 60_000;
-/** Daemon warm interval — keep in sync with the setInterval in `lib/daemon.ts`. */
-export const SESSION_CACHE_WARM_INTERVAL_MS = 3 * 60_000;
-/** Kick off the first warm 30s after daemon start (staggered off other ticks). */
-export const SESSION_CACHE_WARM_KICKOFF_MS = 30_000;
+export const DEFAULT_ACTIVE_CACHE_MAX_AGE_MS = 15_000;
+/** Daemon warm interval — below the freshness ceiling to avoid an expiry gap. */
+export const SESSION_CACHE_WARM_INTERVAL_MS = 10_000;
+/** Kick off the first warm shortly after daemon start, staggered off bootstrap. */
+export const SESSION_CACHE_WARM_KICKOFF_MS = 5_000;
+/** Process-local L1. The atomic snapshot remains the cross-process source. */
+const activeSnapshotMemory = createMemoryCache({
+    max: 2,
+    ttlMs: DEFAULT_ACTIVE_CACHE_MAX_AGE_MS,
+});
 /** Keys stored in the immutable memo (transcript-stable). */
 export const IMMUTABLE_FIELD_KEYS = [
     'topic',
@@ -92,8 +99,13 @@ let immutablePathOverride = null;
 export function setActiveSessionsSnapshotPathForTest(p) {
     const prev = snapshotPathOverride;
     snapshotPathOverride = p;
+    activeSnapshotMemory.clear();
     return prev;
 }
+/** Test seam: isolate process-local entries between fixtures. */
+export function clearActiveSnapshotMemoryForTest() {
+    activeSnapshotMemory.clear();
+}
 /** Test seam: redirect the immutable-memo file. Returns the previous override. */
 export function setImmutableMemoPathForTest(p) {
     const prev = immutablePathOverride;
@@ -109,6 +121,9 @@ function immutablePath() {
 // ── snapshot read / write ──────────────────────────────────────────────────
 /** Read one scope from the snapshot file (best-effort; missing/corrupt → null). */
 export function readActiveSessionsCache(scope) {
+    const memory = activeSnapshotMemory.get(scope);
+    if (memory)
+        return memory;
     try {
         const parsed = JSON.parse(fs.readFileSync(snapshotPath(), 'utf-8'));
         if (!parsed || parsed.version !== 1 || !parsed.entries)
@@ -116,6 +131,7 @@ export function readActiveSessionsCache(scope) {
         const entry = parsed.entries[scope];
         if (!entry || !Array.isArray(entry.sessions) || typeof entry.capturedAt !== 'number')
             return null;
+        activeSnapshotMemory.set(scope, entry);
         return entry;
     }
     catch {
@@ -153,6 +169,7 @@ export function writeActiveSessionsCache(scope, sessions, opts = {}) {
         const tmp = `${snapshotPath()}.tmp`;
         fs.writeFileSync(tmp, JSON.stringify(body));
         fs.renameSync(tmp, snapshotPath());
+        activeSnapshotMemory.set(scope, snap);
     }
     catch {
         // best-effort

package/dist/lib/shims.js

@@ -600,6 +600,18 @@ else
   BINARY="$VERSION_DIR/node_modules/.bin/$CLI_COMMAND"
 fi
 
+# A managed binary must never resolve back into this dispatcher. This can
+# happen when an install-script launcher was imported before adoption and was
+# later repointed at the agents shim. Use the durable native target recorded by
+# adoption instead of recursively exec-ing this script.
+if [ -x "$BINARY" ]; then
+  RESOLVED_BINARY=$(realpath "$BINARY" 2>/dev/null || readlink -f "$BINARY" 2>/dev/null || echo "")
+  RESOLVED_SHIM=$(realpath "$AGENTS_USER_DIR/.cache/shims/$CLI_COMMAND" 2>/dev/null || readlink -f "$AGENTS_USER_DIR/.cache/shims/$CLI_COMMAND" 2>/dev/null || echo "")
+  if [ -n "$RESOLVED_BINARY" ] && [ "$RESOLVED_BINARY" = "$RESOLVED_SHIM" ]; then
+    BINARY=$(adopted_original_bin || echo "")
+  fi
+fi
+
 # Auto-install if not present
 if [ ! -x "$BINARY" ]; then
   if [ "$VERSION_SOURCE" = "project" ]; then