akm-cli 0.9.31 → 0.10.261002-beta

package/dist/integrations/harnesses/opencode/config-import.js

@@ -6,75 +6,144 @@
  * #564).
  *
  * Detects an OpenCode installation (filesystem only, no network) and reads its
- * config to extract LLM connection details. API key VALUES are never stored —
- * only the env var name that holds them. The pluggable registry
- * (`HARNESS_CONFIG_IMPORTERS`) and the Claude importer stay in their respective
- * modules; `setup/harness-config-import.ts` imports this importer back.
+ * config to extract the connection details of the user's SELECTED model. It is
+ * a pure reader, so one implementation serves OpenCode 1 and 2 configs and
+ * writes nothing into either. API key VALUES are never stored: only the name
+ * of the environment variable a `{env:NAME}` / `$NAME` reference points at.
+ * A literal key or a `{file:path}` reference yields no credential (a literal
+ * must not be copied, and akm's setup has no file-reference slot to carry it).
  *
- * Behaviour-preserving relocation.
+ * Config shapes (checked against OpenCode 1.18.34 and 2.0.26):
+ *   - files: `opencode.json` / `opencode.jsonc` in the global config dir and
+ *     the project (cwd, `.opencode/`); V1 also reads a legacy `config.json`.
+ *   - `model`: `"provider/model"` string (V1, and accepted by V2) or
+ *     `{providerID, model}` (V2).
+ *   - V1 providers: `provider.<id>.options.{baseURL,apiKey}`, `models.<k>.id`.
+ *   - V2 providers: `providers.<id>.settings.{baseURL,apiKey}`, `env: [NAME]`,
+ *     `models.<k>.modelID`. V2 also accepts the V1 `provider` key, so both are
+ *     read per file and merged by provider id.
+ * The provider is the one `model` names. When no model is selected, or it
+ * names a provider the config does not define, nothing else is substituted.
  */
 import fs from "node:fs";
 import path from "node:path";
+import { asNonEmptyString, asRecord, parseJsonc, toErrorMessage } from "../../../core/common.js";
+import { warnOnce } from "../../../core/warn.js";
 import { homeDir } from "../shared.js";
+const asObject = asRecord;
+const str = asNonEmptyString;
+function configDir() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    return path.join(xdg && xdg.length > 0 ? xdg : path.join(homeDir(), ".config"), "opencode");
+}
+/** Config files in increasing precedence: global, explicit env overrides, then the project. */
+function candidateFiles() {
+    const dirs = [configDir(), process.env.OPENCODE_CONFIG_DIR].filter((d) => !!d);
+    const files = [path.join(configDir(), "config.json"), path.join(homeDir(), ".opencode", "config.json")];
+    for (const dir of dirs)
+        files.push(path.join(dir, "opencode.json"), path.join(dir, "opencode.jsonc"));
+    if (process.env.OPENCODE_CONFIG)
+        files.push(process.env.OPENCODE_CONFIG);
+    const cwd = process.cwd();
+    files.push(path.join(cwd, "opencode.json"), path.join(cwd, "opencode.jsonc"), path.join(cwd, ".opencode", "config.json"), path.join(cwd, ".opencode", "opencode.json"), path.join(cwd, ".opencode", "opencode.jsonc"));
+    return [...new Set(files)];
+}
+/** `provider/model` or `{providerID, model}` -> the selection, or undefined when none is made. */
+function selectedModel(model) {
+    const obj = asObject(model);
+    if (obj) {
+        const providerId = str(obj.providerID);
+        const modelKey = str(obj.model);
+        return providerId && modelKey ? { providerId, modelKey } : undefined;
+    }
+    const text = str(model);
+    const slash = text?.indexOf("/") ?? -1;
+    if (!text || slash < 1 || slash === text.length - 1)
+        return undefined;
+    return { providerId: text.slice(0, slash), modelKey: text.slice(slash + 1) };
+}
 /**
- * Imports LLM config from an OpenCode installation.
- *
- * OpenCode stores config in `~/.config/opencode/config.json` or
- * `~/.opencode/config.json`. Its schema has a `providers` array and a
- * `model` field. API keys in providers appear as `$ENV_VAR_NAME` references.
+ * Add one file's providers, from both the V2 (`providers`/`settings`) and V1
+ * (`provider`/`options`) keys, into `out`: a later file's values win per field.
  */
