@phnx-labs/agents-cli 1.22.106 → 1.22.109

package/dist/lib/devices/doctor-findings.d.ts

@@ -1,6 +1,7 @@
 import type { AgentId } from '../types.js';
 import type { DuplicateVersionHook } from '../hooks/install.js';
 import type { AgentsBinaryShadow } from '../binary-shadow.js';
+import type { LeakedDaemon } from '../daemon/leaked-daemons.js';
 import type { RcSecretFinding } from '../secrets-types.js';
 import type { OwnerSinkStatus } from '../channels/owner-sink.js';
 import { type WindowsSshEnrollmentAudit } from './windows-ssh-enrollment.js';
@@ -13,7 +14,7 @@ export type FindingSeverity = 'critical' | 'warning';
  *  the JSON consumer group by kind. */
 /** Every finding class. Severity is NOT annotated here — {@link FINDING_SEVERITY}
  *  below owns it, and a second copy in these comments is a fourth place to drift. */
-export declare const ALL_FINDING_KINDS: readonly ["logged-out", "logout-unprovable", "missing-hook", "missing-plugin", "unwired-hook", "hook-runtime-broken", "hook-runtime-visibility-unavailable", "cli-missing", "missing-resource", "content-drift", "never-synced", "stale", "repo-behind", "repo-drift", "fleet-resource-gap", "host-cli-missing", "host-cli-invalid", "version-skew", "orphan", "duplicate-hook", "duplicate-hook-drift", "rc-secret-export", "env-secret-export", "auth-bundle-wrong-backend", "exec-policy", "ssh-key-enrollment", "stale-cli", "binary-shadow", "owner-sink-unreachable"];
+export declare const ALL_FINDING_KINDS: readonly ["logged-out", "logout-unprovable", "missing-hook", "missing-plugin", "unwired-hook", "hook-runtime-broken", "hook-runtime-visibility-unavailable", "cli-missing", "missing-resource", "content-drift", "never-synced", "stale", "repo-behind", "repo-drift", "fleet-resource-gap", "host-cli-missing", "host-cli-invalid", "version-skew", "orphan", "duplicate-hook", "duplicate-hook-drift", "rc-secret-export", "env-secret-export", "auth-bundle-wrong-backend", "exec-policy", "ssh-key-enrollment", "stale-cli", "binary-shadow", "owner-sink-unreachable", "leaked-daemon"];
 /**
  * The severity each kind is emitted with - the SINGLE source of truth, read by
  * the builders below and asserted against both prose rubrics by
@@ -124,6 +125,11 @@ export interface LocalFindingInputs {
     ownerSink?: OwnerSinkStatus;
     /** `agents` binaries that shadow the currently running CLI (RUSH-2431). */
     binaryShadows?: AgentsBinaryShadow[];
+    /** `__daemon-run` processes no owner record names — neither the service
+     *  manager's unit main PID nor the recorded daemon.pid (W4, PHNX-3736).
+     *  Collected by `findLeakedDaemons` in the command (it runs `ps` and reads
+     *  /proc, so it stays out of this pure module). */
+    leakedDaemons?: LeakedDaemon[];
 }
 /**
  * Fold this machine's signals into findings. Missing hooks/plugins and unwired

package/dist/lib/devices/doctor-findings.js

@@ -27,7 +27,7 @@
  *              fleet-resource-gap · hook-runtime-visibility-unavailable · orphan · duplicate-hook ·
  *              duplicate-hook-drift · host-cli-missing · host-cli-invalid ·
  *              rc-secret-export · env-secret-export · auth-bundle-wrong-backend · exec-policy · stale-cli ·
- *              binary-shadow.
+ *              binary-shadow · leaked-daemon.
  *   (RUSH-2162 moved never-synced and duplicate-hook-drift to WARNING: both are
  *   stale-sync states one `agents sync` resolves, not "needs you now".)
  *
@@ -38,6 +38,7 @@
  * format, so the layout is unit-tested against fixtures with no live fleet.
  */
 import chalk from 'chalk';
