strom-research 1.0.0

package/dist/agents/files.js

@@ -0,0 +1,313 @@
+// 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.
+import fs from "node:fs";
+import path from "node:path";
+import { langName } from "../core/lang.js";
+import { writeFileAtomic } from "../core/json.js";
+import { PROFILES, SELF_READING } from "./profiles.js";
+import { Settings } from "../core/config.js";
+import { configDir } from "../core/paths.js";
+import { browserConnectors } from "../core/connector.js";
+import { CHROME_ALLOW, CHROME_DENY, chromeDomain } from "../core/browser.js";
+export const MARKER = "<!-- strom: generated above this line (strom agents sync); your own notes below are kept -->";
+function agentsMd(tree) {
+    const lang = langName(tree.config.lang);
+    return `# Family research: ${tree.config.name}
+
+This folder is a family tree researched with **strom**, a command-line tool
+that holds the evidence, the method and the history of the research. You are
+the researcher; \`strom\` is your only way to read and change the research.
+
+1. Start with \`strom\` — it says where things stand and what to do next.
+   \`strom guide\` explains the work; \`strom help <command>\` any command.
+2. Work in sessions: \`strom session start\` gives you the brief for the next
+   task; finish with \`strom session close --summary "…" --next "…"\`.
+3. Never create, edit or delete anything in \`data/\`, \`strom.json\` or \`.git\`,
+   never read the files in \`data/\` (strom shows them better and shorter), and
+   never run git yourself. strom detects changes and then refuses to write.
+4. The research language is ${lang}: talk to the user in ${lang} and write notes,
+   tasks and summaries in ${lang}. Transcripts stay in the record's language.
+5. Material from the user goes in with \`strom intake <file or folder>\` or
+   \`strom intake --text "…"\`. Exit code 3 means strom needs an answer from the
+   user; exit code 4 means the USER must run the given command in their own
+   terminal — never do it yourself.
+6. You may read \`inputs/\`, \`output/\`, \`notes/\` and \`.strom/views/\`, and write
+   your own working notes in \`notes/\`. Scans are looked at through views:
+   \`strom media view B0001:57 --half left\` writes one to \`.strom/views/\`.
+7. Run strom commands on their own — no pipes (\`| head\`, \`| grep\`): output is
+   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
+   another one has started.
+
+## Working with the user
+
+The user watches this conversation and is usually not technical. Talk in
+${lang}, plainly: say "the baptism of Karel in 1782", not record IDs, unless
+they ask.
+
+- **First conversation** (no research yet): explain in a few sentences how you
+  work together — you search registers and archives, record only what a
+  record proves, and ask them for decisions and for what only they can do —
+  then ask whom to research and what they know or have: names, dates, places,
+  documents, photos, a family tree file.
+- **The user decides**: whom to research, what next, anything that costs
+  money, what you may do. Suggest; do not decide for them.
+- **Ways of working** — explain them when it helps:
+  - this conversation: the two of you together;
+  - the agent working on its own: they start it from strom's menu ("Let the
+    agent work on its own"); it works the task queue and tells them the result;
+    with many tasks in the queue, suggest it — every task gets a fresh session;
+  - one task, one fresh context: after a session closes, strom says how the
+    user clears your context (Claude Code: /clear) — nothing is lost, strom
+    keeps it all; suggest it in a sentence, go on here if they prefer;
+  - what only they can do: when strom needs their consent it opens a window
+    on their screen — tell them to answer it, you cannot; images a portal gives
+    only by hand — strom says which ones and where to save them.
+- **Downloaders**: the research needs an archive strom has no downloader
+  (connector) for — build one yourself, do not wait to be asked; tell them in
+  a sentence what you are doing ("I am preparing a downloader for this
+  archive — a few minutes; it then fetches only the images we need, slowly").
+- **Stories of their ancestors**: on by default — once records tell a life,
+  strom proposes a task to write it for the family book in the Strom app
+  (the method: a story rests on recorded facts only). When the research
+  starts, tell them in a sentence and that they may say no (\`strom\` shows
+  whether they chose; \`strom config set stories no\`). A story stays a draft
+  until they approve it.
+- **What waits for them** (\`strom\` shows it): tell them plainly what to do
+  and where, one thing at a time.
+- **Results and the Strom app**: \`output/tree-strom.ged\` is the family tree
+  for the Strom app (https://stromapp.info) — strom's companion: a free family
+  tree app, no account, their data stay on their computer; it shows the tree,
+  the sources, a map, a family book. When they want to see the results (or
+  once, when the first ones are there), suggest it gently, in a sentence or
+  two: best installed as an app from the browser, from
+  https://stromapp.info/run/ — \`strom app install\` opens it there and says
+  where to click; it works offline then; \`strom app\` opens it, with this
+  research when the app can take it — run by you, the app then follows the
+  research live, what you record shows there by itself (else in the app:
+  Import, and this file). \`strom\` says which, in its results line. A program they already use is fine too:
+  \`output/tree.ged\`. If they do not want it, do not bring it up again.
+- **The tree in this conversation, app or not**: they can simply ask you —
+  about anyone in the tree, a family, a line, what is proven and by which
+  record, what is still missing. Answer from strom (\`strom person show\`,
+  \`family show\`, \`research show\`, \`find\`, \`source show\`, \`story show\`,
+  \`gaps\`, \`frontier\`) in plain words: names, dates, places and the record
+  behind each fact, no IDs. Tell them once that they can ask like this.
+
+${SELF_READING}
+${MARKER}
+`;
+}
+function claudeMd(tree) {
+    const models = new Settings(tree.env, {}).models("claude", tree.config);
+    return `@AGENTS.md
+
+Claude Code: use Bash for \`strom\` commands only; read images and documents
+with the Read tool. You can choose a model for a subagent: delegate reading as
+below, not the way "Reading scans" in AGENTS.md says for other agents.
+
+${PROFILES.claude.instructions(models)}
+${MARKER}
+`;
+}
+/** An absolute path as a Claude Code permission path ("//Users/x", "//c/Users/x"). */
+export function permissionPath(abs) {
+    const p = abs.replace(/\\/g, "/");
+    const win = /^([A-Za-z]):\/(.*)$/.exec(p);
+    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).
+ */
+export function claudeSettings(tree) {
+    const settings = new Settings(tree.env, {});
+    const shared = settings.shared()?.value;
+    const keys = permissionPath(configDir(tree.env));
+    // Connectors whose images come through the user's browser: browser tools, for their sites only.
+    const browser = browserConnectors(tree.env, 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;
+    return {
+        permissions: {
+            allow: [
+                "Bash(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/**)",
+                "Bash(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.)
+                "Bash(strom login:*)",
+                "Bash(strom connector add:*)",
+                "Bash(strom connector remove:*)",
+                "Bash(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 : []),
+            ],
+        },
+        // The user's model: the desktop app cannot be given one when it opens (the CLI is, with --model).
+        ...(lead ? { model: lead } : {}),
+    };
+}
+/** 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})`),
+    // downloads round strom's limiter
+    "Bash(curl:*)",
+    "Bash(wget:*)",
+];
+/**
+ * OpenCode's rules for this tree (opencode.json in the tree folder, found as the
+ * project's config): strom commands allowed; the evidence, the seal and git are
+ * strom's; a password and installing a plugin the user's own. Paths inside the
+ * tree are relative to it; folders outside it (the shared inbox and plugins) are
+ * "external directories". Of several matching rules the last one counts, so the
+ * general rule comes first.
+ */
+export function opencodeConfig(tree) {
+    const settings = new Settings(tree.env, {});
+    const shared = settings.shared()?.value;
+    const abs = (p) => p.replace(/\\/g, "/");
+    const full = settings.agentPermissions() === "full";
+    const users = ["strom login *", "strom seal *", "strom connector add *", "strom connector remove *"];
+    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",
+            },
+            webfetch: "allow",
+            websearch: "allow",
+        },
+    };
+}
+/** 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() === ""],
+    [path.join(".gemini", "strom-policy.toml"), (t) => t.startsWith("# strom: generated")],
+];
+/** Keep what the user wrote below the marker. */
+function withUserPart(file, generated) {
+    try {
+        const old = fs.readFileSync(file, "utf8");
+        const i = old.indexOf(MARKER);
+        if (i >= 0)
+            return generated + old.slice(i + MARKER.length + 1);
+    }
+    catch {
+        // new file
+    }
+    return generated;
+}
+export const AGENT_FILES = ["AGENTS.md", "CLAUDE.md", path.join(".claude", "settings.json"), "opencode.json"];
+export function syncAgentFiles(tree) {
+    const written = [];
+    const write = (rel, content) => {
+        const file = path.join(tree.root, rel);
+        const next = rel.endsWith(".md") ? withUserPart(file, content) : content;
+        let cur;
+        try {
+            cur = fs.readFileSync(file, "utf8");
+        }
+        catch {
+            cur = undefined;
+        }
+        if (cur === next)
+            return;
+        if (!tree.dryRun)
+            writeFileAtomic(file, next);
+        written.push(rel.split(path.sep).join("/"));
+    };
+    write("AGENTS.md", agentsMd(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");
+    for (const [rel, ours] of OBSOLETE) {
+        const file = path.join(tree.root, rel);
+        let text;
+        try {
+            text = fs.readFileSync(file, "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (!ours(text))
+            continue; // the user's own
+        if (!tree.dryRun) {
+            fs.rmSync(file);
+            if (path.dirname(rel) !== "." && fs.readdirSync(path.dirname(file)).length === 0)
+                fs.rmdirSync(path.dirname(file));
+        }
+        written.push(rel.split(path.sep).join("/"));
+    }
+    return written;
+}

package/dist/agents/global.js

@@ -0,0 +1,257 @@
+// Teaching an agent CLI about strom in any folder: a user who opens Claude
+// Code, Codex or Antigravity anywhere and says "I want to research my ancestors"
+// gets an agent that knows strom is there and how to start. Claude Code gets
+// a skill of its own; Codex and Antigravity a marked block in their
+// global instruction file (the user's own text around it is kept) — and in
+// the settings of Claude Code (also its desktop app) and Antigravity, strom
+// allowed: an agent opened anywhere runs strom without asking each time (what
+// 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.
+import fs from "node:fs";
+import path from "node:path";
+import { userHome } from "../core/paths.js";
+import { writeFileAtomic } from "../core/json.js";
+import { installation } from "../core/self.js";
+const BEGIN = "<!-- strom: begin (strom agents install; removed by strom agents uninstall) -->";
+const END = "<!-- strom: end -->";
+export const GLOBAL_TEXT = `# strom — family history research
+
+strom (the \`strom\` command) is installed on this computer: a tool for
+researching a family's history with you as the researcher — people, parish
+registers, archives, evidence, a family tree the Strom app can import.
+Use it whenever the user wants to research their ancestors or family, or
+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).
+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
+   \`strom init "<name of the family tree>"\`.
+3. Talk to the user in their language. Ask them before decisions: whom to
+   research, what they already know, anything that costs money or needs
+   their permission.
+4. The research lives in a family tree folder; change it ONLY through
+   \`strom\` commands, never by editing its files. In that folder its own
+   AGENTS.md says the rest.
+5. You work best started by strom: it opens you in the tree folder with the
+   right permissions. Tell the user once: next time run \`strom\` in a
+   terminal (or the "Strom research" shortcut on the desktop) and choose
+   "Continue the research with the agent".
+6. When strom needs the user's consent it opens a window on their screen —
+   tell them to answer it; you cannot. Exit code 4 means the user must run
+   the given command themselves.
+7. Scans come through strom. An archive the research needs has no
+   downloader (connector) yet: build one yourself, unasked
+   (\`strom connector new\`), and tell the user in a sentence.
+8. The Strom app (https://stromapp.info) is strom's companion: a free family
+   tree app, no account, the data stay on the user's computer. The research's
+   result (\`output/tree-strom.ged\`) opens in it. When the user wants to see
+   the tree, suggest it gently — best installed as an app from the browser,
+   from https://stromapp.info/run/ (\`strom app install\` opens it there; it
+   then works offline); \`strom app\` opens it — with the research, followed
+   live while you work, when the app can take it. Without it, the user can ask
+   you about anyone in the tree: answer from \`strom person show\` and the like.
+`;
+/**
+ * The rules that let the agent run strom without asking, in its own settings' words.
+ * Claude Code: `strom` on PATH, and the installer's command by its path — right after
+ * the installer an agent calls it so, until a new terminal has it on PATH.
+ */
+function allowRules(agent) {
+    if (agent === "antigravity")
+        return ["command(strom)"];
+    return ["Bash(strom:*)", ...(installation().launchers ?? []).map((p) => `Bash(${p}:*)`)];
+}
+/** A rule of strom's in Claude Code's or Antigravity's settings, whichever installation wrote it. */
+function isStromRule(agent, rule) {
+    if (agent === "antigravity")
+        return rule === "command(strom)";
+    return /^Bash\((?:.*[\\/])?strom(?:\.exe|\.cmd)?:\*\)$/.test(rule);
+}
+/** 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");
+}
+export function globalTargets(env) {
+    const home = userHome(env);
+    return [
+        { agent: "claude", file: path.join(env.CLAUDE_CONFIG_DIR ?? path.join(home, ".claude"), "skills", "strom", "SKILL.md"), kind: "own" },
+        { agent: "claude", file: path.join(env.CLAUDE_CONFIG_DIR ?? path.join(home, ".claude"), "settings.json"), kind: "allow" },
+        { agent: "codex", file: path.join(env.CODEX_HOME ?? path.join(home, ".codex"), "AGENTS.md"), kind: "block" },
+        // Antigravity CLI reads its global rules where Gemini CLI did, and its permissions from its settings.
+        { agent: "antigravity", file: path.join(home, ".gemini", "GEMINI.md"), kind: "block" },
+        { 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" },
+    ];
+}
+const SKILL = `---
+name: strom
+description: Family history and genealogy research with the strom command — ancestors, family trees, parish registers and archives, evidence, GEDCOM and the Strom app. Use when the user wants to research their family or mentions strom or the Strom app.
+---
+
+${GLOBAL_TEXT}`;
+function read(file) {
+    try {
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function withoutBlock(text) {
+    const i = text.indexOf(BEGIN);
+    const j = text.indexOf(END);
+    if (i < 0 || j < i)
+        return text;
+    const before = text.slice(0, i).replace(/\s+$/, "");
+    const after = text.slice(j + END.length).replace(/^\s+/, "");
+    const rest = before && after ? `${before}\n\n${after}` : before || after;
+    return rest ? `${rest.replace(/\s+$/, "")}\n` : "";
+}
+/** The agent's settings as JSON, or undefined when they are not (strom then leaves them alone). */
+function settingsOf(text) {
+    if (text === undefined || !text.trim())
+        return {};
+    try {
+        const v = JSON.parse(text);
+        return v && typeof v === "object" && !Array.isArray(v) ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function allowList(s) {
+    const p = (s.permissions ?? {});
+    return Array.isArray(p.allow) ? p.allow : [];
+}
+function isObject(v) {
+    return Boolean(v) && typeof v === "object" && !Array.isArray(v);
+}
+/** Is strom allowed in these settings (and, for OpenCode, its instructions named)? */
+function hasAllow(t, s) {
+    if (t.agent !== "opencode")
+        return allowRules(t.agent).every((r) => allowList(s).includes(r));
+    const bash = isObject(s.permission) ? s.permission.bash : undefined;
+    const own = path.join(path.dirname(t.file), "strom.md");
+    return isObject(bash) && bash[OPENCODE_STROM] === "allow" && Array.isArray(s.instructions) && s.instructions.includes(own);
+}
+function addAllow(t, s) {
+    if (t.agent !== "opencode") {
+        const have = allowList(s);
+        s.permissions = { ...(s.permissions ?? {}), allow: [...have, ...allowRules(t.agent).filter((r) => !have.includes(r))] };
+        return;
+    }
+    const perm = isObject(s.permission) ? s.permission : typeof s.permission === "string" ? { "*": s.permission } : {};
+    // A plain value for bash ("ask") becomes the general rule; strom's comes after it (the last match counts).
+    const bash = isObject(perm.bash) ? perm.bash : typeof perm.bash === "string" ? { "*": perm.bash } : {};
+    s.permission = { ...perm, bash: { ...bash, [OPENCODE_STROM]: "allow" } };
+    const own = path.join(path.dirname(t.file), "strom.md");
+    const list = Array.isArray(s.instructions) ? s.instructions : [];
+    if (!list.includes(own))
+        s.instructions = [...list, own];
+}
+function removeAllow(t, s) {
+    if (t.agent !== "opencode") {
+        const rest = allowList(s).filter((r) => !isStromRule(t.agent, r));
+        const perms = { ...s.permissions };
+        if (rest.length)
+            perms.allow = rest;
+        else
+            delete perms.allow;
+        if (Object.keys(perms).length)
+            s.permissions = perms;
+        else
+            delete s.permissions;
+        return;
+    }
+    const own = path.join(path.dirname(t.file), "strom.md");
+    if (Array.isArray(s.instructions)) {
+        const rest = s.instructions.filter((i) => i !== own);
+        if (rest.length)
+            s.instructions = rest;
+        else
+            delete s.instructions;
+    }
+    if (isObject(s.permission) && isObject(s.permission.bash)) {
+        const bash = { ...s.permission.bash };
+        delete bash[OPENCODE_STROM];
+        const perm = { ...s.permission };
+        if (Object.keys(bash).length)
+            perm.bash = bash;
+        else
+            delete perm.bash;
+        if (Object.keys(perm).length)
+            s.permission = perm;
+        else
+            delete s.permission;
+    }
+}
+/** Write it for one agent; false when it was already there as it is. */
+export function installGlobal(t) {
+    const cur = read(t.file);
+    let next;
+    if (t.kind === "allow") {
+        const s = settingsOf(cur);
+        if (!s || hasAllow(t, s))
+            return false;
+        addAllow(t, s);
+        next = JSON.stringify(s, null, 2) + "\n";
+    }
+    else if (t.kind === "own")
+        next = t.agent === "claude" ? SKILL : GLOBAL_TEXT;
+    else {
+        const rest = cur ? withoutBlock(cur).replace(/\s+$/, "") : "";
+        next = `${rest ? `${rest}\n\n` : ""}${BEGIN}\n${GLOBAL_TEXT}${END}\n`;
+    }
+    if (cur === next)
+        return false;
+    fs.mkdirSync(path.dirname(t.file), { recursive: true });
+    writeFileAtomic(t.file, next);
+    return true;
+}
+/** Take it away again; false when there was nothing of strom's. */
+export function uninstallGlobal(t) {
+    const cur = read(t.file);
+    if (cur === undefined)
+        return false;
+    if (t.kind === "allow") {
+        const s = settingsOf(cur);
+        // Any of strom's rules, also those another installation of strom wrote.
+        const any = t.agent === "opencode" ? s && hasAllow(t, s) : s && allowList(s).some((r) => isStromRule(t.agent, r));
+        if (!s || !any)
+            return false;
+        removeAllow(t, s);
+        writeFileAtomic(t.file, JSON.stringify(s, null, 2) + "\n");
+        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")
+            fs.rmSync(path.dirname(t.file), { recursive: true, force: true });
+        else
+            fs.rmSync(t.file, { force: true });
+        return true;
+    }
+    if (!cur.includes(BEGIN))
+        return false;
+    const rest = withoutBlock(cur);
+    if (rest.trim())
+        writeFileAtomic(t.file, rest);
+    else
+        fs.rmSync(t.file);
+    return true;
+}
+export function isInstalled(t) {
+    const cur = read(t.file);
+    if (cur === undefined)
+        return false;
+    if (t.kind === "allow")
+        return hasAllow(t, settingsOf(cur) ?? {});
+    return t.kind === "own" || cur.includes(BEGIN);
+}

package/dist/agents/launch.js

@@ -0,0 +1,36 @@
+// Starting an agent CLI for a conversation with the user, set up the way the
+// user chose once (agent.permissions) — so a person who is not technical never
+// has to know an agent's own switches. Each agent names the levels its own way:
+//
+//   level  Claude Code                 Codex
+//   ask    its own mode (it asks)      sandbox on the folder, asks on request
+//   auto   --permission-mode auto      sandbox on the folder, own review
+//   full   bypassPermissions           no sandbox, no approvals
+//
+// Antigravity CLI (agy): ask — its own mode; auto — accept-edits; full —
+// --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.
+//
+// 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).
+import { claudeArgs } from "../runners/claude.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 } : {}) });
+    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] : [])];
+        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];
+    }
+    if (agent === "opencode")
+        return [...(o.level === "full" ? ["--auto"] : []), ...(o.model ? ["--model", o.model] : []), "--prompt", o.kickoff];
+    throw new Error(`no conversation launcher for agent "${agent}"`);
+}