+function readProviders(raw, out) {
+    for (const [key, settingsKey] of [
+        ["provider", "options"],
+        ["providers", "settings"],
+    ]) {
+        const map = asObject(raw[key]);
+        if (!map)
+            continue;
+        for (const [id, value] of Object.entries(map)) {
+            const p = asObject(value);
+            if (!p)
+                continue;
+            const settings = asObject(p[settingsKey]);
+            const entry = out.get(id) ?? { models: new Map() };
+            entry.baseUrl = str(settings?.baseURL) ?? str(settings?.baseUrl) ?? entry.baseUrl;
+            entry.apiKey = str(settings?.apiKey) ?? entry.apiKey;
+            if (Array.isArray(p.env))
+                entry.env = p.env.filter((e) => typeof e === "string");
+            for (const [modelKey, m] of Object.entries(asObject(p.models) ?? {})) {
+                const mo = asObject(m);
+                entry.models.set(modelKey, str(mo?.modelID) ?? str(mo?.id) ?? entry.models.get(modelKey));
+            }
+            out.set(id, entry);
+        }
+    }
+}
+/** The env var an apiKey reference names: `{env:NAME}`, `$NAME` or `${NAME}`. Literals and `{file:}` give undefined. */
+function envVarOf(apiKey) {
+    if (!apiKey)
+        return undefined;
+    const m = /^(?:\{env:([A-Za-z_][A-Za-z0-9_]*)\}|\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*))$/.exec(apiKey);
+    return m?.[1] ?? m?.[2] ?? m?.[3];
+}
+/** Imports the selected model's LLM connection from an OpenCode 1 or 2 config. */
 export const openCodeImporter = {
     harnessName: "OpenCode",
     detect() {
-        const home = homeDir();
-        return fs.existsSync(path.join(home, ".config", "opencode")) || fs.existsSync(path.join(home, ".opencode"));
+        return fs.existsSync(configDir()) || fs.existsSync(path.join(homeDir(), ".opencode"));
     },
     importConfig() {
-        const home = homeDir();
-        const candidates = [
-            path.join(home, ".config", "opencode", "config.json"),
-            path.join(home, ".opencode", "config.json"),
-            path.join(process.cwd(), ".opencode", "config.json"),
-        ];
-        for (const filePath of candidates) {
+        let model;
+        let read = false;
+        const providers = new Map();
+        for (const filePath of candidateFiles()) {
+            let raw;
             try {
                 if (!fs.existsSync(filePath))
                     continue;
-                const raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
-                // OpenCode config shape: { model?: string, providers?: Array<{id, apiKey, baseUrl, ...}> }
-                const model = typeof raw.model === "string" ? raw.model : undefined;
-                // Extract provider info from the first entry in the providers array
-                let provider;
-                let baseUrl;
-                let apiKeyEnvVar;
-                const providers = Array.isArray(raw.providers) ? raw.providers : [];
-                if (providers.length > 0) {
-                    const first = providers[0];
-                    provider = typeof first?.id === "string" ? first.id : undefined;
-                    baseUrl =
-                        typeof first?.baseUrl === "string"
-                            ? first.baseUrl
-                            : typeof first?.base_url === "string"
-                                ? first.base_url
-                                : undefined;
-                    // apiKey is an env var reference like "$OPENAI_API_KEY" — extract the var name
-                    const apiKeyVal = typeof first?.apiKey === "string" ? first.apiKey : "";
-                    if (apiKeyVal.startsWith("$")) {
-                        apiKeyEnvVar = apiKeyVal.slice(1);
-                    }
-                }
-                return {
-                    harnessName: "OpenCode",
-                    provider,
-                    model,
-                    baseUrl,
-                    apiKeyEnvVar,
-                };
+                raw = asObject(parseJsonc(fs.readFileSync(filePath, "utf8")));
             }
-            catch {
-                // try next candidate
+            catch (error) {
+                warnOnce(`opencode-config-import:${filePath}`, `OpenCode config ${filePath} could not be read (${toErrorMessage(error)}); skipped.`);
+                continue;
             }
+            if (!raw)
+                continue;
+            read = true;
+            if (raw.model !== undefined)
+                model = raw.model;
+            readProviders(raw, providers);
+        }
+        if (!read)
+            return null;
+        const result = { harnessName: "OpenCode" };
+        const selection = selectedModel(model);
+        if (!selection)
+            return result;
+        const entry = providers.get(selection.providerId);
+        result.provider = selection.providerId;
+        result.model = entry?.models.get(selection.modelKey) ?? selection.modelKey;
+        if (entry?.baseUrl)
+            result.baseUrl = entry.baseUrl;
+        const envVar = envVarOf(entry?.apiKey) ?? (!entry?.apiKey && entry?.env?.length === 1 ? entry.env[0] : undefined);
+        if (envVar)
+            result.apiKeyEnvVar = envVar;
+        else if (entry?.apiKey) {
+            warnOnce(`opencode-config-import:credential:${selection.providerId}`, `OpenCode provider "${selection.providerId}" has an API key that is not an environment-variable reference; it was not imported. Export the key as an environment variable and reference it there.`);
         }
-        return null;
+        return result;
     },
 };

package/dist/integrations/harnesses/opencode/index.js

@@ -1,9 +1,27 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * OpenCode harness (#564).
+ *
+ * Per-harness barrel that gathers the OpenCode integration surfaces previously
+ * scattered across the codebase:
+ *   - session-log reader     → ./session-log.ts   (OpenCodeProvider)
+ *   - agent command builder  → ./agent-builder.ts (opencodeBuilder)
+ *   - config importer        → ./config-import.ts (openCodeImporter)
+ *
+ * It also defines {@link OpencodeHarness}, the {@link AkmHarness} descriptor
+ * that `HARNESS_REGISTRY` registers.
+ *
+ * id normalization: OpenCode's canonical id (`'opencode'`) is also its runtime
+ * identity and session-log provider name — there is no historical split (unlike
+ * Claude Code's 'claude' vs 'claude'), so no alias bridge is needed.
+ */
+import { OPENCODE_ENV_PASSTHROUGH } from "../../../core/spawn-env.js";
 import { caps } from "../shared.js";
 import { BaseHarness } from "../types.js";
 import { opencodeBuilder } from "./agent-builder.js";
+import { openCodeImporter } from "./config-import.js";
 import { OpenCodeProvider } from "./session-log.js";
 export { opencodeBuilder } from "./agent-builder.js";
 export { openCodeImporter } from "./config-import.js";
@@ -20,6 +38,8 @@ export class OpencodeHarness extends BaseHarness {
     // session-log provider, so offering it as a stash source is functional.
     setupDetectionDir = ".config/opencode";
     agentBuilder = opencodeBuilder;
+    configImporter = openCodeImporter;
+    profile = { bin: "opencode", args: ["run"], envPassthrough: OPENCODE_ENV_PASSTHROUGH };
     // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
     // Session-id env marker for run attribution.
     identityEnv = ["OPENCODE_SESSION_ID"];
@@ -28,6 +48,8 @@ export class OpencodeHarness extends BaseHarness {
         sessionLogs: true,
         agentDispatch: true,
         detection: true,
+        modelWork: true,
+        nativeAgent: true,
         configImport: true,
     });
 }

package/dist/integrations/harnesses/opencode/plugin-layout.js

@@ -0,0 +1,68 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Where each OpenCode major installs the akm plugin (#1049). `akm upgrade`
+ * (`commands/sources/plugin-upgrade.ts`) refreshes these caches and `akm health`
+ * (`commands/health/plugin-staleness.ts`) reads the akm-cli bundled in them, so
+ * the layout is written down once, here.
+ *
+ * OpenCode 1 and OpenCode 2 share `~/.config/opencode` and `~/.cache/opencode`
+ * but lay both out differently, and each major only loads its own package, so a
+ * host is handled per flavor and a flavor never touches the other's package,
+ * cache or config entry.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { tryParseJson } from "../../../core/common.js";
+/** The newest numbered build folder (`<epoch-ms>`) under an OpenCode 2 cache folder. */
+export function newestBuildDir(folder) {
+    try {
+        const builds = fs.readdirSync(folder).filter((name) => /^\d+$/.test(name));
+        builds.sort((a, b) => Number(b) - Number(a));
+        return builds[0] ? path.join(folder, builds[0]) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** A package.json's `version`, or undefined when the file is missing, unreadable or has none. */
+export function readPackageVersion(file) {
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    const pkg = tryParseJson(text);
+    return typeof pkg?.version === "string" ? pkg.version : undefined;
+}
+export const OPENCODE_V1 = {
+    harness: "opencode",
+    pkg: "akm-opencode",
+    major: 1,
+    configKeys: ["plugin"],
+    globalConfigOnly: false,
+    // OpenCode 1: <cache>/opencode/packages/<spec>/node_modules/<pkg>
+    cacheFolder: (spec) => path.join("packages", spec),
+    nodeModulesDir: (folder) => path.join(folder, "node_modules"),
+    // Any OpenCode command that resolves the config installs the plugin again.
+    prefetch: () => ["debug", "config"],
+};
+export const OPENCODE_V2 = {
+    harness: "opencode-v2",
+    pkg: "akm-opencode-v2",
+    major: 2,
+    // OpenCode 2.0.26 reads both keys; its own `plugin add` writes `plugins`.
+    configKeys: ["plugins", "plugin"],
+    globalConfigOnly: true,
+    // OpenCode 2: <cache>/opencode/npm/<spec>/<epoch-ms>/node_modules/<pkg>
+    cacheFolder: (spec) => path.join("npm", spec),
+    nodeModulesDir: (folder) => {
+        const build = newestBuildDir(folder);
+        return build ? path.join(build, "node_modules") : undefined;
+    },
+    // `debug config` does not resolve plugins in OpenCode 2; `plugin add` of a configured spec only reinstalls it.
+    prefetch: (spec) => ["plugin", "add", spec],
+};

package/dist/integrations/harnesses/opencode/session-log-types.js

@@ -0,0 +1,12 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+export function toMeta(r, sessionId) {
+    return {
+        sessionId,
+        startedAt: typeof r.time_created === "number" ? r.time_created : undefined,
+        endedAt: typeof r.time_updated === "number" ? r.time_updated : undefined,
+        projectHint: typeof r.directory === "string" && r.directory.length > 0 ? r.directory : undefined,
+        title: typeof r.title === "string" && r.title.length > 0 ? r.title : undefined,
+    };
+}

package/dist/integrations/harnesses/opencode/session-log-v1.js

@@ -0,0 +1,72 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { extractInlineRefMentions } from "../../session-logs/inline-refs.js";
+import { toMeta } from "./session-log-types.js";
+/** Listing needs only `session`; reading a session needs `message` and `part`, and fails loudly without them. */
+export const V1_TABLES = ["session"];
+/** Every V1 session updated at or after `sinceMs`, newest first. Throws on an incompatible schema. */
+export function listV1Sessions(db, sinceMs) {
+    const rows = db
+        .prepare("SELECT id, title, directory, time_created, time_updated FROM session WHERE time_updated >= ? ORDER BY time_updated DESC")
+        .all(sinceMs);
+    return rows.map((r) => toMeta(r, r.id));
+}
+/** Whether a V1 `session` row exists for `sessionId`. */
+export function hasV1Session(db, sessionId) {
+    return db.prepare("SELECT id FROM session WHERE id = ?").get(sessionId) !== undefined;
+}
+/**
+ * One event per message, text-parts concatenated in time order. Throws on an
+ * incompatible schema; individual unparsable rows are skipped.
+ */
+export function readV1Session(db, harness, sessionId, filePath) {
+    const meta = db
+        .prepare("SELECT title, directory, time_created, time_updated FROM session WHERE id = ?")
+        .get(sessionId);
+    const messages = db
+        .prepare("SELECT id, data, time_created FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC")
+        .all(sessionId);
+    const parts = db
+        .prepare("SELECT message_id, data FROM part WHERE session_id = ? ORDER BY time_created ASC, id ASC")
+        .all(sessionId);
+    const textByMessage = new Map();
+    for (const part of parts) {
+        let parsed;
+        try {
+            parsed = JSON.parse(part.data);
+        }
+        catch {
+            continue;
+        }
+        if (parsed?.type !== "text")
+            continue;
+        const text = parsed.text;
+        if (typeof text !== "string" || text.length < 1)
+            continue;
+        const bucket = textByMessage.get(part.message_id) ?? [];
+        bucket.push(text);
+        textByMessage.set(part.message_id, bucket);
+    }
+    const events = [];
+    const inlineRefs = [];
+    for (const message of messages) {
+        let mdata = {};
+        try {
+            mdata = JSON.parse(message.data);
+        }
+        catch {
+            // role/timing unavailable — fall through with defaults
+        }
+        const role = typeof mdata.role === "string" ? mdata.role : "unknown";
+        const mtime = mdata.time?.created;
+        const ts = typeof mtime === "number" ? mtime : typeof message.time_created === "number" ? message.time_created : undefined;
+        const text = (textByMessage.get(message.id) ?? []).join("\n").trim();
+        if (text.length < 1)
+            continue;
+        events.push({ harness, text, ts, sessionId, role, filePath });
+        inlineRefs.push(...extractInlineRefMentions(text, ts));
+    }
+    events.sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
+    return { meta: meta ? toMeta(meta, sessionId) : { sessionId }, events, inlineRefs };
+}

package/dist/integrations/harnesses/opencode/session-log-v2.js

@@ -0,0 +1,140 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * OpenCode 2 session-store adapter. V2 keeps one `session_v2` row per session
+ * and the ordered conversation as `session_message` rows (`type` + JSON `data`
+ * minus `id`/`type`, shapes from `@opencode/client` `SessionMessageInfo`).
+ * Read-only: the database is never migrated; V1 rows a native upgrade copied
+ * here arrive as the same shapes under the same session id.
+ *
+ * Mapping into the session-log contract follows the Codex reader: user and
+ * assistant text become events of that role, a tool call becomes
+ * `[tool:<name>] <input>` and its outcome a `tool` event
+ * `[tool_result] <output>`, so the inline-ref scanner sees shell commands.
+ * Reasoning, compaction, synthetic/system and bookkeeping messages are skipped.
+ */
+import { asRecord, tryParseJson } from "../../../core/common.js";
+import { warnOnce } from "../../../core/warn.js";
+import { extractInlineRefMentions } from "../../session-logs/inline-refs.js";
+import { toMeta } from "./session-log-types.js";
+export const V2_TABLES = ["session_v2", "session_message"];
+/** Every V2 session updated at or after `sinceMs`, newest first. Throws on an incompatible schema. */
+export function listV2Sessions(db, sinceMs) {
+    const rows = db
+        .prepare("SELECT id, title, directory, time_created, time_updated FROM session_v2 WHERE time_updated >= ? ORDER BY time_updated DESC")
+        .all(sinceMs);
+    return rows.map((r) => toMeta(r, r.id));
+}
+/** Whether `sessionId` has a `session_v2` row, and how many `session_message` rows it owns. */
+export function v2SessionState(db, sessionId) {
+    const row = db
+        .prepare("SELECT (SELECT COUNT(*) FROM session_message WHERE session_id = s.id) AS n FROM session_v2 s WHERE s.id = ?")
+        .get(sessionId);
+    return row ? { exists: true, messages: row.n } : { exists: false, messages: 0 };
+}
+const asObject = asRecord;
+function asNumber(v) {
+    return typeof v === "number" ? v : undefined;
+}
+/** A tool input as text: a shell command stays a bare command line so inline-ref scanning matches it. */
+function toolInputText(input) {
+    const fields = asObject(input);
+    const cmd = fields?.command ?? fields?.cmd;
+    if (typeof cmd === "string")
+        return cmd;
+    if (typeof input === "string")
+        return input;
+    return JSON.stringify(input ?? {}) ?? "";
+}
+/** Tool output blocks as text: text blocks verbatim, file blocks as a `[file: uri]` marker. */
+function toolContentText(content) {
+    if (!Array.isArray(content))
+        return "";
+    const out = [];
+    for (const block of content) {
+        const b = asObject(block);
+        if (!b)
+            continue;
+        if (b.type === "text" && typeof b.text === "string")
+            out.push(b.text);
+        else if (b.type === "file" && typeof b.uri === "string")
+            out.push(`[file: ${b.uri}]`);
+    }
+    return out.join("\n");
+}
+function structuredErrorText(err) {
+    const e = asObject(err);
+    if (typeof e?.message === "string")
+        return e.message;
+    return typeof e?.type === "string" ? e.type : "error";
+}
+/**
+ * Rebuild one session's events in `seq` order. Throws on an incompatible
+ * schema; a message whose JSON cannot be read is skipped with one warning.
+ */
+export function readV2Session(db, harness, sessionId, filePath) {
+    const meta = db
+        .prepare("SELECT title, directory, time_created, time_updated FROM session_v2 WHERE id = ?")
+        .get(sessionId);
+    const rows = db
+        .prepare("SELECT id, type, data, time_created FROM session_message WHERE session_id = ? ORDER BY seq ASC, time_created ASC, id ASC")
+        .all(sessionId);
+    const events = [];
+    const inlineRefs = [];
+    const push = (role, text, ts) => {
+        const trimmed = text.trim();
+        if (trimmed.length < 1)
+            return;
+        events.push({ harness, text: trimmed, ts, sessionId, role, filePath });
+        inlineRefs.push(...extractInlineRefMentions(trimmed, ts));
+    };
+    for (const row of rows) {
+        const data = asObject(tryParseJson(row.data));
+        if (!data) {
+            warnOnce(`opencode-v2-message:${filePath}:${row.id}`, `OpenCode 2 history: skipped unreadable message ${row.id} in session ${sessionId} (${filePath}).`);
+            continue;
+        }
+        const ts = asNumber(asObject(data.time)?.created) ?? asNumber(row.time_created);
+        if (row.type === "user") {
+            if (typeof data.text === "string")
+                push("user", data.text, ts);
+        }
+        else if (row.type === "assistant") {
+            const content = Array.isArray(data.content) ? data.content : [];
+            const text = content
+                .map((c) => asObject(c))
+                .filter((c) => c?.type === "text" && typeof c.text === "string")
+                .map((c) => c.text)
+                .join("\n");
+            push("assistant", text, ts);
+            for (const item of content) {
+                const tool = asObject(item);
+                if (tool?.type !== "tool")
+                    continue;
+                const state = asObject(tool.state);
+                const name = typeof tool.name === "string" ? tool.name : "tool";
+                const toolTime = asObject(tool.time);
+                const callTs = asNumber(toolTime?.created) ?? ts;
+                push("assistant", `[tool:${name}] ${toolInputText(state?.input)}`, callTs);
+                // Streaming/running calls are incomplete history: the call is kept, no result is invented.
+                const doneTs = asNumber(toolTime?.completed) ?? callTs;
+                if (state?.status === "completed") {
+                    push("tool", `[tool_result] ${toolContentText(state.content)}`, doneTs);
+                }
+                else if (state?.status === "error") {
+                    const body = toolContentText(state.content) || structuredErrorText(state.error);
+                    push("tool", `[tool_result] ${body}`, doneTs);
+                }
+            }
+        }
+        else if (row.type === "shell") {
+            if (typeof data.command === "string")
+                push("assistant", `[tool:shell] ${data.command}`, ts);
+            const out = asObject(data.output)?.output;
+            if (typeof out === "string")
+                push("tool", `[tool_result] ${out}`, ts);
+        }
+    }
+    return { meta: meta ? toMeta(meta, sessionId) : { sessionId }, events, inlineRefs };
+}