strom-research 1.1.1 → 1.3.0

package/dist/core/relocate.js

@@ -0,0 +1,111 @@
+// Moving the research to another folder (the setting `home`). The trees and the
+// shared folder (connectors, hooks, gates, the inbox, big images) live under it:
+// changing the setting alone would leave them behind — the trees gone from the
+// list, the plugins and images not found. So the whole folder moves with it:
+// renamed where it can be (one disk), else copied and the old one left for the
+// user to delete. Never while somebody works in a tree, never into a folder
+// that holds something already, never into itself.
+import fs from "node:fs";
+import path from "node:path";
+import { loadConsents, saveConsents } from "./connector.js";
+import { liveHolder } from "./lock.js";
+import { liveRunning } from "./live.js";
+import { liveWorkers, runsAtWork } from "./workers.js";
+/** Files a system leaves in any folder: a folder with only these is empty. */
+const LITTER = new Set([".DS_Store", "Thumbs.db", "desktop.ini"]);
+/** What the top of a disk holds of the system's own: the research goes into a folder of its own there. */
+const DISK = new Set([".Spotlight-V100", ".fseventsd", ".Trashes", ".TemporaryItems", ".DocumentRevisions-V100", "System Volume Information", "$RECYCLE.BIN"]);
+function entries(dir) {
+    try {
+        return fs.readdirSync(dir).filter((n) => !LITTER.has(n));
+    }
+    catch {
+        return [];
+    }
+}
+/** Is `inner` the folder `outer` or somewhere in it? (Windows: letters of any case are the same.) */
+export function within(inner, outer, platform = process.platform) {
+    const [a, b] = platform === "win32" ? [inner.toLowerCase(), outer.toLowerCase()] : [inner, outer];
+    const rel = path.relative(b, a);
+    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+/** The same folder? (Windows: letters of any case are the same.) */
+export function sameFolder(a, b, platform = process.platform) {
+    return within(path.resolve(a), path.resolve(b), platform) && within(path.resolve(b), path.resolve(a), platform);
+}
+/** Somebody at work in a tree: an agent present, a run, a command holding its lock, the live bridge. */
+function atWork(root) {
+    return liveWorkers(root).length > 0 || runsAtWork(root).length > 0 || Boolean(liveHolder(path.join(root, ".strom", "tree.lock"))) || Boolean(liveRunning(root));
+}
+/** `trees`: the folders of the trees strom knows (those inside `from` move along). */
+export function planMove(from, to, trees) {
+    const names = entries(from);
+    const inside = trees.filter((t) => within(t, from));
+    const busy = inside.filter(atWork).map((t) => path.basename(t));
+    // The top of a disk (its own hidden folders only): into a folder named like the old one there.
+    const there = entries(to);
+    const target = there.length && there.every((n) => DISK.has(n)) ? path.join(to, path.basename(from) || "Strom") : to;
+    const plan = { from, to: target, content: names.length > 0, trees: inside.map((t) => path.basename(t)), busy };
+    if (!plan.content)
+        return plan;
+    if (within(target, from) || within(from, target))
+        plan.problem = "inside";
+    else if (entries(target).length)
+        plan.problem = "notEmpty";
+    else if (busy.length)
+        plan.problem = "busy";
+    return plan;
+}
+/** Move the folder; "copied" when it had to be copied to another disk (the old one stays). */
+export function moveHome(plan) {
+    fs.mkdirSync(path.dirname(plan.to), { recursive: true });
+    if (fs.existsSync(plan.to)) {
+        // empty but for what a system leaves (planMove said so)
+        for (const n of LITTER)
+            fs.rmSync(path.join(plan.to, n), { force: true });
+        fs.rmdirSync(plan.to);
+    }
+    try {
+        fs.renameSync(plan.from, plan.to);
+        return "moved";
+    }
+    catch (err) {
+        if (err.code !== "EXDEV")
+            throw err;
+    }
+    try {
+        fs.cpSync(plan.from, plan.to, { recursive: true, errorOnExist: true, force: false, preserveTimestamps: true, verbatimSymlinks: true });
+    }
+    catch (err) {
+        fs.rmSync(plan.to, { recursive: true, force: true }); // half a copy is no copy
+        throw err;
+    }
+    return "copied";
+}
+/**
+ * What pointed into the old folder points into the new one: the settings (the folders under it, the tree worked on) and
+ * the consents to connectors, which know a connector by its folder.
+ */
+export function repointSettings(settings, env, from, to) {
+    const cfg = settings.config;
+    const move = (p) => (p && within(p, from) ? path.join(to, path.relative(from, p)) : p);
+    cfg.home = to;
+    if (cfg.shared)
+        cfg.shared = move(cfg.shared);
+    if (cfg.trees)
+        cfg.trees = move(cfg.trees);
+    if (cfg.currentTree)
+        cfg.currentTree = move(cfg.currentTree);
+    if (cfg.extraTrees)
+        cfg.extraTrees = cfg.extraTrees.map((p) => move(p));
+    settings.save();
+    const consents = loadConsents(env);
+    let changed = false;
+    for (const c of Object.values(consents.connectors))
+        if (c.dir && within(c.dir, from)) {
+            c.dir = move(c.dir);
+            changed = true;
+        }
+    if (changed)
+        saveConsents(env, consents);
+}

package/dist/core/tree.js

@@ -23,7 +23,7 @@ import * as git from "./git.js";
 import { commitSeal, createKey, fingerprint, loadKey, sha256, signOp } from "./seal.js";
 import { stringifyCanonical } from "./json.js";
 export const TREE_FILE = "strom.json";
-export const VERSION = "1.1.1";
+export const VERSION = "1.3.0";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/
@@ -84,6 +84,10 @@ export class Tree {
     undo = new Map();
     /** Ops written during this process (for the automatic commit message). */
     written = [];
+    /** Of `written`, how many were told to onCommit already. */
+    told = 0;
+    /** Told of each commit with the operations it saved (the CLI tells the user's hooks: core/hooks.ts). */
+    static onCommit;
     env;
     /** Bumped on every write; lets derived indexes know they are stale. */
     version = 0;
@@ -233,6 +237,7 @@ export class Tree {
         this.touchedOps.clear();
         this.counters = undefined;
         this.written.length = 0;
+        this.told = 0;
         this.version++;
         return restored;
     }
@@ -414,7 +419,19 @@ export class Tree {
     commit(message, pathspec = ["."]) {
         const key = this.requireKey();
         git.resetCache(this.root); // another process may have committed since this one last looked
-        return git.commitAll(this.root, message, pathspec, (treeHash) => commitSeal(key, treeHash));
+        const hash = git.commitAll(this.root, message, pathspec, (treeHash) => commitSeal(key, treeHash));
+        if (hash) {
+            const ops = this.written.slice(this.told);
+            this.told = this.written.length;
+            try {
+                if (ops.length)
+                    Tree.onCommit?.(this, ops, hash);
+            }
+            catch {
+                // whoever listens never undoes a commit
+            }
+        }
+        return hash;
     }
     /** Append a signed operation to the current log (inside withTreeLock). */
     appendOp(op) {

package/dist/runners/antigravity.js

@@ -26,7 +26,8 @@ export const antigravityRunner = {
     id: "antigravity",
     command: "agy",
     run(opts) {
-        return runJsonLines("agy", antigravityArgs(opts), opts.env, opts, (msg, heard) => {
+        // Its events name no conversation strom could resume: stopped at the time limit, it is just stopped.
+        return runJsonLines("agy", antigravityArgs(opts), opts.env, opts, undefined, (msg, heard) => {
             const kind = String(msg.event ?? msg.type ?? "");
             if (kind === "result") {
                 const r = (msg.result ?? {});

package/dist/runners/claude.js

@@ -12,6 +12,7 @@
 // count), headless or not. Browser tools
 // are on only when a connector fetches through the browser (--chrome), and off
 // otherwise (--no-chrome), whatever Claude Code's own default is.
+import { randomUUID } from "node:crypto";
 import { appendLog, looksLikeLimit, spawnAgent, stopTree } from "./runner.js";
 function describeTool(block) {
     const input = block.input ?? {};
@@ -40,6 +41,9 @@ export function claudeArgs(opts) {
         args.push("--model", opts.model);
     if (opts.chrome !== undefined)
         args.push(opts.chrome ? "--chrome" : "--no-chrome");
+    // named always: its value is optional, and a bare flag would take the next argument
+    if (opts.remote)
+        args.push("--remote-control", opts.name ?? "Strom");
     args.push(...(opts.extraArgs ?? []));
     return args;
 }
@@ -60,122 +64,164 @@ export function headlessEnv(env, timeoutMs) {
         BASH_MAX_TIMEOUT_MS: long,
     };
 }
-export const claudeRunner = {
-    id: "claude",
-    command: "claude",
-    run(opts) {
-        return new Promise((resolve) => {
-            const child = spawnAgent("claude", claudeArgs(opts), {
-                cwd: opts.cwd,
-                env: opts.interactive ? opts.env : headlessEnv(opts.env, opts.timeoutMs),
-                stdio: opts.interactive ? "inherit" : ["pipe", "pipe", "pipe"],
-                windowsHide: !opts.interactive,
-            });
-            // The brief goes in on stdin: no limit on its length on any platform.
-            if (!opts.interactive)
-                child.stdin?.end(opts.prompt);
-            let timedOut = false;
-            const timer = opts.timeoutMs
-                ? setTimeout(() => {
-                    timedOut = true;
-                    opts.onProgress?.(`time limit reached (${Math.round(opts.timeoutMs / 60000)} min) — stopping the agent`);
-                    stopTree(child);
-                }, opts.timeoutMs)
-                : undefined;
-            opts.signal?.addEventListener("abort", () => stopTree(child), { once: true });
-            const metrics = {};
-            let text = "";
-            let buffer = "";
-            let isError = false;
-            const denied = [];
-            const handle = (line) => {
-                if (!line.trim())
-                    return;
-                let msg;
-                try {
-                    msg = JSON.parse(line);
-                }
-                catch {
-                    return;
-                }
-                if (msg.type === "system" && msg.subtype === "init" && typeof msg.model === "string")
-                    metrics.model = msg.model;
-                if (msg.type === "assistant") {
-                    const content = (msg.message?.content ?? []);
-                    for (const b of content) {
-                        if (b.type === "tool_use")
-                            opts.onProgress?.(describeTool(b));
-                        else if (b.type === "text" && b.text?.trim())
-                            opts.onProgress?.(b.text.trim().split("\n")[0].slice(0, 160));
-                    }
-                }
-                if (msg.type === "result") {
-                    text = String(msg.result ?? "");
-                    isError = Boolean(msg.is_error);
-                    const u = (msg.usage ?? {});
-                    if (u.input_tokens !== undefined)
-                        metrics.inputTokens = u.input_tokens;
-                    if (u.output_tokens !== undefined)
-                        metrics.outputTokens = u.output_tokens;
-                    if (u.cache_read_input_tokens !== undefined)
-                        metrics.cacheReadTokens = u.cache_read_input_tokens;
-                    if (u.cache_creation_input_tokens !== undefined)
-                        metrics.cacheWriteTokens = u.cache_creation_input_tokens;
-                    if (typeof msg.total_cost_usd === "number")
-                        metrics.costUsd = msg.total_cost_usd;
-                    if (typeof msg.num_turns === "number")
-                        metrics.turns = msg.num_turns;
-                    if (typeof msg.duration_ms === "number")
-                        metrics.durationMs = msg.duration_ms;
-                    for (const d of (msg.permission_denials ?? [])) {
-                        const input = d.tool_input ?? {};
-                        const what = typeof input.command === "string" ? input.command : typeof input.file_path === "string" ? input.file_path : typeof input.url === "string" ? input.url : "";
-                        denied.push(`${d.tool_name ?? "tool"}${what ? `: ${String(what).split("\n")[0].slice(0, 120)}` : ""}`);
-                    }
-                    if (denied.length)
-                        metrics.denied = denied.length;
+function attempt(opts, args, input, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = spawnAgent("claude", args, {
+            cwd: opts.cwd,
+            env: opts.interactive ? opts.env : headlessEnv(opts.env, opts.timeoutMs),
+            stdio: opts.interactive ? "inherit" : ["pipe", "pipe", "pipe"],
+            windowsHide: !opts.interactive,
+        });
+        // The brief goes in on stdin: no limit on its length on any platform.
+        if (!opts.interactive)
+            child.stdin?.end(input);
+        let timedOut = false;
+        const timer = timeoutMs
+            ? setTimeout(() => {
+                timedOut = true;
+                stopTree(child);
+            }, timeoutMs)
+            : undefined;
+        const abort = () => stopTree(child);
+        opts.signal?.addEventListener("abort", abort, { once: true });
+        const a = { code: null, timedOut: false, metrics: {}, reported: false, text: "", stderr: "", isError: false, denied: [] };
+        let buffer = "";
+        const handle = (line) => {
+            if (!line.trim())
+                return;
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            if (msg.type === "system" && msg.subtype === "init" && typeof msg.model === "string")
+                a.metrics.model = msg.model;
+            if (msg.type === "assistant") {
+                const content = (msg.message?.content ?? []);
+                for (const b of content) {
+                    if (b.type === "tool_use")
+                        opts.onProgress?.(describeTool(b));
+                    else if (b.type === "text" && b.text?.trim())
+                        opts.onProgress?.(b.text.trim().split("\n")[0].slice(0, 160));
                 }
-            };
-            child.stdout?.on("data", (d) => {
-                const s = d.toString("utf8");
-                appendLog(opts.logFile, s);
-                buffer += s;
-                let nl;
-                while ((nl = buffer.indexOf("\n")) >= 0) {
-                    handle(buffer.slice(0, nl));
-                    buffer = buffer.slice(nl + 1);
+            }
+            if (msg.type === "result") {
+                a.reported = true;
+                a.text = String(msg.result ?? "");
+                a.isError = Boolean(msg.is_error);
+                const m = a.metrics;
+                const u = (msg.usage ?? {});
+                if (u.input_tokens !== undefined)
+                    m.inputTokens = u.input_tokens;
+                if (u.output_tokens !== undefined)
+                    m.outputTokens = u.output_tokens;
+                if (u.cache_read_input_tokens !== undefined)
+                    m.cacheReadTokens = u.cache_read_input_tokens;
+                if (u.cache_creation_input_tokens !== undefined)
+                    m.cacheWriteTokens = u.cache_creation_input_tokens;
+                if (typeof msg.total_cost_usd === "number")
+                    m.costUsd = msg.total_cost_usd;
+                if (typeof msg.num_turns === "number")
+                    m.turns = msg.num_turns;
+                if (typeof msg.duration_ms === "number")
+                    m.durationMs = msg.duration_ms;
+                for (const d of (msg.permission_denials ?? [])) {
+                    const input = d.tool_input ?? {};
+                    const what = typeof input.command === "string" ? input.command : typeof input.file_path === "string" ? input.file_path : typeof input.url === "string" ? input.url : "";
+                    a.denied.push(`${d.tool_name ?? "tool"}${what ? `: ${String(what).split("\n")[0].slice(0, 120)}` : ""}`);
                 }
-            });
-            let stderr = "";
-            child.stderr?.on("data", (d) => {
-                stderr += d.toString("utf8");
-                appendLog(opts.logFile, d.toString("utf8"));
-            });
-            child.on("error", (err) => {
-                if (timer)
-                    clearTimeout(timer);
-                resolve({ exitCode: 127, outcome: "error", text: String(err.message), metrics });
-            });
-            child.on("close", (code) => {
-                if (timer)
-                    clearTimeout(timer);
-                if (buffer)
-                    handle(buffer);
-                const all = `${text}\n${stderr}`;
-                const limit = looksLikeLimit(all);
-                const outcome = opts.signal?.aborted
-                    ? "stopped"
-                    : timedOut
-                        ? "timeout"
-                        : limit.limit
-                            ? "limit"
-                            : /log ?in|authenticat|api key|unauthori[sz]ed/i.test(all) && (code ?? 0) !== 0
-                                ? "auth"
-                                : (code ?? 0) !== 0 || isError
-                                    ? "error"
-                                    : "ok";
-                resolve({ exitCode: code ?? 1, outcome, text: text || stderr.trim(), metrics, ...(limit.resumeAt ? { resumeAt: limit.resumeAt } : {}), ...(denied.length ? { denied } : {}) });
-            });
+            }
+        };
+        child.stdout?.on("data", (d) => {
+            const s = d.toString("utf8");
+            appendLog(opts.logFile, s);
+            buffer += s;
+            let nl;
+            while ((nl = buffer.indexOf("\n")) >= 0) {
+                handle(buffer.slice(0, nl));
+                buffer = buffer.slice(nl + 1);
+            }
+        });
+        child.stderr?.on("data", (d) => {
+            a.stderr += d.toString("utf8");
+            appendLog(opts.logFile, d.toString("utf8"));
+        });
+        const end = () => {
+            if (timer)
+                clearTimeout(timer);
+            opts.signal?.removeEventListener("abort", abort);
+        };
+        child.on("error", (err) => {
+            end();
+            resolve({ ...a, failed: String(err.message) });
         });
+        child.on("close", (code) => {
+            end();
+            if (buffer)
+                handle(buffer);
+            resolve({ ...a, code, timedOut });
+        });
+    });
+}
+/** Two starts as one session: the time's metrics added up. */
+function together(first, then) {
+    const sum = (k) => first[k] === undefined && then[k] === undefined ? {} : { [k]: (first[k] ?? 0) + (then[k] ?? 0) };
+    return {
+        ...((first.model ?? then.model) ? { model: (first.model ?? then.model) } : {}),
+        ...sum("inputTokens"),
+        ...sum("outputTokens"),
+        ...sum("cacheReadTokens"),
+        ...sum("cacheWriteTokens"),
+        ...sum("costUsd"),
+        ...sum("turns"),
+        ...sum("durationMs"),
+    };
+}
+export const claudeRunner = {
+    id: "claude",
+    command: "claude",
+    async run(opts) {
+        // A headless session has an id of strom's choosing: stopped at its limit, it is resumed to write down what it found.
+        const id = opts.interactive ? undefined : randomUUID();
+        const args = claudeArgs(opts);
+        let a = await attempt(opts, id ? [...args, "--session-id", id] : args, opts.prompt, opts.timeoutMs);
+        if (a.failed)
+            return { exitCode: 127, outcome: "error", text: a.failed, metrics: a.metrics };
+        const timedOut = a.timedOut;
+        let metrics = { ...a.metrics, ...(a.reported ? {} : { costPartial: true }) };
+        const denied = [...a.denied];
+        if (timedOut) {
+            const min = Math.round(opts.timeoutMs / 60000);
+            if (opts.wrapUp && id && !opts.signal?.aborted) {
+                opts.onProgress?.(`time limit reached (${min} min) — the agent gets ${Math.round(opts.wrapUp.ms / 60000)} min to write down what it found`);
+                const more = await attempt(opts, [...args, "--resume", id], opts.wrapUp.prompt, opts.wrapUp.ms);
+                if (more.timedOut)
+                    opts.onProgress?.("the agent did not finish in time — stopped");
+                metrics = { ...together(metrics, more.metrics), costPartial: true };
+                denied.push(...more.denied);
+                a = { ...more, code: more.code, stderr: a.stderr + more.stderr, text: more.text || a.text };
+            }
+            else
+                opts.onProgress?.(`time limit reached (${min} min) — the agent was stopped`);
+        }
+        if (denied.length)
+            metrics.denied = denied.length;
+        const all = `${a.text}\n${a.stderr}`;
+        const limit = looksLikeLimit(all);
+        const code = a.code;
+        const outcome = opts.signal?.aborted
+            ? "stopped"
+            : timedOut
+                ? "timeout"
+                : limit.limit
+                    ? "limit"
+                    : /log ?in|authenticat|api key|unauthori[sz]ed/i.test(all) && (code ?? 0) !== 0
+                        ? "auth"
+                        : (code ?? 0) !== 0 || a.isError
+                            ? "error"
+                            : "ok";
+        return { exitCode: code ?? 1, outcome, text: a.text || a.stderr.trim(), metrics, ...(limit.resumeAt ? { resumeAt: limit.resumeAt } : {}), ...(denied.length ? { denied } : {}) };
     },
 };

package/dist/runners/codex.js

@@ -12,11 +12,24 @@ export function codexArgs(opts) {
         : ["--sandbox", "workspace-write", "-c", "sandbox_workspace_write.network_access=true", ...(opts.shared ? ["--add-dir", opts.shared] : [])];
     return ["exec", "--json", "--skip-git-repo-check", ...sandbox, ...(opts.model ? ["--model", opts.model] : []), ...(opts.extraArgs ?? []), "-"];
 }
+/**
+ * Arguments that resume a headless session with a message on stdin (exported for tests). `exec resume` has no
+ * --sandbox or --add-dir: the same sandbox is set through its configuration.
+ */
+export function codexResumeArgs(id, opts) {
+    const sandbox = opts.permissions === "full"
+        ? ["--dangerously-bypass-approvals-and-sandbox"]
+        : ["-c", 'sandbox_mode="workspace-write"', "-c", "sandbox_workspace_write.network_access=true", ...(opts.shared ? ["-c", `sandbox_workspace_write.writable_roots=[${JSON.stringify(opts.shared)}]`] : [])];
+    return ["exec", "resume", "--json", "--skip-git-repo-check", ...sandbox, ...(opts.model ? ["--model", opts.model] : []), id, "-"];
+}
 export const codexRunner = {
     id: "codex",
     command: "codex",
     run(opts) {
-        return runJsonLines("codex", codexArgs(opts), opts.env, opts, (msg, heard) => {
+        const resume = (id, message) => ({ args: codexResumeArgs(id, opts), input: message });
+        return runJsonLines("codex", codexArgs(opts), opts.env, opts, resume, (msg, heard) => {
+            if (msg.type === "thread.started" && typeof msg.thread_id === "string")
+                heard.sessionId = msg.thread_id;
             const item = msg.item;
             if (msg.type === "item.started" && item?.type === "command_execution" && item.command)
                 opts.onProgress?.(`$ ${item.command.replace(/^\S*sh -lc '(.*)'$/s, "$1").split("\n")[0].slice(0, 140)}`);

package/dist/runners/jsonl.js

@@ -2,23 +2,69 @@
 // `--output-format stream-json`): the brief on stdin, one event per line on
 // stdout, a time limit, Ctrl-C, the subscription limit and a missing login
 // recognised — the same for every such agent; each runner only reads its own
-// events.
+// events. Stopped at its time limit, an agent that can resume its session gets a
+// few minutes to write down what it found (RunOptions.wrapUp).
 import { appendLog, looksLikeLimit, spawnAgent, stopTree } from "./runner.js";
-export function runJsonLines(command, args, env, opts, onEvent) {
+export async function runJsonLines(command, args, env, opts, resume, onEvent) {
+    const started = Date.now();
+    const heard = { metrics: {}, text: "", isError: false, denied: [] };
+    let a = await attempt(command, args, opts.prompt, env, opts, opts.timeoutMs, heard, onEvent);
+    if (a.failed)
+        return { exitCode: 127, outcome: "error", text: a.failed, metrics: heard.metrics };
+    const timedOut = a.timedOut;
+    if (timedOut) {
+        const min = Math.round(opts.timeoutMs / 60000);
+        if (opts.wrapUp && resume && heard.sessionId && !opts.signal?.aborted) {
+            opts.onProgress?.(`time limit reached (${min} min) — the agent gets ${Math.round(opts.wrapUp.ms / 60000)} min to write down what it found`);
+            const r = resume(heard.sessionId, opts.wrapUp.prompt);
+            const more = await attempt(command, r.args, r.input, env, opts, opts.wrapUp.ms, heard, onEvent);
+            if (more.timedOut)
+                opts.onProgress?.("the agent did not finish in time — stopped");
+            a = { ...more, stderr: a.stderr + more.stderr };
+        }
+        else
+            opts.onProgress?.(`time limit reached (${min} min) — the agent was stopped`);
+    }
+    const code = a.code;
+    heard.metrics.durationMs ??= Date.now() - started;
+    if (heard.denied.length)
+        heard.metrics.denied = heard.denied.length;
+    const all = `${heard.text}\n${a.stderr}`;
+    const limit = looksLikeLimit(all);
+    const outcome = opts.signal?.aborted
+        ? "stopped"
+        : timedOut
+            ? "timeout"
+            : limit.limit
+                ? "limit"
+                : /log ?in|authenticat|api[ _]?key|unauthori[sz]ed|GEMINI_API_KEY/i.test(all) && ((code ?? 0) !== 0 || heard.isError)
+                    ? "auth"
+                    : (code ?? 0) !== 0 || heard.isError
+                        ? "error"
+                        : "ok";
+    return {
+        exitCode: code ?? 1,
+        outcome,
+        text: heard.text || a.stderr.trim(),
+        metrics: heard.metrics,
+        ...(limit.resumeAt ? { resumeAt: limit.resumeAt } : {}),
+        ...(heard.denied.length ? { denied: heard.denied } : {}),
+    };
+}
+/** One start of the agent; its events go to `heard`. */
+function attempt(command, args, input, env, opts, timeoutMs, heard, onEvent) {
     return new Promise((resolve) => {
-        const started = Date.now();
         const child = spawnAgent(command, args, { cwd: opts.cwd, env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
-        child.stdin?.end(opts.prompt);
+        child.stdin?.end(input);
         let timedOut = false;
-        const timer = opts.timeoutMs
+        const timer = timeoutMs
             ? setTimeout(() => {
                 timedOut = true;
-                opts.onProgress?.(`time limit reached (${Math.round(opts.timeoutMs / 60000)} min) — stopping the agent`);
                 stopTree(child);
-            }, opts.timeoutMs)
+            }, timeoutMs)
             : undefined;
-        opts.signal?.addEventListener("abort", () => stopTree(child), { once: true });
-        const heard = { metrics: {}, text: "", isError: false, denied: [] };
+        const abort = () => stopTree(child);
+        opts.signal?.addEventListener("abort", abort, { once: true });
         let buffer = "";
         const handle = (line) => {
             if (!line.trim())
@@ -47,40 +93,20 @@ export function runJsonLines(command, args, env, opts, onEvent) {
             stderr += d.toString("utf8");
             appendLog(opts.logFile, d.toString("utf8"));
         });
-        child.on("error", (err) => {
+        const end = () => {
             if (timer)
                 clearTimeout(timer);
-            resolve({ exitCode: 127, outcome: "error", text: String(err.message), metrics: heard.metrics });
+            opts.signal?.removeEventListener("abort", abort);
+        };
+        child.on("error", (err) => {
+            end();
+            resolve({ code: 127, timedOut, stderr, failed: String(err.message) });
         });
         child.on("close", (code) => {
-            if (timer)
-                clearTimeout(timer);
+            end();
             if (buffer)
                 handle(buffer);
-            heard.metrics.durationMs ??= Date.now() - started;
-            if (heard.denied.length)
-                heard.metrics.denied = heard.denied.length;
-            const all = `${heard.text}\n${stderr}`;
-            const limit = looksLikeLimit(all);
-            const outcome = opts.signal?.aborted
-                ? "stopped"
-                : timedOut
-                    ? "timeout"
-                    : limit.limit
-                        ? "limit"
-                        : /log ?in|authenticat|api[ _]?key|unauthori[sz]ed|GEMINI_API_KEY/i.test(all) && ((code ?? 0) !== 0 || heard.isError)
-                            ? "auth"
-                            : (code ?? 0) !== 0 || heard.isError
-                                ? "error"
-                                : "ok";
-            resolve({
-                exitCode: code ?? 1,
-                outcome,
-                text: heard.text || stderr.trim(),
-                metrics: heard.metrics,
-                ...(limit.resumeAt ? { resumeAt: limit.resumeAt } : {}),
-                ...(heard.denied.length ? { denied: heard.denied } : {}),
-            });
+            resolve({ code, timedOut, stderr });
         });
     });
 }

package/dist/runners/opencode.js

@@ -4,7 +4,8 @@
 // evidence and git denied); what they would ask about is refused in a run
 // nobody watches — under ask and auto that is all; full adds --auto
 // (everything the rules do not deny). Events are JSON lines: text, tool_use,
-// step_start, step_finish (tokens and cost of a step), error.
+// step_start, step_finish (tokens and cost of a step), error; each names its
+// session (sessionID), which `--session` resumes.
 import { runJsonLines } from "./jsonl.js";
 /** Command-line arguments of a headless run (exported for tests). */
 export function opencodeArgs(opts) {
@@ -16,8 +17,12 @@ export const opencodeRunner = {
     run(opts) {
         const args = opencodeArgs({ ...opts, kickoff: "Your brief is above. Work only through `strom` in this folder, as it says." });
         const tokens = { input: 0, output: 0, cacheRead: 0 };
-        return runJsonLines("opencode", args, opts.env, opts, (msg, heard) => {
+        // Resumed: its session by id, the message as the prompt.
+        const resume = (id, message) => ({ args: [...opencodeArgs({ ...opts, kickoff: message }).slice(0, -1), "--session", id, message], input: "" });
+        return runJsonLines("opencode", args, opts.env, opts, resume, (msg, heard) => {
             const part = (msg.part ?? {});
+            if (typeof msg.sessionID === "string")
+                heard.sessionId = msg.sessionID;
             if (msg.type === "tool_use") {
                 const state = (part.state ?? {});
                 const input = state.input ?? {};