strom-research 1.2.0 → 1.4.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.2.0";
+export const VERSION = "1.4.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/core/which.js

@@ -26,9 +26,13 @@ export const AGENTS = [
     { id: "codex", command: "codex", name: "OpenAI Codex CLI" },
     { id: "antigravity", command: "agy", name: "Antigravity CLI" },
     { id: "opencode", command: "opencode", name: "OpenCode" },
+    { id: "grok", command: "grok", name: "Grok Build" },
 ];
 /** Which AI agent's shell tool runs strom? (they set these variables) */
 export function detectAgent(env) {
+    // Grok first: it passes on the environment it was started from (a Claude Code terminal's too).
+    if (env.GROK_AGENT === "1")
+        return "grok";
     if (env.CLAUDECODE)
         return "claude";
     if (Object.keys(env).some((k) => k.startsWith("ANTIGRAVITY_")))
@@ -37,10 +41,24 @@ export function detectAgent(env) {
         return "codex";
     if (env.OPENCODE === "1" || env.OPENCODE_PID)
         return "opencode";
+    // Cursor's agents — also xAI's Grok Bot, on Cursor's platform (found live): not one strom starts, but an agent
+    if (env.CURSOR_AGENT)
+        return "cursor";
     if (env.AI_AGENT)
         return env.AI_AGENT.toLowerCase();
     return undefined;
 }
+/** What says an agent runs strom (detectAgent) — not the user's own settings of an agent (…_HOME). */
+export function isAgentMark(k) {
+    return ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT", "AI_AGENT", "OPENCODE", "OPENCODE_PID", "GROK_AGENT", "GROK_SESSION_ID", "CURSOR_AGENT"].includes(k) || (/^(CODEX|ANTIGRAVITY)_/.test(k) && !/_HOME$/.test(k));
+}
+/**
+ * The environment for an agent strom starts: without the marks of the agent strom itself was run
+ * from (a terminal of Grok's passes them on), so strom in the new agent's shell knows which one it is.
+ */
+export function withoutAgentMarks(env) {
+    return Object.fromEntries(Object.entries(env).filter(([k]) => !isAgentMark(k)));
+}
 /** Is an agent running strom — its shell tool, or an agent strom run started? */
 export function isAgent(env) {
     return Boolean(detectAgent(env) || env.STROM_SESSION);

package/dist/runners/claude.js

@@ -41,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;
 }

package/dist/runners/codex.js

@@ -1,15 +1,24 @@
 // OpenAI Codex CLI runner. Headless: `codex exec --json` in the tree folder
 // with the brief on stdin. The user's level decides the sandbox: ask and auto
-// work in Codex's sandbox on the tree folder (the shared folder added, the
-// network on — strom fetches), where what the sandbox refuses simply fails —
+// work in Codex's sandbox on the tree folder (its .git and the shared folder
+// writable too, the network on — strom fetches), where what the sandbox refuses simply fails —
 // nothing asks, as with Claude Code's dontAsk; full runs without the sandbox.
 // Interactive conversations are started by strom chat (agents/launch.ts).
+import path from "node:path";
 import { runJsonLines } from "./jsonl.js";
+/**
+ * What Codex's sandbox lets it write besides the tree folder: the tree's .git — its sandbox keeps a .git
+ * read-only even inside the folder it works in, and every change strom makes is a commit (found live:
+ * `strom session note` failed on .git/index.lock) — and the shared folder (inbox, plugins).
+ */
+export function codexWritable(root, shared) {
+    return ["-c", `sandbox_workspace_write.writable_roots=${JSON.stringify([path.join(root, ".git"), ...(shared ? [shared] : [])])}`];
+}
 /** Command-line arguments of a headless run (exported for tests). */
 export function codexArgs(opts) {
     const sandbox = opts.permissions === "full"
         ? ["--dangerously-bypass-approvals-and-sandbox"]
-        : ["--sandbox", "workspace-write", "-c", "sandbox_workspace_write.network_access=true", ...(opts.shared ? ["--add-dir", opts.shared] : [])];
+        : ["--sandbox", "workspace-write", "-c", "sandbox_workspace_write.network_access=true", ...codexWritable(opts.cwd, opts.shared)];
     return ["exec", "--json", "--skip-git-repo-check", ...sandbox, ...(opts.model ? ["--model", opts.model] : []), ...(opts.extraArgs ?? []), "-"];
 }
 /**
@@ -19,7 +28,7 @@ export function codexArgs(opts) {
 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)}]`] : [])];
+        : ["-c", 'sandbox_mode="workspace-write"', "-c", "sandbox_workspace_write.network_access=true", ...codexWritable(opts.cwd, opts.shared)];
     return ["exec", "resume", "--json", "--skip-git-repo-check", ...sandbox, ...(opts.model ? ["--model", opts.model] : []), id, "-"];
 }
 export const codexRunner = {
@@ -39,7 +48,7 @@ export const codexRunner = {
             }
             // The sandbox refused a command (a write outside the tree, the network off): counted like a denial.
             if (msg.type === "item.completed" && item?.type === "command_execution" && item.exit_code !== 0 && /operation not permitted|sandbox|read-only file system/i.test(item.aggregated_output ?? ""))
-                heard.denied.push(`Bash: ${String(item.command ?? "").slice(0, 120)}`);
+                heard.denied.push(`Bash: ${String(item.command ?? "").replace(/^\S*sh -lc '(.*)'$/s, "$1").slice(0, 120)}`);
             if (msg.type === "turn.completed") {
                 const u = (msg.usage ?? {});
                 const m = heard.metrics;

package/dist/runners/grok.js

@@ -0,0 +1,108 @@
+// Grok Build runner (xAI's `grok`). Headless: `grok --trust --prompt-file <brief>
+// --output-format streaming-json` in the tree folder — it reads no stdin, so the
+// brief goes in a file beside the run's log. --trust: the tree folder's own files
+// (AGENTS.md, .grok/config.toml with the tree's rules) load only in a trusted
+// folder. The level: ask and auto — --permission-mode dontAsk (what the rules do
+// not allow is refused; Grok still lets harmless commands of its own judgement
+// through, so the deny rules are what holds); full — --always-approve (only the
+// deny rules count). strom names the session (-s <uuid>) and resumes it by that
+// id at the time limit (-r). Events are JSON lines: text, tool_call,
+// tool_call_update, end (usage, cost) and error.
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { runJsonLines } from "./jsonl.js";
+/** Command-line arguments of a headless run (exported for tests). */
+export function grokArgs(opts, prompt, session) {
+    return [
+        "--trust",
+        ...prompt,
+        "--output-format",
+        "streaming-json",
+        ...(opts.permissions === "full" ? ["--always-approve"] : ["--permission-mode", "dontAsk"]),
+        ...session,
+        ...(opts.model ? ["--model", opts.model] : []),
+        "--no-auto-update",
+        ...(opts.extraArgs ?? []),
+    ];
+}
+/**
+ * The environment of a headless run: a command may take as long as the session and is never sent to the
+ * background when its time is up (a headless run ends with its turn, and what it left in the background with it).
+ */
+export function grokEnv(env, timeoutMs) {
+    const secs = Math.max(Math.round((timeoutMs ?? 0) / 1000), 30 * 60);
+    return { ...env, GROK_CONFIG: JSON.stringify({ toolset: { bash: { timeout_secs: secs, max_timeout_secs: secs, auto_background_on_timeout: false } } }) };
+}
+/** What a tool call was, in one line: its command, else the tool and its file. */
+function describe(e) {
+    const input = (e.rawInput ?? {});
+    if (typeof input.command === "string")
+        return `$ ${input.command.split("\n")[0].slice(0, 140)}`;
+    const file = input.target_file ?? input.file_path ?? input.path ?? input.target_directory;
+    return typeof file === "string" ? `${String(e.toolName ?? e.title ?? "tool")} ${file}` : String(e.toolName ?? e.title ?? "tool");
+}
+export const grokRunner = {
+    id: "grok",
+    command: "grok",
+    run(opts) {
+        const promptFile = opts.logFile.replace(/\.log$/, "") + ".prompt.md";
+        fs.mkdirSync(path.dirname(promptFile), { recursive: true });
+        fs.writeFileSync(promptFile, opts.prompt);
+        const id = randomUUID();
+        const env = grokEnv(opts.env, opts.timeoutMs);
+        // Its text comes in pieces; the last message (after the last tool call) is its answer.
+        let said = "";
+        const calls = new Map();
+        const resume = (sid, message) => ({ args: grokArgs(opts, ["-p", message], ["--resume", sid]), input: "" });
+        return runJsonLines("grok", grokArgs(opts, ["--prompt-file", promptFile], ["--session-id", id]), env, opts, resume, (msg, heard) => {
+            heard.sessionId ??= id;
+            const type = msg.type;
+            if (type === "text" && typeof msg.data === "string") {
+                said += msg.data;
+                heard.text = said.trim();
+            }
+            else if (type === "tool_call") {
+                if (said.trim())
+                    opts.onProgress?.(said.trim().split("\n")[0].slice(0, 160));
+                said = "";
+                const what = describe(msg);
+                if (typeof msg.toolCallId === "string")
+                    calls.set(msg.toolCallId, `${msg.toolName === "run_terminal_command" ? "Bash" : String(msg.toolName ?? "tool")}: ${what.replace(/^\$ /, "").slice(0, 120)}`);
+                opts.onProgress?.(what);
+            }
+            else if (type === "tool_call_update" && msg.status === "failed") {
+                // Refused by the rules ("Denied by permission policy") or by dontAsk ("User cancelled the execution").
+                const content = JSON.stringify(msg.content ?? "");
+                if (/denied by permission|permission policy|user cancelled|not allowed/i.test(content))
+                    heard.denied.push(calls.get(String(msg.toolCallId)) ?? "tool");
+            }
+            else if (type === "end") {
+                if (typeof msg.sessionId === "string")
+                    heard.sessionId = msg.sessionId;
+                const u = (msg.usage ?? {});
+                const m = heard.metrics;
+                // (a resumed session adds its own)
+                m.inputTokens = (m.inputTokens ?? 0) + (u.input_tokens ?? 0);
+                m.outputTokens = (m.outputTokens ?? 0) + (u.output_tokens ?? 0) + (u.reasoning_tokens ?? 0);
+                m.cacheReadTokens = (m.cacheReadTokens ?? 0) + (u.cache_read_input_tokens ?? 0);
+                if (typeof msg.num_turns === "number")
+                    m.turns = (m.turns ?? 0) + msg.num_turns;
+                // A cost only when Grok knows it whole (a subscription often does not say it).
+                if (typeof msg.total_cost_usd === "number")
+                    m.costUsd = (m.costUsd ?? 0) + msg.total_cost_usd;
+                else if (msg.cost_is_partial === true || msg.usage_is_incomplete === true)
+                    m.costPartial = true;
+                const models = Object.keys((msg.modelUsage ?? {}));
+                if (models[0])
+                    m.model = models[0];
+                if (msg.stopReason === "refusal")
+                    heard.isError = true;
+            }
+            else if (type === "error") {
+                heard.isError = true;
+                heard.text = String(msg.message ?? "error");
+            }
+        });
+    },
+};

package/dist/runners/index.js

@@ -2,12 +2,14 @@ import { claudeRunner } from "./claude.js";
 import { codexRunner } from "./codex.js";
 import { antigravityRunner } from "./antigravity.js";
 import { opencodeRunner } from "./opencode.js";
+import { grokRunner } from "./grok.js";
 import { scriptRunner } from "./script.js";
 export const RUNNERS = {
     claude: claudeRunner,
     codex: codexRunner,
     antigravity: antigravityRunner,
     opencode: opencodeRunner,
+    grok: grokRunner,
     script: scriptRunner,
 };
 export const DEFAULT_RUNNER = "claude";

package/dist/runners/opencode.js

@@ -1,15 +1,18 @@
 // OpenCode runner. Headless: `opencode run --format json "<kickoff>"` in the tree
 // folder with the brief on stdin (it joins what is piped in with the message).
 // The tree's rules are its project config (opencode.json: strom allowed, the
-// 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
+// evidence and git denied); under ask and auto a run nobody watches is its
+// agent "strom-run" there — the same rules, what would ask refused (OpenCode 2
+// ends a headless run at the first question it cannot ask); 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; each names its
 // session (sessionID), which `--session` resumes.
 import { runJsonLines } from "./jsonl.js";
+import { OPENCODE_RUN_AGENT } from "../agents/files.js";
 /** Command-line arguments of a headless run (exported for tests). */
 export function opencodeArgs(opts) {
-    return ["run", "--format", "json", ...(opts.permissions === "full" ? ["--auto"] : []), ...(opts.model ? ["--model", opts.model] : []), ...(opts.extraArgs ?? []), opts.kickoff];
+    const level = opts.permissions === "full" ? ["--auto"] : ["--agent", OPENCODE_RUN_AGENT];
+    return ["run", "--format", "json", ...level, ...(opts.model ? ["--model", opts.model] : []), ...(opts.extraArgs ?? []), opts.kickoff];
 }
 export const opencodeRunner = {
     id: "opencode",
@@ -28,8 +31,9 @@ export const opencodeRunner = {
                 const input = state.input ?? {};
                 const what = typeof input.command === "string" ? `$ ${input.command}` : typeof input.filePath === "string" ? `${String(part.tool)} ${input.filePath}` : String(part.tool ?? "tool");
                 opts.onProgress?.(what.split("\n")[0].slice(0, 140));
+                // (its shell tool: "bash", "shell" from OpenCode 2 — named "Bash" like Claude Code's, so a refused strom stops the run)
                 if (state.status === "error" && /reject|denied|not allowed|permission/i.test(state.error ?? ""))
-                    heard.denied.push(`${String(part.tool)}: ${what.slice(0, 120)}`);
+                    heard.denied.push(typeof input.command === "string" ? `Bash: ${input.command.slice(0, 120)}` : `${String(part.tool)}: ${what.slice(0, 120)}`);
             }
             if (msg.type === "text" && typeof part.text === "string" && part.text.trim())
                 heard.text = part.text;

package/package.json

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