strom-research 1.2.0 → 1.3.0

package/dist/commands/tasks.js

@@ -16,6 +16,8 @@ import { foldText } from "../core/text.js";
 import { now, typeOfId } from "../core/tree.js";
 import { resolveResearch } from "./research.js";
 import { makeNote } from "../core/actions.js";
+import { phrase } from "../core/phrases.js";
+import { readJsonLines } from "../core/json.js";
 import { lacksImages, rankTasks } from "../core/queue.js";
 import { clipNote, inboxFolderFor, parseImageList, transcriptNote } from "../core/media.js";
 function written(tree) {
@@ -82,6 +84,25 @@ export function rankedQueue(tree, filter = {}) {
 function taskLine(t) {
     return [t.id, `p${t.priority}`, t.level, t.state === "open" ? "" : `[${t.state}]`, truncate(t.what, 70)];
 }
+/** Why a task was put aside: on the task, or — parked by an older strom — in the history. */
+export function parkedWhy(tree, t) {
+    if (t.state !== "parked")
+        return undefined;
+    if (t.parkedReason)
+        return t.parkedReason;
+    const dir = path.join(tree.dataDir, "ops");
+    let last;
+    try {
+        for (const f of fs.readdirSync(dir).filter((x) => x.endsWith(".jsonl")))
+            for (const o of readJsonLines(path.join(dir, f)))
+                if (o.op === "task.park" && o.targets.includes(t.id) && (!last || o.at > last.at))
+                    last = o;
+    }
+    catch {
+        // no history to read
+    }
+    return last?.reason;
+}
 function taskDetail(tree, t) {
     const where = t.where.map((w) => {
         const b = /^B\d{4,}$/.test(w) ? tree.get(w) : undefined;
@@ -89,7 +110,7 @@ function taskDetail(tree, t) {
     });
     const searches = tree.list("search").filter((s) => s.task === t.id || s.recordsets.some((b) => t.where.includes(b)));
     const lessons = tree.list("lesson").filter((l) => l.target && t.where.includes(l.target));
-    return lines(`${t.id} ${t.what}`, `level ${t.level} · priority ${t.priority} · ${t.state}${t.research ? ` · research ${t.research}` : ""}${t.parkedUntil ? ` · parked until ${t.parkedUntil}` : ""}${t.waitingOn ? ` · waiting on ${t.waitingOn}` : ""}`, `where  ${where.join("\n       ")}`, `why    ${t.why}`, `done   ${t.doneWhen}`, t.subject.length ? `about  ${t.subject.join(" ")}` : undefined, t.result ? `result ${t.result}${t.produced?.length ? ` → ${t.produced.join(" ")}` : ""}` : undefined, searches.length ? "\nalready searched there\n" + table(searches.map((s) => [`  ${s.id}`, s.result, truncate(s.question, 60), s.scope.years ?? ""])) : undefined, lessons.length ? "\nlessons for these record sets\n" + lessons.map((l) => `  ${l.id} ${l.rule}`).join("\n") : undefined, ...t.notes.map((n) => `note   ${n.text}`));
+    return lines(`${t.id} ${t.what}`, `level ${t.level} · priority ${t.priority} · ${t.state}${t.research ? ` · research ${t.research}` : ""}${t.parkedUntil ? ` · parked until ${t.parkedUntil}` : ""}${t.waitingOn ? ` · waiting on ${t.waitingOn}` : ""}`, t.state === "parked" ? `parked ${parkedWhy(tree, t) ?? "(no reason recorded)"} — strom task wake ${t.id} to go on` : undefined, `where  ${where.join("\n       ")}`, `why    ${t.why}`, `done   ${t.doneWhen}`, t.subject.length ? `about  ${t.subject.join(" ")}` : undefined, t.result ? `result ${t.result}${t.produced?.length ? ` → ${t.produced.join(" ")}` : ""}` : undefined, searches.length ? "\nalready searched there\n" + table(searches.map((s) => [`  ${s.id}`, s.result, truncate(s.question, 60), s.scope.years ?? ""])) : undefined, lessons.length ? "\nlessons for these record sets\n" + lessons.map((l) => `  ${l.id} ${l.rule}`).join("\n") : undefined, ...t.notes.map((n) => `note   ${n.text}`));
 }
 function stateChange(tree, ref, state, fields, reason, verb) {
     const id = normId(ref, "task");
@@ -97,8 +118,12 @@ function stateChange(tree, ref, state, fields, reason, verb) {
         if (t.state === "done" && state !== "open")
             throw new UsageError(`${id} is already done`);
         const next = { ...t, state, ...fields };
-        if (state !== "parked")
+        if (state !== "parked") {
             delete next.parkedUntil;
+            delete next.parkedReason;
+        }
+        else if (reason)
+            next.parkedReason = reason;
         if (state !== "waiting") {
             delete next.waitingOn;
             delete next.awaits;
@@ -401,10 +426,22 @@ register({
     group: "tasks",
     tree: true,
     writes: true,
+    description: "--answer: what the user found or decided for a task that waited for them (a link, a book's number) — kept on\nthe task with what it asked, so the agent reads both in its brief.",
     args: [{ name: "task", description: "task ID", required: true }],
-    run(ctx, { args }) {
+    options: [{ name: "answer", type: "string", value: "<text>", description: "the user's answer to what the task waited for" }],
+    examples: ["strom task wake T0002", 'strom task wake T0003 --answer "https://archive.example.org/book/5359"'],
+    run(ctx, { args, opts }) {
         const tree = ctx.tree();
-        const t = stateChange(tree, args[0], "open", {}, undefined, "wake");
+        const id = normId(args[0], "task");
+        const answer = typeof opts.answer === "string" && opts.answer.trim() ? opts.answer.trim() : undefined;
+        const t = tree.withTreeLock(() => {
+            const before = requireRecord(tree, id, "task");
+            // an answer is to what the task waits for: one that waits no more (done, dropped, taken up) is left as it is
+            if (answer && before.state !== "waiting")
+                throw new UsageError(`${id} does not wait for the user (it is ${before.state}) — the answer is not needed there`, { hint: `strom task show ${id}` });
+            const note = answer ? makeNote(tree, phrase(tree.lang, "task.answer", { asked: truncate(before.waitingOn || before.what, 120), answer })) : undefined;
+            return stateChange(tree, id, "open", note ? { notes: [...before.notes, note] } : {}, undefined, "wake");
+        });
         return { text: written(tree), data: { task: t } };
     },
 }, {

package/dist/core/browser.js

@@ -41,6 +41,56 @@ export const CHROME_ALLOW = [
 export const CHROME_DENY = ["file_upload", "upload_image", "shortcuts_execute", "gif_creator", "browser_batch"].map((t) => `mcp__claude-in-chrome__${t}`);
 /** The permission rule of Claude in Chrome for one site. */
 export const chromeDomain = (host) => `ClaudeInChromeDomain(${host.replace(/^\*\./, "").toLowerCase()})`;
+/** Claude in Chrome in the Chrome Web Store: the extension Claude Code's browser tools work through. */
+export const CLAUDE_IN_CHROME_ID = "fcoeoabgfenejglbffodgkkbkcdhcgfn";
+export const CLAUDE_IN_CHROME_URL = `https://chromewebstore.google.com/detail/${CLAUDE_IN_CHROME_ID}`;
+/** The folders of the browsers' profiles (Chrome, Edge, Brave take extensions from the Chrome Web Store). */
+function browserDataDirs(env, platform) {
+    const home = userHome(env);
+    if (platform === "darwin") {
+        const base = path.join(home, "Library", "Application Support");
+        return [
+            { browser: "Chrome", dir: path.join(base, "Google", "Chrome") },
+            { browser: "Edge", dir: path.join(base, "Microsoft Edge") },
+            { browser: "Brave", dir: path.join(base, "BraveSoftware", "Brave-Browser") },
+        ];
+    }
+    if (platform === "win32") {
+        const base = env.LOCALAPPDATA ?? path.join(home, "AppData", "Local");
+        return [
+            { browser: "Chrome", dir: path.join(base, "Google", "Chrome", "User Data") },
+            { browser: "Edge", dir: path.join(base, "Microsoft", "Edge", "User Data") },
+            { browser: "Brave", dir: path.join(base, "BraveSoftware", "Brave-Browser", "User Data") },
+        ];
+    }
+    const base = env.XDG_CONFIG_HOME ?? path.join(home, ".config");
+    return [
+        { browser: "Chrome", dir: path.join(base, "google-chrome") },
+        { browser: "Edge", dir: path.join(base, "microsoft-edge") },
+        { browser: "Brave", dir: path.join(base, "BraveSoftware", "Brave-Browser") },
+    ];
+}
+/**
+ * Is Claude in Chrome installed — in which browsers? Only the extension's folder in the profiles is looked for (its
+ * name), nothing else of the browser is read. Whether it is signed in and connected strom cannot see.
+ */
+export function claudeInChrome(env, platform = process.platform) {
+    const browsers = [];
+    const extension = [];
+    for (const { browser, dir } of browserDataDirs(env, platform)) {
+        let profiles;
+        try {
+            profiles = fs.readdirSync(dir).filter((n) => n === "Default" || /^Profile \d+$/u.test(n));
+        }
+        catch {
+            continue;
+        }
+        browsers.push(browser);
+        if (profiles.some((p) => fs.existsSync(path.join(dir, p, "Extensions", CLAUDE_IN_CHROME_ID))))
+            extension.push(browser);
+    }
+    return { browsers, extension };
+}
 /** The folder a browser saves downloads into by default: ~/Downloads, or what the desktop names it (Linux). */
 export function downloadsDir(env, platform = process.platform) {
     const home = userHome(env);

package/dist/core/config.js

@@ -54,6 +54,7 @@ export const SETTINGS = [
     // Read from the config file only — no variable, no flag, no tree: nothing an agent can set.
     { key: "agent.permissions", env: "", tree: false, kind: "choice", choices: PERMISSION_LEVELS, description: "what the agent may do without asking you: ask (what the tree allows; anything else it asks), auto (default: what the tree allows; anything else the agent's own review decides, asking only when risky), full (everything but what the tree denies) — only you raise it" },
     { key: "agent.where", env: "STROM_AGENT_WHERE", tree: false, kind: "choice", choices: ["app", "terminal"], description: "where you talk with the agent: app (its desktop app — the easiest), terminal (its CLI) — unset: the app when it is installed" },
+    { key: "agent.remote", env: "", tree: false, kind: "choice", choices: ["on", "off"], description: "the Claude Code sessions strom starts (strom run, strom chat in the terminal) with Remote Control: on — follow and steer them from claude.ai or the Claude app on your phone; off (default) — only you turn it on" },
     { key: "updates", env: "STROM_UPDATES", tree: false, kind: "choice", choices: ["check", "off"], description: "look for new versions of strom: check (default — at most once a day, one small file from the project's releases; strom says so, strom update installs it) or off" },
     { key: "strom.app", env: "", tree: false, kind: "choice", choices: ["yes", "no"], description: "you use the Strom app: yes (strom says which file to import into it), no (strom never mentions it) — unset: strom notices it itself" },
     { key: "strom.app.url", env: "STROM_APP_URL", tree: false, kind: "url", description: "another copy of the Strom app to open instead of https://stromapp.info/run/ — its beta (https://beta.stromapp.info/run/), its development (http://127.0.0.1:8080/); installed from a browser, that copy opens as its own app" },
@@ -69,6 +70,7 @@ const FIELDS = {
     "browser.downloads": "browserDownloads",
     "agent.permissions": "agentPermissions",
     "agent.where": "agentWhere",
+    "agent.remote": "agentRemote",
     "strom.app": "stromApp",
     "strom.app.url": "stromAppUrl",
     "main.person": "mainPerson",
@@ -334,6 +336,10 @@ export class Settings {
     downloads() {
         return String(this.resolve("browser.downloads")?.value ?? downloadsDir(this.env));
     }
+    /** Claude Code sessions strom starts with Remote Control (agent.remote: on). */
+    agentRemote() {
+        return this.resolve("agent.remote")?.value === "on";
+    }
     /** Where the user wants to talk with the agent, if they said (env, else the config); see whereToTalk. */
     agentWhere() {
         const r = this.resolve("agent.where");

package/dist/core/hooks.js

@@ -0,0 +1,210 @@
+// Hooks: the user's programs told of what was saved into a research. After
+// every commit of a research, strom starts each hook the user turned on
+// (`strom hook on <name>`) in the background — never waiting for it, never
+// failing because of it — with the operations that commit saved: a person
+// added, a fact, a task done, a session closed… A hook filters them
+// (`events` in hook.json, or itself), may read more through strom (`strom
+// person card P0002`) and does with it what the user wants: a message to
+// their phone, a log, a backup.
+//
+// A hook is a folder in the plugins folder, <shared>/plugins/hooks/<name>/,
+// with hook.json ({"interface": 1, "command": [...], "events": [...]}) and its
+// program (interface: assets/plugins/hooks/README.md, copied next to the
+// hooks). The event comes as one JSON document on the program's stdin; what it
+// prints goes to hook.log in its folder. A hook runs only when the user turned
+// it on — a folder an agent put there does nothing by itself.
+import fs from "node:fs";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { StromError, UsageError } from "./errors.js";
+import { NAME_RE, pluginsDir } from "./connector.js";
+import { readAsset } from "./assets.js";
+export const HOOK_INTERFACE = 1;
+const MANIFEST = "hook.json";
+/** How long `strom hook test` waits for a hook. */
+const DEFAULT_TIMEOUT_S = 60;
+/** Event files older than this are cleared away (a hook reads its own at once). */
+const KEEP_MS = 24 * 3600_000;
+/** The hook's output, appended; cut to its last part when it grows past this. */
+const LOG_MAX = 1024 * 1024;
+export function hooksDir(shared) {
+    return path.join(pluginsDir(shared), "hooks");
+}
+/** The hooks folder with its interface (refreshed). */
+export function ensureHooksDir(shared) {
+    const dir = hooksDir(shared);
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+        const text = readAsset("plugins", "hooks", "README.md");
+        const file = path.join(dir, "README.md");
+        let old;
+        try {
+            old = fs.readFileSync(file, "utf8");
+        }
+        catch {
+            old = undefined;
+        }
+        if (text !== undefined && old !== text)
+            fs.writeFileSync(file, text);
+    }
+    catch (err) {
+        if (!["EACCES", "EPERM", "EROFS"].includes(err?.code ?? ""))
+            throw err;
+    }
+    return dir;
+}
+export function listHooks(shared) {
+    let names = [];
+    try {
+        names = fs
+            .readdirSync(hooksDir(shared), { withFileTypes: true })
+            .filter((d) => d.isDirectory() && NAME_RE.test(d.name))
+            .map((d) => d.name);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names.sort()) {
+        try {
+            out.push(loadHook(shared, name));
+        }
+        catch {
+            // not a hook (yet): `strom hook test <name>` says why
+        }
+    }
+    return out;
+}
+export function loadHook(shared, name) {
+    if (!NAME_RE.test(name))
+        throw new UsageError(`invalid hook name "${name}"`, { hint: "lowercase letters, digits and dashes, e.g. telegram" });
+    const dir = path.join(hooksDir(shared), name);
+    const file = path.join(dir, MANIFEST);
+    if (!fs.existsSync(file))
+        throw new StromError(`no hook "${name}" (no ${file})`, { hint: `the hooks here: strom hook list — a hook is a folder in ${hooksDir(shared)} with ${MANIFEST}` });
+    let m;
+    try {
+        m = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (err) {
+        throw new StromError(`hook "${name}": ${MANIFEST} is not valid JSON (${err.message})`);
+    }
+    if (m.interface !== HOOK_INTERFACE)
+        throw new StromError(`hook "${name}" is for interface ${m.interface}, this strom knows ${HOOK_INTERFACE}`, {
+            hint: m.interface > HOOK_INTERFACE ? "update strom: strom update" : `see ${path.join(hooksDir(shared), "README.md")}`,
+        });
+    if (!Array.isArray(m.command) || !m.command.length || !m.command.every((c) => typeof c === "string" && c))
+        throw new StromError(`hook "${name}": "command" must be a list of strings, e.g. ["node", "hook.ts"]`);
+    if (m.events !== undefined && (!Array.isArray(m.events) || !m.events.every((e) => typeof e === "string" && e)))
+        throw new StromError(`hook "${name}": "events" must be a list like ["person.add", "session.*"]`);
+    return { name, dir, manifest: m };
+}
+/** Does the hook want this operation? "*" all, "person.*" a kind, "person.add" one. */
+export function wants(m, op) {
+    return (m.events ?? ["*"]).some((p) => p === "*" || p === op || (p.endsWith(".*") && op.startsWith(p.slice(0, -1))));
+}
+/** The operations of a commit the hook wants, or none. */
+export function forHook(hook, events) {
+    return events.filter((e) => wants(hook.manifest, e.op));
+}
+function program(hook) {
+    const [cmd, ...args] = hook.manifest.command;
+    return { cmd: cmd === "node" ? process.execPath : cmd, args };
+}
+function hookEnv(env, hook, payload, file) {
+    return {
+        ...env,
+        STROM_HOOK: hook.name,
+        STROM_TREE: payload.tree.root,
+        STROM_LANG: payload.tree.lang,
+        STROM_EVENT_FILE: file,
+        // what it runs of strom reads the research the event came from, as the user would
+        STROM_NONINTERACTIVE: "1",
+    };
+}
+/** The event as a file (the hook's stdin, and STROM_EVENT_FILE); old ones are cleared away. */
+function eventFile(hook, payload) {
+    const dir = path.join(hook.dir, ".events");
+    fs.mkdirSync(dir, { recursive: true });
+    try {
+        for (const f of fs.readdirSync(dir)) {
+            const p = path.join(dir, f);
+            if (Date.now() - fs.statSync(p).mtimeMs > KEEP_MS)
+                fs.rmSync(p, { force: true });
+        }
+    }
+    catch {
+        // another process cleared it
+    }
+    const file = path.join(dir, `${payload.at.replace(/[:.]/g, "-")}-${process.pid}-${Math.random().toString(36).slice(2, 8)}.json`);
+    fs.writeFileSync(file, JSON.stringify(payload, null, 2) + "\n");
+    return file;
+}
+/** Its log, cut to its last part when it has grown too big. */
+function logFd(hook) {
+    const file = path.join(hook.dir, "hook.log");
+    try {
+        if (fs.statSync(file).size > LOG_MAX) {
+            const tail = fs.readFileSync(file).subarray(-LOG_MAX / 2);
+            fs.writeFileSync(file, tail);
+        }
+    }
+    catch {
+        // no log yet
+    }
+    return fs.openSync(file, "a");
+}
+/**
+ * Tell the hooks the user turned on what a commit saved — in the background: strom neither waits for them nor
+ * fails because of them. A hook's own writes (it may run strom) tell no hook again.
+ */
+export function fireHooks(shared, names, env, payload) {
+    if (!shared || !names?.length || !payload.events.length || env.STROM_HOOK)
+        return;
+    for (const name of names) {
+        try {
+            const hook = loadHook(shared, name);
+            const events = forHook(hook, payload.events);
+            if (!events.length)
+                continue;
+            const full = { ...payload, hook: name, events };
+            const file = eventFile(hook, full);
+            let input;
+            let log;
+            try {
+                input = fs.openSync(file, "r");
+                log = logFd(hook);
+                const { cmd, args } = program(hook);
+                const child = spawn(cmd, args, { cwd: hook.dir, env: hookEnv(env, hook, full, file), stdio: [input, log, log], detached: true, windowsHide: true });
+                child.on("error", () => undefined);
+                child.unref();
+            }
+            finally {
+                // the child has its own copies; ours are closed whatever happened
+                for (const fd of [input, log])
+                    if (fd !== undefined)
+                        fs.closeSync(fd);
+            }
+        }
+        catch {
+            // a hook that is gone or broken never stops the research: strom hook test <name> says why
+        }
+    }
+}
+/** Run a hook now and wait for it (strom hook test): what it printed and how it ended. */
+export function runHookNow(hook, env, payload) {
+    const file = eventFile(hook, payload);
+    const { cmd, args } = program(hook);
+    const r = spawnSync(cmd, args, {
+        cwd: hook.dir,
+        env: hookEnv(env, hook, payload, file),
+        input: fs.readFileSync(file),
+        encoding: "utf8",
+        timeout: (hook.manifest.timeout ?? DEFAULT_TIMEOUT_S) * 1000,
+        windowsHide: true,
+    });
+    const output = `${r.stdout ?? ""}${r.stderr ?? ""}`.trim();
+    if (r.error)
+        return { status: null, output, error: r.error.code === "ETIMEDOUT" ? `no end within ${hook.manifest.timeout ?? DEFAULT_TIMEOUT_S} s` : r.error.message };
+    return { status: r.status, output };
+}

package/dist/core/media.js

@@ -64,22 +64,36 @@ const MIME = {
 export function mimeOf(file) {
     return MIME[path.extname(file).toLowerCase()] ?? "application/octet-stream";
 }
-/** Every file under the given paths (folders recursively), hidden files skipped. */
+/**
+ * Every file under the given paths (folders recursively), hidden files skipped. What is inside a folder but cannot be
+ * read (a broken link or alias, a folder the system keeps to itself) is left out; the paths given must be there.
+ */
 export function collectFiles(paths) {
     const out = [];
-    const walk = (p) => {
+    const walk = (p, given) => {
         const base = path.basename(p);
-        if (base.startsWith(".") || base === "Thumbs.db" || base === "desktop.ini")
+        if (!given && (base.startsWith(".") || base === "Thumbs.db" || base === "desktop.ini"))
+            return;
+        let st;
+        let names = [];
+        try {
+            st = fs.statSync(p);
+            if (st.isDirectory())
+                names = fs.readdirSync(p).sort();
+        }
+        catch (err) {
+            if (given)
+                throw err;
             return;
-        const st = fs.statSync(p);
+        }
         if (st.isDirectory())
-            for (const e of fs.readdirSync(p).sort())
-                walk(path.join(p, e));
+            for (const e of names)
+                walk(path.join(p, e), false);
         else if (st.isFile())
             out.push(p);
     };
     for (const p of paths)
-        walk(p);
+        walk(p, true);
     return out;
 }
 const digitGroups = (file) => path.basename(file, path.extname(file)).match(/\d+/g) ?? [];

package/dist/core/phrases.js

@@ -76,6 +76,7 @@ export const PHRASES = {
     "intake.done.imported": "the leads are checked for obvious mistakes (duplicates, impossible dates) and the first locate/link tasks exist",
     "intake.done.read": "what it adds to the tree is entered as leads citing it (strom source add … --kind family-tree --form authored --input {id}) — or the input is skipped with a reason (strom input skip {id} --reason …)",
     "intake.done": "every person and fact in it is recorded (a source if it is an original document, leads otherwise) and cited — or the input is skipped with a reason (strom input skip I… --reason …)",
+    "task.answer": "The user answered (to: {asked}): {answer}",
 };
 const catalogs = new Map();
 /**

package/dist/core/relocate.js

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

package/dist/core/tree.js

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

package/dist/runners/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/package.json

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