strom-research 1.1.1 → 1.2.0

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.2.0";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

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 ?? {};
@@ -60,122 +61,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 ?? {};

package/dist/runners/script.js

@@ -7,52 +7,61 @@ import { appendLog, looksLikeLimit, stopTree } from "./runner.js";
 export const scriptRunner = {
     id: "script",
     command: process.execPath,
-    run(opts) {
-        const script = opts.env.STROM_RUNNER_SCRIPT;
-        return new Promise((resolve) => {
-            if (!script)
-                return resolve({ exitCode: 2, outcome: "error", text: "STROM_RUNNER_SCRIPT is not set", metrics: {} });
-            const child = spawn(process.execPath, [script, ...(opts.extraArgs ?? [])], {
-                cwd: opts.cwd,
-                env: { ...opts.env, STROM_PROMPT: opts.prompt },
-                stdio: ["pipe", "pipe", "pipe"],
-            });
-            child.stdin.end(opts.prompt);
-            let timedOut = false;
-            const timer = opts.timeoutMs
-                ? setTimeout(() => {
-                    timedOut = true;
-                    stopTree(child);
-                }, opts.timeoutMs)
-                : undefined;
-            opts.signal?.addEventListener("abort", () => stopTree(child), { once: true });
-            let out = "";
-            const denied = [];
-            const on = (d) => {
-                for (const l of d.toString("utf8").split("\n"))
-                    if (l.startsWith("denied: "))
-                        denied.push(l.slice(8).trim());
-                out += d.toString("utf8");
-                appendLog(opts.logFile, d.toString("utf8"));
-                for (const l of d.toString("utf8").split("\n"))
-                    if (l.trim())
-                        opts.onProgress?.(l.trim().slice(0, 160));
-            };
-            child.stdout.on("data", on);
-            child.stderr.on("data", on);
-            child.on("close", (code) => {
-                if (timer)
-                    clearTimeout(timer);
-                const limit = looksLikeLimit(out);
-                resolve({
-                    exitCode: code ?? 1,
-                    outcome: opts.signal?.aborted ? "stopped" : timedOut ? "timeout" : limit.limit ? "limit" : code === 0 ? "ok" : "error",
-                    text: out.trim().split("\n").slice(-5).join("\n"),
-                    metrics: { turns: 1, ...(denied.length ? { denied: denied.length } : {}) },
-                    ...(limit.resumeAt ? { resumeAt: limit.resumeAt } : {}),
-                    ...(denied.length ? { denied } : {}),
-                });
-            });
-        });
+    async run(opts) {
+        const first = await once(opts, opts.prompt, opts.timeoutMs, false);
+        if (first.outcome !== "timeout" || !opts.wrapUp || opts.signal?.aborted)
+            return first;
+        // Stopped at its limit: resumed with the message to write down what it found (STROM_WRAP_UP=1).
+        opts.onProgress?.("time limit reached — the agent gets time to write down what it found");
+        const more = await once(opts, opts.wrapUp.prompt, opts.wrapUp.ms, true);
+        return { ...more, outcome: "timeout" };
     },
 };
+function once(opts, prompt, timeoutMs, wrapUp) {
+    const script = opts.env.STROM_RUNNER_SCRIPT;
+    return new Promise((resolve) => {
+        if (!script)
+            return resolve({ exitCode: 2, outcome: "error", text: "STROM_RUNNER_SCRIPT is not set", metrics: {} });
+        const child = spawn(process.execPath, [script, ...(opts.extraArgs ?? [])], {
+            cwd: opts.cwd,
+            env: { ...opts.env, STROM_PROMPT: prompt, ...(wrapUp ? { STROM_WRAP_UP: "1" } : {}) },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        child.stdin.end(prompt);
+        let timedOut = false;
+        const timer = timeoutMs
+            ? setTimeout(() => {
+                timedOut = true;
+                stopTree(child);
+            }, timeoutMs)
+            : undefined;
+        opts.signal?.addEventListener("abort", () => stopTree(child), { once: true });
+        let out = "";
+        const denied = [];
+        const on = (d) => {
+            for (const l of d.toString("utf8").split("\n"))
+                if (l.startsWith("denied: "))
+                    denied.push(l.slice(8).trim());
+            out += d.toString("utf8");
+            appendLog(opts.logFile, d.toString("utf8"));
+            for (const l of d.toString("utf8").split("\n"))
+                if (l.trim())
+                    opts.onProgress?.(l.trim().slice(0, 160));
+        };
+        child.stdout.on("data", on);
+        child.stderr.on("data", on);
+        child.on("close", (code) => {
+            if (timer)
+                clearTimeout(timer);
+            const limit = looksLikeLimit(out);
+            resolve({
+                exitCode: code ?? 1,
+                outcome: opts.signal?.aborted ? "stopped" : timedOut ? "timeout" : limit.limit ? "limit" : code === 0 ? "ok" : "error",
+                text: out.trim().split("\n").slice(-5).join("\n"),
+                metrics: { turns: 1, ...(denied.length ? { denied: denied.length } : {}) },
+                ...(limit.resumeAt ? { resumeAt: limit.resumeAt } : {}),
+                ...(denied.length ? { denied } : {}),
+            });
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {