strom-research 1.2.0 → 1.4.0

package/dist/agents/files.js

@@ -1,9 +1,10 @@
 // Instruction and permission files for the agents that work in a tree.
-// AGENTS.md is the single source every agent reads (Codex, Antigravity and
-// OpenCode natively; CLAUDE.md imports it) and holds nothing agent-specific;
-// each agent's own file adds what only that agent needs. .claude/settings.json
-// (and OpenCode's opencode.json) allow `strom` and deny direct access to the
-// evidence — the first line of defence; the seal is the one that always holds.
+// AGENTS.md is the single source every agent reads (Codex, Antigravity,
+// OpenCode and Grok natively; CLAUDE.md imports it) and holds nothing
+// agent-specific; each agent's own file adds what only that agent needs.
+// .claude/settings.json (and OpenCode's opencode.json, Grok's .grok/config.toml)
+// allow `strom` and deny direct access to the evidence — the first line of
+// defence; the seal is the one that always holds.
 import fs from "node:fs";
 import path from "node:path";
 import { langName } from "../core/lang.js";
@@ -42,7 +43,7 @@ the researcher; \`strom\` is your only way to read and change the research.
    already short, listings take \`--limit\` and \`--page\`, and piped commands may
    be refused by your permissions.
 8. Other agents may work on this tree too (Claude Code, Codex, Antigravity,
-   OpenCode — the user's choice). \`strom\` shows who is working now; never take a task
+   OpenCode, Grok — the user's choice). \`strom\` shows who is working now; never take a task
    another one has started.
 
 ## Working with the user
@@ -130,76 +131,100 @@ export function permissionPath(abs) {
     return win ? `//${win[1].toLowerCase()}/${win[2]}` : `/${p}`;
 }
 /**
- * Permissions for Claude Code in this tree (paths of this computer). File rules are
- * Edit(…) only: Claude Code checks every file-editing tool against them (Write(…)
- * rules match nothing and are reported as a mistake).
+ * The tree's rules for Claude Code or Grok Build. Grok reads Claude Code's rules too, but an absolute
+ * path in Claude Code's words ("//Users/x") is plain text to it: its own file gets the path as it is.
+ * File rules are Edit(…) only: Claude Code checks every file-editing tool against them (Write(…) rules
+ * match nothing and are reported as a mistake); Grok's Edit covers Write as well.
  */
-export function claudeSettings(tree) {
+function treeRules(tree, agent) {
     const settings = new Settings(tree.env, {});
     const shared = settings.shared()?.value;
-    const keys = permissionPath(configDir(tree.env));
-    // Connectors of this tree whose images come through the user's browser: browser tools, for their sites only.
-    const browser = treeBrowserConnectors(tree, shared);
-    const sites = [...new Set(browser.flatMap((c) => c.manifest.hosts.map(chromeDomain)))];
-    const downloads = permissionPath(settings.downloads());
-    const lead = settings.models("claude", tree.config).lead;
-    // A rule for each of Claude Code's shells: Bash, and PowerShell (on Windows) — a Bash rule does not cover it.
-    const shell = (cmd) => [`Bash(${cmd})`, `PowerShell(${cmd})`];
+    const claude = agent === "claude";
+    const at = (abs) => (claude ? permissionPath(abs) : abs.replace(/\\/g, "/"));
+    const keys = at(configDir(tree.env));
+    // Connectors of this tree whose images come through the user's browser: browser tools (Claude in Chrome), for their sites only.
+    const sites = claude ? [...new Set(treeBrowserConnectors(tree, shared).flatMap((c) => c.manifest.hosts.map(chromeDomain)))] : [];
+    const downloads = at(settings.downloads());
+    // A rule for each of Claude Code's shells: Bash, and PowerShell (on Windows) — a Bash rule does not cover it. Grok has one.
+    const shell = (cmd) => (claude ? [`Bash(${cmd})`, `PowerShell(${cmd})`] : [`Bash(${cmd})`]);
     return {
-        permissions: {
-            allow: [
-                ...shell("strom:*"),
-                "Read(inputs/**)",
-                "Read(output/**)",
-                "Read(notes/**)",
-                "Read(.strom/views/**)",
-                // Files the user drops for the research; scans are seen through views only (strom media view).
-                ...(shared ? [`Read(${permissionPath(path.join(shared, "inbox"))}/**)`] : []),
-                "Edit(notes/**)",
-                // A connector it builds for an archive the research needs (strom connector new); strom runs it.
-                ...(shared ? ["Read", "Edit"].map((t) => `${t}(${permissionPath(path.join(shared, "plugins", "connectors"))}/**)`) : []),
-                "WebSearch",
-                "WebFetch",
-                ...(sites.length ? [...CHROME_ALLOW, ...sites] : []),
-            ],
-            deny: [
-                "Read(data/**)",
-                // The media store: images are looked at through views, so strom knows what was seen.
-                ...(shared ? [`Read(${permissionPath(path.join(shared, "media"))}/**)`] : []),
-                "Edit(data/**)",
-                "Edit(strom.json)",
-                "Edit(.git/**)",
-                ...shell("git:*"),
-                // A password is typed by the user in their own terminal, and so is installing a plugin; the seal is strom's.
-                // (Consents the agent may ask for — strom allow …: strom asks the person in a window.)
-                ...shell("strom login:*"),
-                ...shell("strom connector add:*"),
-                ...shell("strom connector remove:*"),
-                ...shell("strom seal:*"),
-                // The limiter's memory (pace, refusals).
-                ...(shared ? [`Edit(${permissionPath(path.join(shared, "net"))}/**)`] : []),
-                // A session ends with its turn: nothing wakes it up later (a live run waited for a wake-up that never came).
-                "ScheduleWakeup",
-                "CronCreate",
-                // The seal keys: an agent that could read them could forge the seal.
-                `Read(${keys}/**)`,
-                `Edit(${keys}/**)`,
-                // What the browser downloads is strom's to take over; the rest of the folder is the user's.
-                `Read(${downloads}/**)`,
-                ...CHROME_DENY,
-                // With full permissions only the deny rules count: what the allow list kept away is kept away here.
-                ...(settings.agentPermissions() === "full" ? BYPASS_DENY : []),
-            ],
-        },
+        allow: [
+            ...shell("strom:*"),
+            "Read(inputs/**)",
+            "Read(output/**)",
+            "Read(notes/**)",
+            "Read(.strom/views/**)",
+            // Files the user drops for the research; scans are seen through views only (strom media view).
+            ...(shared ? [`Read(${at(path.join(shared, "inbox"))}/**)`] : []),
+            "Edit(notes/**)",
+            // A connector it builds for an archive the research needs (strom connector new); strom runs it.
+            ...(shared ? ["Read", "Edit"].map((t) => `${t}(${at(path.join(shared, "plugins", "connectors"))}/**)`) : []),
+            "WebSearch",
+            "WebFetch",
+            ...(sites.length ? [...CHROME_ALLOW, ...sites] : []),
+        ],
+        deny: [
+            "Read(data/**)",
+            // The media store: images are looked at through views, so strom knows what was seen.
+            ...(shared ? [`Read(${at(path.join(shared, "media"))}/**)`] : []),
+            "Edit(data/**)",
+            "Edit(strom.json)",
+            "Edit(.git/**)",
+            ...shell("git:*"),
+            // A password is typed by the user in their own terminal, and so is installing a plugin; the seal is strom's.
+            // (Consents the agent may ask for — strom allow …: strom asks the person in a window.)
+            ...shell("strom login:*"),
+            ...shell("strom connector add:*"),
+            ...shell("strom connector remove:*"),
+            ...shell("strom seal:*"),
+            // The limiter's memory (pace, refusals).
+            ...(shared ? [`Edit(${at(path.join(shared, "net"))}/**)`] : []),
+            // A session ends with its turn: nothing wakes it up later (a live run waited for a wake-up that never came).
+            ...(claude ? ["ScheduleWakeup", "CronCreate"] : []),
+            // The seal keys: an agent that could read them could forge the seal.
+            `Read(${keys}/**)`,
+            `Edit(${keys}/**)`,
+            // What the browser downloads is strom's to take over; the rest of the folder is the user's.
+            `Read(${downloads}/**)`,
+            ...(claude ? CHROME_DENY : []),
+            // With full permissions only the deny rules count: what the allow list kept away is kept away here.
+            ...(settings.agentPermissions() === "full" ? BYPASS_DENY : []),
+        ],
+    };
+}
+/** Permissions for Claude Code in this tree (paths of this computer). */
+export function claudeSettings(tree) {
+    const lead = new Settings(tree.env, {}).models("claude", tree.config).lead;
+    return {
+        permissions: treeRules(tree, "claude"),
         // The user's model: the desktop app cannot be given one when it opens (the CLI is, with --model).
         ...(lead ? { model: lead } : {}),
     };
 }
+/**
+ * Grok Build's rules for this tree (.grok/config.toml, read once the folder is trusted — strom starts it
+ * so). It reads .claude/settings.json as well; this file says the same with paths it understands.
+ */
+export function grokConfig(tree) {
+    const { allow, deny } = treeRules(tree, "grok");
+    // A TOML basic string is written like a JSON one.
+    const list = (xs) => `[\n${xs.map((x) => `  ${JSON.stringify(x)},`).join("\n")}\n]`;
+    return `# strom: generated (strom agents sync) — Grok Build's rules for this family tree; changed by strom only\n[permission]\nallow = ${list(allow)}\ndeny = ${list(deny)}\n`;
+}
+/** Grok Build reads CLAUDE.md too (for Claude Code's projects): what in it is not for Grok. */
+const GROK_RULES = `# Grok Build in this family tree
+
+CLAUDE.md in this folder is written for Claude Code: its way of delegating (the
+Agent tool, the models opus, sonnet and haiku) is not yours. Follow AGENTS.md,
+and read scans yourself as it says under "Reading scans".
+`;
 /** Denied as well when the user lets the agent do everything else (agent.permissions full). */
 export const BYPASS_DENY = [
     // its own permissions and instructions
     "Edit(.claude/**)",
     ...["AGENTS.md", "CLAUDE.md"].map((f) => `Edit(${f})`),
+    // (Grok Build's own rules and instructions)
+    "Edit(.grok/**)",
     // downloads round strom's limiter
     "Bash(curl:*)",
     "Bash(wget:*)",
@@ -218,47 +243,63 @@ export function opencodeConfig(tree) {
     const abs = (p) => p.replace(/\\/g, "/");
     const full = settings.agentPermissions() === "full";
     const users = ["strom login *", "strom seal *", "strom connector add *", "strom connector remove *"];
+    // The user's model ("provider/model"): its conversation takes no --model, it reads it here.
+    const lead = settings.models("opencode", tree.config).lead;
+    const permission = {
+        bash: {
+            "*": "ask",
+            "strom *": "allow",
+            ...Object.fromEntries(users.map((c) => [c, "deny"])),
+            "git *": "deny",
+            ...(full ? { "curl *": "deny", "wget *": "deny" } : {}),
+        },
+        read: { "*": "allow", "data/*": "deny", ".git/*": "deny" },
+        edit: {
+            "*": "ask",
+            "notes/*": "allow",
+            "data/*": "deny",
+            ".git/*": "deny",
+            "strom.json": "deny",
+            // its own rules and instructions
+            "opencode.json": "deny",
+            ...Object.fromEntries(["AGENTS.md", "CLAUDE.md", ".claude/*"].map((f) => [f, "deny"])),
+        },
+        external_directory: {
+            "*": "ask",
+            ...(shared
+                ? {
+                    [`${abs(path.join(shared, "inbox"))}/*`]: "allow",
+                    [`${abs(path.join(shared, "plugins", "connectors"))}/*`]: "allow",
+                    // images are looked at through views, so strom knows what was seen; the limiter's memory is strom's
+                    [`${abs(path.join(shared, "media"))}/*`]: "deny",
+                    [`${abs(path.join(shared, "net"))}/*`]: "deny",
+                }
+                : {}),
+            // the seal keys, and what the browser downloads (strom's to take over)
+            [`${abs(configDir(tree.env))}/*`]: "deny",
+            [`${abs(settings.downloads())}/*`]: "deny",
+        },
+        webfetch: "allow",
+        websearch: "allow",
+    };
+    // What would ask is refused when nobody watches: OpenCode 2 ends a whole headless run at the first question
+    // it cannot ask (found live), where a refusal only fails that call.
+    const refused = (v) => v === "ask" ? "deny" : v && typeof v === "object" ? Object.fromEntries(Object.entries(v).map(([k, x]) => [k, refused(x)])) : v;
     return {
         $schema: "https://opencode.ai/config.json",
-        permission: {
-            bash: {
-                "*": "ask",
-                "strom *": "allow",
-                ...Object.fromEntries(users.map((c) => [c, "deny"])),
-                "git *": "deny",
-                ...(full ? { "curl *": "deny", "wget *": "deny" } : {}),
-            },
-            read: { "*": "allow", "data/*": "deny", ".git/*": "deny" },
-            edit: {
-                "*": "ask",
-                "notes/*": "allow",
-                "data/*": "deny",
-                ".git/*": "deny",
-                "strom.json": "deny",
-                // its own rules and instructions
-                "opencode.json": "deny",
-                ...Object.fromEntries(["AGENTS.md", "CLAUDE.md", ".claude/*"].map((f) => [f, "deny"])),
-            },
-            external_directory: {
-                "*": "ask",
-                ...(shared
-                    ? {
-                        [`${abs(path.join(shared, "inbox"))}/*`]: "allow",
-                        [`${abs(path.join(shared, "plugins", "connectors"))}/*`]: "allow",
-                        // images are looked at through views, so strom knows what was seen; the limiter's memory is strom's
-                        [`${abs(path.join(shared, "media"))}/*`]: "deny",
-                        [`${abs(path.join(shared, "net"))}/*`]: "deny",
-                    }
-                    : {}),
-                // the seal keys, and what the browser downloads (strom's to take over)
-                [`${abs(configDir(tree.env))}/*`]: "deny",
-                [`${abs(settings.downloads())}/*`]: "deny",
+        ...(lead ? { model: lead } : {}),
+        permission,
+        agent: {
+            [OPENCODE_RUN_AGENT]: {
+                mode: "primary",
+                description: "strom run: the agent working alone, nobody to ask — what the rules do not allow is refused",
+                permission: refused(permission),
             },
-            webfetch: "allow",
-            websearch: "allow",
         },
     };
 }
+/** OpenCode's agent for a run nobody watches under ask and auto (opencode run --agent). */
+export const OPENCODE_RUN_AGENT = "strom-run";
 /** Files strom wrote for Gemini CLI (gone: Google ended it for personal accounts) — taken away when they are strom's. */
 const OBSOLETE = [
     ["GEMINI.md", (t) => t.startsWith("@./AGENTS.md") && t.includes(MARKER) && t.slice(t.indexOf(MARKER) + MARKER.length).trim() === ""],
@@ -277,7 +318,7 @@ function withUserPart(file, generated) {
     }
     return generated;
 }
-export const AGENT_FILES = ["AGENTS.md", "CLAUDE.md", path.join(".claude", "settings.json"), "opencode.json"];
+export const AGENT_FILES = ["AGENTS.md", "CLAUDE.md", path.join(".claude", "settings.json"), "opencode.json", path.join(".grok", "config.toml"), path.join(".grok", "rules", "strom.md")];
 export function syncAgentFiles(tree) {
     const written = [];
     const write = (rel, content) => {
@@ -300,6 +341,8 @@ export function syncAgentFiles(tree) {
     write("CLAUDE.md", claudeMd(tree));
     write(path.join(".claude", "settings.json"), JSON.stringify(claudeSettings(tree), null, 2) + "\n");
     write("opencode.json", JSON.stringify(opencodeConfig(tree), null, 2) + "\n");
+    write(path.join(".grok", "config.toml"), grokConfig(tree));
+    write(path.join(".grok", "rules", "strom.md"), GROK_RULES);
     for (const [rel, ours] of OBSOLETE) {
         const file = path.join(tree.root, rel);
         let text;

package/dist/agents/global.js

@@ -8,7 +8,9 @@
 // is the user's — a password, a consent — strom itself keeps for the user).
 // OpenCode gets a file of its own named in its global config (a global
 // AGENTS.md of strom's would hide the user's ~/.claude/CLAUDE.md, which
-// OpenCode reads when it has none) and `strom *` allowed there.
+// OpenCode reads when it has none) and `strom *` allowed there. Grok Build
+// gets a skill of its own, like Claude Code, and strom allowed in its
+// config.toml (a marked block; the user's own text around it is kept).
 import fs from "node:fs";
 import path from "node:path";
 import { userHome } from "../core/paths.js";
@@ -26,6 +28,8 @@ mentions strom, a family tree or the Strom app.
 
 1. Run \`strom\` first. It says where the research stands and what to do next
    (\`strom --json\` for the same as data; \`strom guide\` explains the work).
+   Run each strom command on its own — no pipes, no \`;\` or \`&&\` chains: you
+   may run strom without asking, but not what is chained to it.
 2. Not set up yet: ask the user where to keep the research (suggest
    ~/Documents/Strom) and which language they want, then run
    \`strom setup --home "<folder>" --lang <code> --yes\`, then
@@ -66,7 +70,46 @@ function allowRules(agent) {
     if (agent === "antigravity")
         return ["command(strom)"];
     const commands = ["strom", ...(installation().launchers ?? [])];
-    return commands.flatMap((c) => [`Bash(${c}:*)`, `PowerShell(${c}:*)`]);
+    // Grok Build: one shell tool (its rules know no PowerShell)
+    return commands.flatMap((c) => (agent === "grok" ? [`Bash(${c}:*)`] : [`Bash(${c}:*)`, `PowerShell(${c}:*)`]));
+}
+/**
+ * Grok Build's config.toml, strom's lines marked: a [permission] table of strom's when there is none,
+ * else strom's allow list in the user's table — when it has no allow list of its own (strom does not
+ * rewrite the user's list: Grok then asks before it runs strom, as the user set it).
+ */
+const TOML_BEGIN = "# strom: begin (strom agents install; removed by strom agents uninstall)";
+const TOML_END = "# strom: end";
+function grokWithout(text) {
+    const lines = text.split("\n");
+    const out = [];
+    let inside = false;
+    for (const l of lines) {
+        if (l.trim() === TOML_BEGIN)
+            inside = true;
+        else if (l.trim() === TOML_END)
+            inside = false;
+        else if (!inside)
+            out.push(l);
+    }
+    return out.join("\n");
+}
+function grokWith(text) {
+    const rest = grokWithout(text);
+    const allow = `allow = [${allowRules("grok").map((r) => JSON.stringify(r)).join(", ")}]`;
+    const lines = rest.split("\n");
+    const header = lines.findIndex((l) => /^\s*\[permission\]\s*(#.*)?$/.test(l));
+    if (header < 0) {
+        const body = rest.replace(/\s+$/, "");
+        return `${body ? `${body}\n\n` : ""}${TOML_BEGIN}\n[permission]\n${allow}\n${TOML_END}\n`;
+    }
+    // the user's table: up to the next table
+    let end = lines.findIndex((l, i) => i > header && /^\s*\[/.test(l));
+    if (end < 0)
+        end = lines.length;
+    if (lines.slice(header + 1, end).some((l) => /^\s*allow\s*=/.test(l)))
+        return undefined;
+    return [...lines.slice(0, header + 1), TOML_BEGIN, allow, TOML_END, ...lines.slice(header + 1)].join("\n");
 }
 /** A rule of strom's in Claude Code's or Antigravity's settings, whichever installation wrote it. */
 function isStromRule(agent, rule) {
@@ -74,12 +117,26 @@ function isStromRule(agent, rule) {
         return rule === "command(strom)";
     return /^(?:Bash|PowerShell)\((?:.*[\\/])?strom(?:\.exe|\.cmd)?:\*\)$/.test(rule);
 }
+/** Grok Build's folder (GROK_HOME, else ~/.grok). */
+function grokDir(env) {
+    return env.GROK_HOME ?? path.join(userHome(env), ".grok");
+}
 /** OpenCode: the rule that lets it run strom without asking. */
 const OPENCODE_STROM = "strom *";
 /** OpenCode's global config folder (it follows XDG on every system). */
 function opencodeDir(env) {
     return path.join(env.XDG_CONFIG_HOME ?? path.join(userHome(env), ".config"), "opencode");
 }
+/** Claude Code starts its own conversations with Remote Control (its setting remoteControlAtStartup, the user's own). */
+export function claudeRemoteAtStartup(env) {
+    try {
+        const file = path.join(env.CLAUDE_CONFIG_DIR ?? path.join(userHome(env), ".claude"), "settings.json");
+        return JSON.parse(fs.readFileSync(file, "utf8")).remoteControlAtStartup === true;
+    }
+    catch {
+        return false; // no settings, or not readable: not on
+    }
+}
 export function globalTargets(env) {
     const home = userHome(env);
     return [
@@ -91,6 +148,8 @@ export function globalTargets(env) {
         { agent: "antigravity", file: path.join(home, ".gemini", "antigravity-cli", "settings.json"), kind: "allow" },
         { agent: "opencode", file: path.join(opencodeDir(env), "strom.md"), kind: "own" },
         { agent: "opencode", file: path.join(opencodeDir(env), "opencode.json"), kind: "allow" },
+        { agent: "grok", file: path.join(grokDir(env), "skills", "strom", "SKILL.md"), kind: "own" },
+        { agent: "grok", file: path.join(grokDir(env), "config.toml"), kind: "allow" },
     ];
 }
 const SKILL = `---
@@ -199,7 +258,13 @@ function removeAllow(t, s) {
 export function installGlobal(t) {
     const cur = read(t.file);
     let next;
-    if (t.kind === "allow") {
+    if (t.kind === "allow" && t.agent === "grok") {
+        const with_ = grokWith(cur ?? "");
+        if (with_ === undefined)
+            return false;
+        next = with_;
+    }
+    else if (t.kind === "allow") {
         const s = settingsOf(cur);
         if (!s || hasAllow(t, s))
             return false;
@@ -207,7 +272,7 @@ export function installGlobal(t) {
         next = JSON.stringify(s, null, 2) + "\n";
     }
     else if (t.kind === "own")
-        next = t.agent === "claude" ? SKILL : GLOBAL_TEXT;
+        next = t.agent === "claude" || t.agent === "grok" ? SKILL : GLOBAL_TEXT;
     else {
         const rest = cur ? withoutBlock(cur).replace(/\s+$/, "") : "";
         next = `${rest ? `${rest}\n\n` : ""}${BEGIN}\n${GLOBAL_TEXT}${END}\n`;
@@ -223,6 +288,16 @@ export function uninstallGlobal(t) {
     const cur = read(t.file);
     if (cur === undefined)
         return false;
+    if (t.kind === "allow" && t.agent === "grok") {
+        if (!cur.includes(TOML_BEGIN))
+            return false;
+        const rest = grokWithout(cur);
+        if (rest.trim())
+            writeFileAtomic(t.file, rest.replace(/\n{3,}/g, "\n\n").replace(/\s*$/, "\n"));
+        else
+            fs.rmSync(t.file);
+        return true;
+    }
     if (t.kind === "allow") {
         const s = settingsOf(cur);
         // Any of strom's rules, also those another installation of strom wrote.
@@ -234,8 +309,8 @@ export function uninstallGlobal(t) {
         return true;
     }
     if (t.kind === "own") {
-        // The skill is a folder of its own; OpenCode's instructions one file among the user's.
-        if (t.agent === "claude")
+        // A skill is a folder of its own; OpenCode's instructions one file among the user's.
+        if (t.agent === "claude" || t.agent === "grok")
             fs.rmSync(path.dirname(t.file), { recursive: true, force: true });
         else
             fs.rmSync(t.file, { force: true });
@@ -262,6 +337,8 @@ export function isInstalled(t) {
     const cur = read(t.file);
     if (cur === undefined)
         return false;
+    if (t.kind === "allow" && t.agent === "grok")
+        return cur.includes(TOML_BEGIN) && grokWith(cur) === cur;
     if (t.kind === "allow")
         return hasAllow(t, settingsOf(cur) ?? {});
     return t.kind === "own" || cur.includes(BEGIN);

package/dist/agents/launch.js

@@ -11,26 +11,33 @@
 // --dangerously-skip-permissions; `strom` is allowed in its settings (strom agents install).
 // OpenCode: ask and auto — the tree's rules (opencode.json), anything else it
 // asks (it has no review of its own); full — --auto, everything the rules do not deny.
+// Grok Build: always --trust (the tree folder: else it reads neither AGENTS.md nor
+// the tree's rules); ask — its own mode; auto — --permission-mode auto (its own
+// review); full — --always-approve (only the deny rules count).
 //
 // Claude Code always gets the tree's allow and deny lists (--settings); Codex
-// works in its sandbox on the tree folder with the shared folder added and the
-// network on (strom fetches).
+// works in its sandbox on the tree folder with its .git (strom commits) and the
+// shared folder writable and the network on (strom fetches).
 import { claudeArgs } from "../runners/claude.js";
+import { codexWritable } from "../runners/codex.js";
 /** The command line of a conversation with this agent. */
 export function conversationArgs(agent, o) {
     if (agent === "claude")
-        return claudeArgs({ interactive: true, kickoff: o.kickoff, permissions: o.level, settingsFile: o.settingsFile, ...(o.name ? { name: o.name } : {}), ...(o.model ? { model: o.model } : {}), ...(o.chrome !== undefined ? { chrome: o.chrome } : {}) });
+        return claudeArgs({ interactive: true, kickoff: o.kickoff, permissions: o.level, settingsFile: o.settingsFile, ...(o.name ? { name: o.name } : {}), ...(o.model ? { model: o.model } : {}), ...(o.chrome !== undefined ? { chrome: o.chrome } : {}), ...(o.remote ? { remote: true } : {}) });
     if (agent === "codex") {
         const args = o.level === "full"
             ? ["--dangerously-bypass-approvals-and-sandbox"]
-            : [...(o.level === "auto" ? ["--approve-for-me"] : ["--sandbox", "workspace-write", "--ask-for-approval", "on-request"]), "-c", "sandbox_workspace_write.network_access=true", ...(o.shared ? ["--add-dir", o.shared] : [])];
+            : [...(o.level === "auto" ? ["--approve-for-me"] : ["--sandbox", "workspace-write", "--ask-for-approval", "on-request"]), "-c", "sandbox_workspace_write.network_access=true", ...codexWritable(o.root, o.shared)];
         return [...args, "--search", ...(o.model ? ["--model", o.model] : []), o.kickoff];
     }
     if (agent === "antigravity") {
         const mode = o.level === "full" ? ["--dangerously-skip-permissions"] : o.level === "auto" ? ["--mode", "accept-edits"] : [];
         return [...mode, ...(o.shared ? ["--add-dir", o.shared] : []), ...(o.model ? ["--model", o.model] : []), "--prompt-interactive", o.kickoff];
     }
+    // (its TUI takes no --model: the model is in the tree's opencode.json)
     if (agent === "opencode")
-        return [...(o.level === "full" ? ["--auto"] : []), ...(o.model ? ["--model", o.model] : []), "--prompt", o.kickoff];
+        return [...(o.level === "full" ? ["--auto"] : []), "--prompt", o.kickoff];
+    if (agent === "grok")
+        return ["--trust", ...(o.level === "full" ? ["--always-approve"] : o.level === "auto" ? ["--permission-mode", "auto"] : []), ...(o.model ? ["--model", o.model] : []), o.kickoff];
     throw new Error(`no conversation launcher for agent "${agent}"`);
 }

package/dist/agents/profiles.js

@@ -20,8 +20,8 @@ const DELEGATION_RULES = `- Browsing a book, an index or a range of images ("is
 - Delegates never write to the research. You record their findings through
   strom; a negative result of a delegate is recorded as a search "by reader".
 - Only entries that will get a citation need your own eyes.`;
-/** For agents that cannot pick a model for a subagent (Codex, Antigravity, OpenCode): read yourself, in small batches. */
-export const SELF_READING = `## Reading scans (Codex, Antigravity, OpenCode)
+/** For agents that cannot pick a model for a subagent (Codex, Antigravity, OpenCode, Grok): read yourself, in small batches. */
+export const SELF_READING = `## Reading scans (Codex, Antigravity, OpenCode, Grok)
 
 Read the images yourself, in batches of at most ten: open a batch, write down
 what it gave (strom search add … for what was not found, facts for what was),
@@ -85,6 +85,17 @@ ${DELEGATION_RULES}
         models: {},
         instructions: () => SELF_READING,
     },
+    // xAI's Grok Build: its subagents take only its own models (no cheaper reader worth the images): it reads itself.
+    grok: {
+        id: "grok",
+        name: "Grok Build",
+        command: "grok",
+        exit: "/quit",
+        url: "https://x.ai/cli",
+        delegation: "strom",
+        models: {},
+        instructions: () => SELF_READING,
+    },
 };
 export const DEFAULT_AGENT = "claude";
 export function profile(id) {

package/dist/cli/main.js

@@ -6,7 +6,10 @@ import { groupHelp, helpFor } from "./help.js";
 import { autoCommit } from "./commit.js";
 import { assertIntact } from "../core/integrity.js";
 import { resetCache } from "../core/git.js";
-import { VERSION } from "../core/tree.js";
+import { Tree, VERSION } from "../core/tree.js";
+import { fireHooks, HOOK_INTERFACE } from "../core/hooks.js";
+import { prependPath } from "../runners/runner.js";
+import { shimDir } from "../commands/session.js";
 import { isAgent } from "../core/which.js";
 import { noticeStromApp } from "../core/stromapp.js";
 import { isNewer } from "../core/update.js";
@@ -116,6 +119,19 @@ export async function main(argv, io, env, cwd) {
         const ctx = Context.fromOptions({ env, cwd, io, json, values: v });
         ran = ctx;
         command = def.path.join(" ");
+        // What is saved into a research, the user's hooks are told of (in the background).
+        Tree.onCommit = (tree, ops, commit) => {
+            if (!ctx.settings.config.hooks?.length || env.STROM_HOOK)
+                return;
+            // this strom on the hook's PATH: it reads more of what was saved (strom person card P0012)
+            fireHooks(ctx.settings.shared()?.value, ctx.settings.config.hooks, prependPath(env, shimDir(tree)), {
+                interface: HOOK_INTERFACE,
+                tree: { name: tree.config.name, id: tree.config.id, root: tree.root, lang: tree.lang },
+                commit,
+                at: new Date().toISOString(),
+                events: ops.map((o) => ({ op: o.op, targets: o.targets, summary: o.summary, at: o.at, by: o.by, ...(o.reason ? { reason: o.reason } : {}) })),
+            });
+        };
         // Started by the Strom app: remembered quietly (it is where the results go).
         if (env.STROM_APP)
             noticeStromApp(ctx.settings, env);