+import * as path from 'path';
 import { AGENTS, ALL_AGENT_IDS, supportsAccountInspection } from '../agents.js';
 import { blocksLocalScripts } from '../platform/winpath.js';
 import { loginHint } from '../signin-badge.js';
@@ -126,6 +127,7 @@ export const ALL_FINDING_KINDS = [
     'stale-cli',
     'binary-shadow', // another agents binary on PATH or in a well-known dir shadows the running copy
     'owner-sink-unreachable', // the feed/notify owner-delivery lane can't reach the owner from this box
+    'leaked-daemon', // a `__daemon-run` process no owner record names (not the unit main PID, not daemon.pid)
 ];
 /**
  * The severity each kind is emitted with - the SINGLE source of truth, read by
@@ -174,6 +176,12 @@ export const FINDING_SEVERITY = {
     'ssh-key-enrollment': 'critical',
     'stale-cli': 'warning',
     'binary-shadow': 'warning',
+    // A stray `__daemon-run` under its own (usually temp) HOME: it shares nothing
+    // with this install's state, so it cannot double-fire the real box's work —
+    // but it is a leak nothing owns and it outlives whatever launched it (W4,
+    // PHNX-3736). A human reads its HOME/start time and kills it; nothing is
+    // blocked right now.
+    'leaked-daemon': 'warning',
 };
 function agentName(agent) {
     return AGENT_NAMES[agent] || agent;
@@ -305,6 +313,11 @@ export function remediationFor(finding) {
             return 'upgrade';
         case 'binary-shadow':
             return 'remove or repoint the shadowing agents install(s)';
+        case 'leaked-daemon':
+            // The builder emits the concrete `kill <pid>` — the pid is a property of
+            // the row it builds, not of anything remediationFor can see. This is the
+            // shape only, for a kind constructed through finding() by a future caller.
+            return 'kill <pid>';
         case 'owner-sink-unreachable':
             // The lane delivers over the rush-backed owner channel, which needs rush on
             // PATH AND a usable session in THIS context. Non-interactive shells miss a
@@ -579,6 +592,24 @@ export function buildLocalFindings(input) {
                 : `${shadows.length} agents binaries may shadow the running copy (incl. ${examples})`,
         }));
     }
+    // Leaked daemons (warning) — a `__daemon-run` no owner record names. One row
+    // per pid: the remediation is pid-specific, and the HOME + start time are
+    // what let the operator tell a leaked test fixture from something they meant
+    // to run before they kill it (W4, PHNX-3736). Built directly, not through
+    // finding(): the remediation carries this row's own pid.
+    for (const d of input.leakedDaemons ?? []) {
+        const home = d.home ?? 'unknown HOME';
+        const started = d.startedAt ? `, started ${d.startedAt}` : '';
+        // The launch entry names WHICH install leaked the daemon — part of what
+        // the operator judges before killing. Only a real path: for a stand-in
+        // (`node -e '<code>' __daemon-run`) the token is the code blob.
+        const entry = d.entry && path.isAbsolute(d.entry) ? ` · ${d.entry}` : '';
+        out.push({
+            severity: FINDING_SEVERITY['leaked-daemon'], kind: 'leaked-daemon', device,
+            message: `stray agents daemon (pid ${d.pid}) no unit or pid file owns — HOME=${home}${started}${entry}`,
+            remediation: `kill ${d.pid}`,
+        });
+    }
     return collapseAcrossVersions(out, new Set(input.isolatedVersions ?? []));
 }
 /**

package/dist/lib/hooks/install.js

@@ -2256,12 +2256,72 @@ export function pruneVersionHomeHookEntriesFromSettings(settingsPath, agent, rem
     }
     return removed;
 }
+function trustCodexHooks(hooksPath) {
+    const configPath = path.join(path.dirname(hooksPath), 'config.toml');
+    const hooksFile = JSON.parse(fs.readFileSync(hooksPath, 'utf-8'));
+    let tomlConfig = {};
+    if (fs.existsSync(configPath)) {
+        tomlConfig = TOML.parse(fs.readFileSync(configPath, 'utf-8'));
+    }
+    if (!tomlConfig.features || typeof tomlConfig.features !== 'object') {
+        tomlConfig.features = {};
+    }
+    // Codex 0.116+ feature flag is `hooks` (the legacy `codex_hooks` name is
+    // an unrecognized key that triggers a deprecation error and is ignored).
+    const features = tomlConfig.features;
+    delete features.codex_hooks;
+    features.hooks = true;
+    // Pre-trust hooks. The [hooks.state] key is keyed by the hooks.json path
+    // exactly as Codex resolves it (the absolute CODEX_HOME path), the
+    // snake_case event label, and the per-event group/handler indices — which
+    // must match Codex's parse order, so we iterate the just-written
+    // hooksFile structure in array order.
+    if (!tomlConfig.hooks || typeof tomlConfig.hooks !== 'object') {
+        tomlConfig.hooks = {};
+    }
+    const hooksTable = tomlConfig.hooks;
+    const existingState = hooksTable.state && typeof hooksTable.state === 'object'
+        ? hooksTable.state
+        : {};
+    const hookState = {};
+    for (const [event, eventGroups] of Object.entries(hooksFile.hooks)) {
+        const eventKeyLabel = CODEX_EVENT_KEY_LABELS[event];
+        if (!eventKeyLabel)
+            continue;
+        eventGroups.forEach((group, groupIdx) => {
+            if (!group.hooks)
+                return;
+            group.hooks.forEach((handler, handlerIdx) => {
+                if (handler.type !== 'command')
+                    return;
+                const key = `${hooksPath}:${eventKeyLabel}:${groupIdx}:${handlerIdx}`;
+                const trustedHash = computeCodexHookTrustHash(eventKeyLabel, handler.command, handler.timeout, group.matcher);
+                // Preserve a user's explicit `enabled = false` for this exact hook;
+                // only (re)write the trust hash.
+                const prior = existingState[key];
+                const entry = { trusted_hash: trustedHash };
+                if (prior && prior.enabled === false) {
+                    entry.enabled = false;
+                }
+                hookState[key] = entry;
+            });
+        });
+    }
+    // Carry forward trust state for any hooks we did not (re)register this
+    // pass — e.g. user-added hooks under a different command path.
+    for (const [key, entry] of Object.entries(existingState)) {
+        if (!(key in hookState)) {
+            hookState[key] = entry;
+        }
+    }
+    hooksTable.state = hookState;
+    fs.writeFileSync(configPath, TOML.stringify(tomlConfig), 'utf-8');
+}
 function registerHooksForCodex(versionHome, manifest, resolveScript, managedPrefixes) {
     const registered = [];
     const errors = [];
     const configDir = path.join(versionHome, '.codex');
     const hooksPath = path.join(configDir, 'hooks.json');
-    const configPath = path.join(configDir, 'config.toml');
     // Read existing hooks.json — must have top-level "hooks" wrapper key
     let hooksFile = { hooks: {} };
     if (fs.existsSync(hooksPath)) {
@@ -2373,66 +2433,7 @@ function registerHooksForCodex(versionHome, manifest, resolveScript, managedPref
     // them, so an untrusted hook is silently dropped. We compute the same
     // trust hash Codex would and persist it under [hooks.state].
     try {
-        let tomlConfig = {};
-        if (fs.existsSync(configPath)) {
-            try {
-                tomlConfig = TOML.parse(fs.readFileSync(configPath, 'utf-8'));
-            }
-            catch { /* start fresh if corrupt */ }
-        }
-        if (!tomlConfig.features || typeof tomlConfig.features !== 'object') {
-            tomlConfig.features = {};
-        }
-        // Codex 0.116+ feature flag is `hooks` (the legacy `codex_hooks` name is
-        // an unrecognized key that triggers a deprecation error and is ignored).
-        const features = tomlConfig.features;
-        delete features.codex_hooks;
-        features.hooks = true;
-        // Pre-trust hooks. The [hooks.state] key is keyed by the hooks.json path
-        // exactly as Codex resolves it (the absolute CODEX_HOME path), the
-        // snake_case event label, and the per-event group/handler indices — which
-        // must match Codex's parse order, so we iterate the just-written
-        // hooksFile structure in array order.
-        if (!tomlConfig.hooks || typeof tomlConfig.hooks !== 'object') {
-            tomlConfig.hooks = {};
-        }
-        const hooksTable = tomlConfig.hooks;
-        const existingState = hooksTable.state && typeof hooksTable.state === 'object'
-            ? hooksTable.state
-            : {};
-        const hookState = {};
-        for (const [event, eventGroups] of Object.entries(hooksFile.hooks)) {
-            const eventKeyLabel = CODEX_EVENT_KEY_LABELS[event];
-            if (!eventKeyLabel)
-                continue;
-            eventGroups.forEach((group, groupIdx) => {
-                if (!group.hooks)
-                    return;
-                group.hooks.forEach((handler, handlerIdx) => {
-                    if (handler.type !== 'command')
-                        return;
-                    const key = `${hooksPath}:${eventKeyLabel}:${groupIdx}:${handlerIdx}`;
-                    const trustedHash = computeCodexHookTrustHash(eventKeyLabel, handler.command, handler.timeout, group.matcher);
-                    // Preserve a user's explicit `enabled = false` for this exact hook;
-                    // only (re)write the trust hash.
-                    const prior = existingState[key];
-                    const entry = { trusted_hash: trustedHash };
-                    if (prior && prior.enabled === false) {
-                        entry.enabled = false;
-                    }
-                    hookState[key] = entry;
-                });
-            });
-        }
-        // Carry forward trust state for any hooks we did not (re)register this
-        // pass — e.g. user-added hooks under a different command path.
-        for (const [key, entry] of Object.entries(existingState)) {
-            if (!(key in hookState)) {
-                hookState[key] = entry;
-            }
-        }
-        hooksTable.state = hookState;
-        fs.writeFileSync(configPath, TOML.stringify(tomlConfig), 'utf-8');
+        trustCodexHooks(hooksPath);
     }
     catch (err) {
         errors.push(`Failed to update config.toml: ${err.message}`);
@@ -3282,11 +3283,14 @@ export async function installSessionTrackerHook(agent, version, home) {
     if (!invocation) {
         return { installed: false, error: 'session-tracker not built and tsx is unavailable' };
     }
+    const env = sessionTrackerInstallEnv(agent, version, home);
     try {
         await execFileAsync(invocation.command, invocation.args, {
-            env: sessionTrackerInstallEnv(agent, version, home),
+            env,
             encoding: 'utf8',
         });
+        if (agent === 'codex')
+            trustCodexHooks(path.join(env.HOME ?? os.homedir(), '.codex', 'hooks.json'));
         return { installed: true };
     }
     catch (err) {
@@ -3324,12 +3328,15 @@ export function installSessionTrackerHookSync(agent, version, home) {
     if (!invocation) {
         return { installed: false, error: 'session-tracker not built and tsx is unavailable' };
     }
+    const env = sessionTrackerInstallEnv(agent, version, home);
     try {
         execFileSync(invocation.command, invocation.args, {
-            env: sessionTrackerInstallEnv(agent, version, home),
+            env,
             stdio: ['ignore', 'pipe', 'pipe'],
             encoding: 'utf8',
         });
+        if (agent === 'codex')
+            trustCodexHooks(path.join(env.HOME ?? os.homedir(), '.codex', 'hooks.json'));
         return { installed: true };
     }
     catch (err) {

package/dist/lib/hosts/dispatch.d.ts

@@ -182,7 +182,7 @@ export interface InteractiveDispatchOptions {
     agent: string;
     /** Explicit agent version pin (e.g. "2.1.207") to forward as `agent@version`. */
     version?: string;
-    /** Preserve the trailing-@ account picker so selection happens on the execution host. */
+    /** Preserve the trailing-# account picker so selection happens on the execution host. */
     accountPicker?: boolean;
     /** Explicit run strategy (e.g. "balanced") to forward as `--strategy <strategy>`. */
     strategy?: string;

package/dist/lib/hosts/dispatch.js

@@ -362,7 +362,7 @@ async function launchDetached(host, target, opts) {
 /** Compose `agent[@version][#account]` so the peer resolves ITS slot (PHNX-3940 T5). */
 export function runAgentSpecArg(opts) {
     if (opts.accountPicker)
-        return `${opts.agent}@`;
+        return `${opts.agent}#`;
     let spec = opts.agent;
     if (opts.version)
         spec += `@${opts.version}`;

package/dist/lib/models.js

@@ -13,7 +13,8 @@ import { execFileSync } from 'child_process';
 import chalk from 'chalk';
 import { getVersionDir, getVersionHomePath, getBinaryPath } from './installations/versions.js';
 import { getModelsCachePath } from './state.js';
-import { agentConfigDirName } from './agents.js';
+import { agentConfigDirName, resolveOpenCodeXdgPath } from './agents.js';
+import { stripJsonComments } from './permissions-registry.js';
 import { resolveRunDefaults } from './run-defaults.js';
 import { getModelPricing } from './pricing/index.js';
 const CACHE_PATH = getModelsCachePath();
@@ -1014,6 +1015,12 @@ export function resolveConfiguredModel(agent, version, home) {
     const nativeModel = readNativeConfigModel(agent, version, home);
     if (nativeModel)
         return { model: nativeModel, source: 'config' };
+    // The agent's own persisted selection, for a runtime that stores one instead
+    // of flagging a catalog default. Ranks below `config` (an explicit setting
+    // wins) and above the catalog, whose `isDefault` OpenCode never sets.
+    const selected = readNativeSelectedModel(agent, version);
+    if (selected)
+        return { model: selected, source: 'cli-default' };
     const catalog = getModelCatalog(agent, version);
     if (catalog) {
         const flagged = catalog.models.find((m) => m.isDefault);
@@ -1022,15 +1029,79 @@ export function resolveConfiguredModel(agent, version, home) {
     return null;
 }
 /**
- * Best-effort read of the agent's own `model` from its native settings.json
+ * Where each agent keeps its OWN `model` setting, when that is not the
+ * `<configDir>/settings.json` every Claude-shaped harness uses.
+ *
+ * OpenCode reads `~/.config/opencode/opencode.{jsonc,json}` and puts `model` at
+ * its top level as `"<provider>/<model-id>"`. Its `~/.opencode/settings.json`
+ * DOES exist, but that is agents-cli's own plugin-enablement file, which
+ * OpenCode never reads a model from — so the default path found nothing and
+ * every OpenCode row rendered the placeholder `default`. Comments are stripped
+ * for BOTH spellings because OpenCode's loader accepts them in both, which is
+ * also how the MCP writer treats the same file (`format: 'opencode-jsonc'`).
+ */
+const NATIVE_MODEL_CONFIGS = {
+    opencode: {
+        paths: (home) => [
+            path.join(home, '.config', 'opencode', 'opencode.jsonc'),
+            path.join(home, '.config', 'opencode', 'opencode.json'),
+        ],
+        jsonc: true,
+    },
+};
+/**
+ * Best-effort read of the agent's own `model` from its native config
  * (e.g. `~/.agents/.history/versions/claude/<ver>/home/.claude/settings.json`).
  * A missing/malformed file is a fall-through, not an error.
  */
 function readNativeConfigModel(agent, version, home) {
+    const resolvedHome = home ?? getVersionHomePath(agent, version);
+    const native = NATIVE_MODEL_CONFIGS[agent];
+    const candidates = native?.paths(resolvedHome)
+        ?? [path.join(resolvedHome, agentConfigDirName(agent), 'settings.json')];
+    for (const configPath of candidates) {
+        try {
+            const raw = fs.readFileSync(configPath, 'utf8');
+            const parsed = JSON.parse(native?.jsonc ? stripJsonComments(raw) : raw);
+            if (typeof parsed.model === 'string' && parsed.model.trim() !== '')
+                return parsed.model;
+        }
+        catch {
+            /* absent or malformed — try the next spelling */
+        }
+    }
+    return null;
+}
+/**
+ * The model the agent's OWN runtime will start with, for a harness that persists
+ * its selection rather than flagging a catalog default.
+ *
+ * OpenCode is the case that needs it: it ships no default model, so its catalog
+ * has no `isDefault` and `agents view` fell through to the literal `default` —
+ * a placeholder, not something the user could act on. OpenCode instead records
+ * the model picked in its TUI to `$XDG_STATE_HOME/opencode/model.json` as
+ * `{ recent: [{ providerID, modelID }, …] }`, newest first, and reuses
+ * `recent[0]` for the next session. That entry is the real answer to "what model
+ * is this install on", rendered the same `<provider>/<model-id>` way OpenCode's
+ * own config spells it.
+ *
+ * Returns null for every other agent, and for OpenCode when nothing has been
+ * selected yet — the catalog fallback still applies.
+ */
+function readNativeSelectedModel(agent, version) {
+    if (agent !== 'opencode')
+        return null;
+    const statePath = resolveOpenCodeXdgPath(getVersionHomePath(agent, version), 'state', 'model.json');
+    if (!statePath)
+        return null;
     try {
-        const settingsPath = path.join(home ?? getVersionHomePath(agent, version), agentConfigDirName(agent), 'settings.json');
-        const parsed = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-        return typeof parsed.model === 'string' && parsed.model.trim() !== '' ? parsed.model : null;
+        const parsed = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+        const current = parsed.recent?.[0];
+        const provider = typeof current?.providerID === 'string' ? current.providerID : '';
+        const model = typeof current?.modelID === 'string' ? current.modelID : '';
+        if (!model)
+            return null;
+        return provider ? `${provider}/${model}` : model;
     }
     catch {
         return null;

package/dist/lib/session/cloud.js

@@ -53,6 +53,8 @@ function agentToFormat(agent) {
         return 'rush';
     if (agent === 'droid')
         return 'droid';
+    if (agent === 'opencode')
+        return 'opencode';
     return null;
 }
 export function assertContained(candidate, rootDir) {
@@ -128,7 +130,7 @@ export async function ensureCloudSessionCached(executionId, destPath) {
         throw new Error(`session.jsonl fetch ${res.status}: ${body.slice(0, 200)}`);
     }
     const format = (res.headers.get('X-Session-Format') || '').toLowerCase();
-    if (!['claude', 'codex', 'rush'].includes(format)) {
+    if (!['claude', 'codex', 'rush', 'opencode'].includes(format)) {
         throw new Error(`Unknown X-Session-Format on cloud response: "${format}"`);
     }
     const finalPath = callerPath ?? cachePathForExecution(id, format);

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

@@ -229,6 +229,7 @@ export declare function parseGrok(filePath: string): SessionEvent[];
  */
 export declare const OPENCODE_TRANSCRIPT_QUERY: string;
 export declare function parseOpenCode(filePath: string): SessionEvent[];
+export declare function parseOpencodeCloud(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

@@ -12,6 +12,7 @@ import * as path from 'path';
 import Database from '../sqlite.js';
 import { isSyntheticUserMessage, extractSlashCommandName, extractSlashCommandFromToolInput, unwrapUserQuery } from './prompt.js';
 import { structuredToolResult, commandsFromCodexExec } from './tool-calls.js';
+import { isCloudSessionPath } from './cloud.js';
 /**
  * Largest session file we will load into memory. Above this we throw a clean
  * error instead of OOMing or hitting V8's ERR_STRING_TOO_LONG. Aligns with
@@ -143,7 +144,11 @@ const TRANSCRIPT_PARSERS = {
     codex: (filePath) => parseCodex(filePath),
     gemini: (filePath) => parseGemini(filePath),
     antigravity: (filePath) => parseAntigravity(filePath),
-    opencode: (filePath) => parseOpenCode(filePath),
+    // Cloud-captured opencode sessions are normalized JSONL (produced by the
+    // factory at capture time), NOT the local `opencode.db#<session>` SQLite
+    // composite the offline parser reads — route by whether the path is in the
+    // cloud session cache (PHNX-3845).
+    opencode: (filePath) => isCloudSessionPath(filePath) ? parseOpencodeCloud(filePath) : parseOpenCode(filePath),
     grok: (filePath) => parseGrok(filePath),
     rush: (filePath) => parseRush(filePath),
     openclaw: () => [], // OpenClaw sessions don't have parseable files yet
@@ -206,7 +211,7 @@ export function detectAgent(filePath) {
         return 'muse';
     }
     // Cloud convention: cloud-sessions/<id>/session.<format>.jsonl
-    const cloudMatch = filePath.match(/session\.(claude|codex|rush)\.jsonl(?:$|[?#])/);
+    const cloudMatch = filePath.match(/session\.(claude|codex|rush|opencode)\.jsonl(?:$|[?#])/);
     if (cloudMatch)
         return cloudMatch[1];
     if (filePath.includes('opencode.db'))
@@ -1832,6 +1837,135 @@ export function parseOpenCode(filePath) {
     return events;
 }
 // ---------------------------------------------------------------------------
+// OpenCode parser — cloud (normalized JSONL)
+// ---------------------------------------------------------------------------
+//
+// OpenCode stores sessions in a SQLite DB, so the offline path reads a
+// `opencode.db#<session>` composite (parseOpenCode above). The CLOUD path is
+// different: the factory converts that DB into a flat, normalized JSONL
+// transcript at capture time (prix/factory opencode-capture.ts, PHNX-3845), so
+// the whole cloud pipeline stays SQLite-free downstream. This parser reads that
+// JSONL; it's routed from TRANSCRIPT_PARSERS only when the file lives in the
+// cloud session cache (isCloudSessionPath).
+//
+// Each line is one of:
+//   transcript row:
+//     { role: "user"|"assistant", part_type: "text"|"reasoning"|"tool",
+//       part_data: <json string>, time_created: <ms number> }
+//   todo snapshot (at most one, emitted last):
+//     { part_type: "todo", todos: [{content,status}], time_created: <ms> }
+//
+// The per-part logic mirrors parseOpenCode's post-query switch (and prix/api's
+// server-side parseOpencode) so the event stream is identical to the offline
+// path. NOTE: the shell tool is named `bash` on real opencode (>=1.18.x), not
+// `shell` — map `command` for both so a shell step reads by its command line.
+export function parseOpencodeCloud(filePath) {
+    const content = safeReadSessionFile(filePath);
+    const lines = content.split('\n').filter(l => l.trim());
+    const events = [];
+    for (const line of lines) {
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch {
+            /* malformed JSONL line, skip */
+            continue;
+        }
+        const partType = typeof raw.part_type === 'string' ? raw.part_type : '';
+        const timeMs = typeof raw.time_created === 'number'
+            ? raw.time_created
+            : parseInt(String(raw.time_created), 10);
+        const timestamp = Number.isFinite(timeMs)
+            ? new Date(timeMs).toISOString()
+            : new Date().toISOString();
+        // Todo snapshot: emit one `todo_write` tool_use so the shared enrichment
+        // (`extractTodoProgressFromEvents`) derives `todos` the same way it does for
+        // every other harness — the offline parser emits the identical event.
+        if (partType === 'todo') {
+            const todos = Array.isArray(raw.todos) ? raw.todos : [];
+            if (todos.length) {
+                events.push({
+                    type: 'tool_use',
+                    agent: 'opencode',
+                    timestamp,
+                    tool: 'todo_write',
+                    args: { todos },
+                });
+            }
+            continue;
+        }
+        let partData;
+        try {
+            partData = JSON.parse(typeof raw.part_data === 'string' ? raw.part_data : '');
+        }
+        catch {
+            /* malformed part data, skip */
+            continue;
+        }
+        switch (partType) {
+            case 'text': {
+                const text = (partData.text || '').trim();
+                if (text) {
+                    events.push({
+                        type: 'message',
+                        agent: 'opencode',
+                        timestamp,
+                        role: raw.role === 'user' ? 'user' : 'assistant',
+                        content: text,
+                    });
+                }
+                break;
+            }
+            case 'reasoning': {
+                const text = (partData.text || '').trim();
+                if (text) {
+                    events.push({
+                        type: 'thinking',
+                        agent: 'opencode',
+                        timestamp,
+                        content: text,
+                    });
+                }
+                break;
+            }
+            case 'tool': {
+                const toolName = partData.tool || 'unknown';
+                const state = partData.state || {};
+                const input = state.input || {};
+                const output = state.output || '';
+                const callId = typeof partData.callID === 'string' ? partData.callID : undefined;
+                events.push({
+                    type: 'tool_use',
+                    agent: 'opencode',
+                    timestamp,
+                    tool: toolName,
+                    callId,
+                    args: input,
+                    command: toolName === 'bash' || toolName === 'shell' ? input.command : undefined,
+                    path: input.filePath || input.path || undefined,
+                });
+                if (state.status === 'completed' || state.status === 'error') {
+                    const outputStr = typeof output === 'string' ? output : JSON.stringify(output);
+                    events.push({
+                        type: state.status === 'error' ? 'error' : 'tool_result',
+                        agent: 'opencode',
+                        timestamp,
+                        tool: toolName,
+                        callId,
+                        success: state.status === 'completed',
+                        output: outputStr,
+                    });
+                }
+                break;
+            }
+            // step-start / step-finish / patch / file never reach the JSONL (dropped
+            // at capture time) — nothing to handle here.
+        }
+    }
+    return events;
+}
+// ---------------------------------------------------------------------------
 // Rush parser
 //
 // Rush messages.jsonl format is flat: one JSON object per line with

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

@@ -68,7 +68,15 @@ export declare function sessionMatchesAccount(session: Pick<SessionMeta, 'agent'
 export declare function inspectNativeResumeSession(session: SessionMeta, versionHome: string): NativeResumeInspection;
 /** Keep the native conversation where possible; replay remains a separate choice. */
 export declare function resolveSessionRecoveryFromCandidates(session: SessionMeta, candidates: RotateCandidate[], supportsNative?: (agent: AgentId, version?: string) => boolean, nativeInspection?: NativeResumeInspection, options?: SessionRecoverySelection): SessionRecoveryTarget;
-/** A mirror digest or live registry entry is not conversation content. */
+/**
+ * Whether recovery has conversation content to replay for this session: a
+ * non-empty transcript file, or archived content in the index for a row this
+ * device owns. A mirror digest or live registry entry is not conversation
+ * content. The picker consults this before spending a terminal tab on a pick
+ * that {@link assertRecoverableTranscript} would refuse one hop later.
+ */
+export declare function sessionTranscriptReadable(session: SessionMeta): boolean;
+/** Refuse recovery for a session with nothing to replay (PHNX-4080). */
 export declare function assertRecoverableTranscript(session: SessionMeta): void;
 /**
  * Resolve recovery for a durable session, reading the live account pool.

package/dist/lib/session/recovery.js

@@ -365,16 +365,26 @@ export function resolveSessionRecoveryFromCandidates(session, candidates, suppor
         reason: `${sourceReason(session, source, options.model ?? session.model)}; continuing with ${continueWith}`,
     };
 }
-/** A mirror digest or live registry entry is not conversation content. */
-export function assertRecoverableTranscript(session) {
+/**
+ * Whether recovery has conversation content to replay for this session: a
+ * non-empty transcript file, or archived content in the index for a row this
+ * device owns. A mirror digest or live registry entry is not conversation
+ * content. The picker consults this before spending a terminal tab on a pick
+ * that {@link assertRecoverableTranscript} would refuse one hop later.
+ */
+export function sessionTranscriptReadable(session) {
     const file = splitSessionFilePath(session.filePath).container;
     try {
         if (file && fs.statSync(file).isFile() && fs.statSync(file).size > 0
             && (session.agent !== 'opencode' || parseOpenCode(session.filePath).length > 0))
-            return;
+            return true;
     }
     catch { /* The canonical scan already tried to repair this path. */ }
-    if (!session.mirrorSyncedAt && !session.mirrorSource && readSessionContent(session.id)?.trim())
+    return !session.mirrorSyncedAt && !session.mirrorSource && Boolean(readSessionContent(session.id)?.trim());
+}
+/** Refuse recovery for a session with nothing to replay (PHNX-4080). */
+export function assertRecoverableTranscript(session) {
+    if (sessionTranscriptReadable(session))
         return;
     throw new SessionRecoveryError(`Session ${session.shortId} has no readable transcript after checking its account homes and index. ` +
         `No agent was started. Start a new conversation with: agents run ${session.agent}`);