strom-research 1.1.1 → 1.3.0

package/dist/commands/session.js

@@ -9,7 +9,7 @@ import path from "node:path";
 import { register } from "../cli/registry.js";
 import { ui } from "../cli/ui.js";
 import { lines, table, truncate } from "../cli/format.js";
-import { UsageError, StromError } from "../core/errors.js";
+import { NeedsConsentError, UsageError, StromError } from "../core/errors.js";
 import { closeSession, currentSession, openSessions, othersAtWork, sessionNote, startSession } from "../core/session.js";
 import { buildBrief } from "../brief/brief.js";
 import { DEFAULT_BUDGET, DEFAULT_RUN_MINUTES, Settings } from "../core/config.js";
@@ -25,8 +25,10 @@ import { syncAgentFiles } from "../agents/files.js";
 import { setTreeSetting } from "./setup.js";
 import { RUNNERS } from "../runners/index.js";
 import { PROFILES } from "../agents/profiles.js";
-import { AGENTS, detectAgent, which } from "../core/which.js";
+import { AGENTS, detectAgent, isAgent, which } from "../core/which.js";
+import { askGate, ensureGatesDir, loadGate } from "../core/gate.js";
 import { keepAwake } from "../core/awake.js";
+import { deadlineOf, WRAP_UP_MS } from "../core/clock.js";
 import { stromLauncher } from "../core/self.js";
 import { phrase } from "../core/phrases.js";
 import { enterWorker, runAlive, runsAtWork } from "../core/workers.js";
@@ -35,6 +37,7 @@ import { guard } from "../core/guard.js";
 import { hasErrors } from "../core/check.js";
 import { Tree } from "../core/tree.js";
 import { treeBrowserConnectors } from "../core/connector.js";
+import { browserNote } from "./connectors.js";
 import { reviewProposals } from "../core/review.js";
 function written(tree) {
     return lines(...tree.written.map((o) => o.summary), tree.dryRun ? "(dry run — nothing written)" : undefined);
@@ -161,7 +164,7 @@ register({
     tree: true,
     run(ctx) {
         const all = ctx.tree().list("session").slice().reverse();
-        const cost = (s) => (s.metrics?.costUsd !== undefined ? `$${s.metrics.costUsd.toFixed(2)}` : "");
+        const cost = (s) => costText(s.metrics);
         return {
             text: all.length ? table(all.map((s) => [s.id, s.state, s.task ?? "", s.started.slice(0, 16).replace("T", " "), cost(s), truncate(s.summary ?? "", 70)])) : "no sessions yet → strom session start",
             data: { sessions: all },
@@ -186,7 +189,7 @@ register({
                     m.inputTokens && `${m.inputTokens} in`,
                     m.outputTokens && `${m.outputTokens} out`,
                     m.cacheReadTokens && `${m.cacheReadTokens} cache read`,
-                    m.costUsd !== undefined && `$${m.costUsd.toFixed(2)}`,
+                    costText(m),
                     s.ended && `${Math.max(1, Math.round((Date.parse(s.ended) - Date.parse(s.started)) / 60000))} min`,
                     m.denied && `${m.denied} refused by permissions`,
                 ]
@@ -210,7 +213,7 @@ register({
         const tree = ctx.tree();
         const s = currentSession(tree, ctx.env);
         const task = args[0] ? requireRecord(tree, args[0], "task") : s?.task ? tree.get(s.task) : taskQueue(tree, { strategy: ctx.settings.strategy(tree.config) })[0];
-        const b = buildBrief(tree, { ...(task ? { task } : {}), ...(s ? { session: s } : {}), budget: ctx.settings.number("brief.budget", tree.config, DEFAULT_BUDGET), shared: ctx.settings.shared()?.value });
+        const b = buildBrief(tree, { ...(task ? { task } : {}), ...(s ? { session: s, deadline: deadlineOf(ctx.env) } : {}), budget: ctx.settings.number("brief.budget", tree.config, DEFAULT_BUDGET), shared: ctx.settings.shared()?.value });
         if (opts.stats)
             return {
                 text: lines(table(b.sections.map((x) => [x.name, `${x.tokens}`, x.cut ? "cut" : ""])), `total ~${b.total} tokens of ${b.budget}`),
@@ -381,20 +384,30 @@ register({
     description: "One session by default; with --until, session after session until that time. The agent works headless with\n" +
         "the tree's permissions (anything else is denied), or with the terminal (--interactive). Stops at the\n" +
         "subscription limit, when the queue is empty, or at --until (a session already running finishes, within\n" +
-        "--minutes). A session longer than --minutes is stopped (its task goes back to the queue); a task that comes\n" +
-        "back twice in a row with nothing recorded is parked. --task picks the tasks (one session each, in that order;\n" +
-        "one done or held by another agent meanwhile is left out). Arguments after -- go to the agent CLI unchanged.",
+        "--minutes). The agent knows when its session is stopped (the brief; strom's output counts down its last\n" +
+        "10 minutes, a short session its last quarter); at --minutes it is stopped, and Claude Code, Codex and OpenCode\n" +
+        "get 5 minutes more to write down what they found and close (an unfinished task goes back to the queue); a task\n" +
+        "that comes back twice in a row with nothing recorded is parked. --task picks the tasks (one session each, in that order;\n" +
+        "one done or held by another agent meanwhile is left out). --loop: session after session for as long as there\n" +
+        "is work. A gate (setting run.gate, or --gate; plugins/gates/<name>) is asked before each session of --loop and\n" +
+        "--until: go on, wait (the run waits and asks again) or stop — the user's condition, e.g. the subscription's room\n" +
+        "(strom gate list). Tasks started otherwise (one, --max, --task) are the user's choice: the gate is asked once,\n" +
+        "and when it would not start, the user is asked whether to start anyway (an agent: a window of the system).\n" +
+        "Arguments after -- go to the agent CLI unchanged.",
     options: [
         { name: "task", type: "string", multiple: true, value: "<T…>", description: "work on these tasks, in this order (repeatable or T0003,T0007; default: the next one of the queue)" },
         { name: "research", type: "string", value: "<G…>", description: "only tasks of this research" },
         { name: "max", type: "string", value: "<n>", description: "at most n sessions (default 1; with --until, no limit)" },
         { name: "until", type: "string", value: "<HH:MM>", description: "start no session after this time" },
+        { name: "loop", type: "boolean", description: "session after session for as long as there is work (and the gate lets it)" },
+        { name: "gate", type: "string", value: "<name [n]>", description: 'ask this gate before each session, with what it is given, e.g. "claude-usage 20" (default: run.gate)' },
+        { name: "no-gate", type: "boolean", description: "ask no gate this time (only you: an agent cannot)" },
         { name: "minutes", type: "string", value: "<n>", description: `time limit of one session (default: run.minutes, ${DEFAULT_RUN_MINUTES})` },
         { name: "budget", type: "string", value: "<tokens>", description: `brief size (default: brief.budget, ${DEFAULT_BUDGET})` },
         { name: "model", type: "string", value: "<model>", description: "model of the main agent (default: model.lead)" },
         { name: "interactive", type: "boolean", description: "give the agent the terminal (you can talk to it)" },
     ],
-    examples: ["strom run", "strom run --max 3 --until 23:00", "strom run --task T0003,T0007", "strom run --interactive", "strom run --agent codex", "strom run --minutes 30 -- --add-dir ~/Scans"],
+    examples: ["strom run", "strom run --max 3 --until 23:00", "strom run --loop", "strom run --task T0003,T0007", "strom run --interactive", "strom run --agent codex", "strom run --minutes 30 -- --add-dir ~/Scans"],
     run: async (ctx, { opts, extra }) => {
         const root = ctx.tree().root;
         const treeCfg = ctx.tree().config;
@@ -408,10 +421,11 @@ register({
         const until = parseUntil(opts.until);
         // Tasks the user picked: one session each, in their order (then the queue, when --max asks for more).
         const picked = csvOpt(opts.task).map((id) => requireRecord(Tree.open(root, ctx.env), id, "task").id);
-        const max = opts.max === undefined ? (picked.length ? picked.length : until ? Infinity : 1) : Number(opts.max);
+        const max = opts.max === undefined ? (picked.length ? picked.length : until || opts.loop ? Infinity : 1) : Number(opts.max);
         if (max !== Infinity && (!Number.isInteger(max) || max < 1))
             throw new UsageError("--max must be a positive number");
         const minutes = ctx.settings.number("run.minutes", treeCfg, DEFAULT_RUN_MINUTES);
+        const gate = runGate(ctx, opts);
         const budget = ctx.settings.number("brief.budget", treeCfg, DEFAULT_BUDGET);
         // Each run has a name of its own (as a conversation does): several work side by side, never on one task.
         const worker = `run-${process.pid}-${Date.now().toString(36)}`;
@@ -419,10 +433,12 @@ register({
         // Present in the tree for the others at work (conversations with agents): strom shows who works.
         const beside = runsAtWork(root);
         const leave = enterWorker(root, worker, `${PROFILES[runnerId]?.name ?? runnerId} on its own`);
-        const stopAwake = keepAwake(ctx.env);
+        let stopAwake = keepAwake(ctx.env);
         // Progress goes to stderr when stdout carries JSON.
         const out = (s) => (ctx.json ? ctx.io.stderr : ctx.io.stdout)(s + "\n");
         const report = [];
+        // What the gate answered, for the record of the run.
+        const gates = [];
         // Why the run stopped: a code for the exit status and for data, words for the user (their language).
         const lang = Tree.open(root, runEnv).lang;
         let stopCode = "done";
@@ -464,8 +480,18 @@ register({
                 out(ui(lang, "ui.run.browser", { name: c.manifest.title ?? c.name, hosts: c.manifest.hosts.join(", ") }));
             if (browser.length && /haiku/i.test(models.lead ?? ""))
                 out(ui(lang, "ui.run.browser.model", { model: models.lead }));
+            // Archives through the browser with an agent that has no browser tools, or without the extension: said before it starts.
+            const browserSays = browserNote(ctx, Tree.open(root, runEnv), runnerId);
+            if (browserSays)
+                out(browserSays);
             if (permissions === "full")
                 out(ui(lang, "ui.run.full"));
+            // The gate holds a run that goes on by itself (--loop, --until). Tasks the user starts themselves (one, --max n,
+            // --task) are their choice: the gate is asked once, and when it would not start, the user decides.
+            const gateHolds = Boolean(opts.loop || until);
+            let gateAnswered = false;
+            if (gate)
+                out(ui(lang, gateHolds ? "ui.run.gate" : "ui.run.gate.once", { name: gate.manifest.title ?? gate.name }));
             for (let i = 0; i < max; i++) {
                 if (stop.signal.aborted) {
                     stopCode = "user";
@@ -500,9 +526,49 @@ register({
                     stopCode = "empty";
                     break;
                 }
+                // The user's condition, between sessions only: go on, wait and ask again, or stop — in a run that goes on by
+                // itself. Tasks the user started themselves: asked once, and the user decides when it would not start.
+                if (gate && !gateAnswered) {
+                    const said = askGate(gate, runEnv, { tree: root, lang, agent: runnerId, model: models.lead, sessions: report.length, costUsd: report.reduce((a, r) => a + (r.costUsd ?? 0), 0), nextTask: task.id });
+                    const answer = { at: new Date().toISOString(), verdict: said.verdict, ...(said.reason ? { reason: said.reason } : {}) };
+                    gates.push(answer);
+                    const name = gate.manifest.title ?? gate.name;
+                    if (!gateHolds) {
+                        gateAnswered = true;
+                        if (said.verdict !== "go") {
+                            if (!(await startAnyway(ctx, name, gateReason(said, lang), lang))) {
+                                stopCode = "gate.declined";
+                                stopValues = { name, reason: gateReason(said, lang) };
+                                break;
+                            }
+                            answer.anyway = true;
+                        }
+                    }
+                    else if (said.verdict === "stop" || said.verdict === "error") {
+                        stopCode = said.verdict === "stop" ? "gate" : "gate.error";
+                        stopValues = { name, reason: said.reason ?? "" };
+                        break;
+                    }
+                    else if (said.verdict === "wait") {
+                        const at = Date.now() + said.waitMs;
+                        if (until && at > until) {
+                            stopCode = "time";
+                            break;
+                        }
+                        out(ui(lang, "ui.run.gate.wait", { at: new Date(at).toLocaleString(lang, { weekday: "short", hour: "2-digit", minute: "2-digit" }), reason: said.reason ?? "" }));
+                        // nothing to do meanwhile: the computer may sleep
+                        stopAwake();
+                        await pause(at - Date.now(), stop.signal);
+                        stopAwake = keepAwake(ctx.env);
+                        i--; // this was no session: ask again, with the queue as it is then
+                        continue;
+                    }
+                }
                 const session = startSession(tree, { task, ...(research ? { research: research.id } : {}), runner: runnerId, ...(models.lead ? { model: models.lead } : {}) });
                 commitNow(tree, `${session.id} session started on ${task.id}`);
-                const brief = buildBrief(tree, { task, session, budget, shared: ctx.settings.shared()?.value });
+                // When the agent is stopped: it knows (the brief, strom's reminders near the end), and gets a few minutes more to write down what it found.
+                const deadline = Date.now() + minutes * 60_000;
+                const brief = buildBrief(tree, { task, session, budget, shared: ctx.settings.shared()?.value, deadline });
                 const briefFile = path.join(root, ".strom", "briefs", `${session.id}.md`);
                 fs.mkdirSync(path.dirname(briefFile), { recursive: true });
                 fs.writeFileSync(briefFile, brief.text);
@@ -514,6 +580,8 @@ register({
                 const env = {
                     ...prependPath(runEnv, bin),
                     STROM_SESSION: session.id,
+                    STROM_DEADLINE: new Date(deadline).toISOString(),
+                    STROM_MINUTES: String(minutes),
                     ...(opts.interactive ? {} : { STROM_NONINTERACTIVE: "1" }),
                 };
                 const result = await runner.run({
@@ -525,11 +593,17 @@ register({
                     name: ["Strom", tree.config.name, tree.get(task.research ?? research?.id ?? "")?.name, `${truncate(task.what, 50)} (${task.id})`].filter(Boolean).join(" · "),
                     logFile: path.join(root, ".strom", "runs", `${session.id}.log`),
                     timeoutMs: minutes * 60_000,
+                    wrapUp: {
+                        ms: WRAP_UP_MS,
+                        prompt: `Time is up: strom stopped you at the session's limit (${minutes} min). You have ${WRAP_UP_MS / 60_000} minutes, no more. Do not open anything new: ` +
+                            "record in strom what you found and have not recorded yet (facts, sources, the images searched, in vain too), " +
+                            `then \`strom session close --continue --summary "…" --next "exactly where you stopped"\` (or finish the task, if it is done).`,
+                    },
                     settingsFile: path.join(root, ".claude", "settings.json"),
                     shared: ctx.settings.shared()?.value,
                     ...(models.lead ? { model: models.lead } : {}),
                     ...(opts.interactive ? { interactive: true } : {}),
-                    ...(runnerId === "claude" ? { chrome: browser.length > 0, permissions } : {}),
+                    ...(runnerId === "claude" ? { chrome: browser.length > 0, permissions, remote: ctx.settings.agentRemote() } : {}),
                     ...(extra?.length ? { extraArgs: extra } : {}),
                     onProgress: (l) => out(`  · ${l}`),
                     signal: stop.signal,
@@ -555,10 +629,11 @@ register({
                 const back = after.get(task.id);
                 const idle = back && back.state === "open" ? idleSessions(after, task.id) : 0;
                 if (idle >= MAX_IDLE_SESSIONS) {
-                    update(after, task.id, "task", (t) => ({ ...t, state: "parked" }), {
+                    const why = `${idle} sessions in a row recorded nothing for it — needs a look (strom task show ${task.id})`;
+                    update(after, task.id, "task", (t) => ({ ...t, state: "parked", parkedReason: why }), {
                         op: "task.park",
                         summary: `${task.id} park: ${idle} sessions without a result`,
-                        reason: `${idle} sessions in a row recorded nothing for it — needs a look (strom task show ${task.id})`,
+                        reason: why,
                     });
                     out(ui(lang, "ui.run.parked", { task: task.id, n: idle }));
                 }
@@ -567,7 +642,7 @@ register({
                 const geds = writeGedcoms(ctx, after);
                 const committed = commitNow(after, `${s.id} ${s.state}: ${truncate(s.summary ?? "", 60)} · ${geds.map((g) => after.relative(g.file)).join(", ")}`);
                 report.push({ session: s.id, task: task.id, outcome: result.outcome, ...(s.summary ? { summary: s.summary } : {}), ...(result.metrics.costUsd !== undefined ? { costUsd: result.metrics.costUsd } : {}) });
-                out(`■ ${s.id} ${s.state} · ${result.outcome}${result.metrics.costUsd !== undefined ? ` · $${result.metrics.costUsd.toFixed(2)}` : ""}${s.summary ? ` · ${truncate(s.summary, 80)}` : ""}`);
+                out(`■ ${s.id} ${s.state} · ${result.outcome}${costText(result.metrics) ? ` · ${costText(result.metrics)}` : ""}${s.summary ? ` · ${truncate(s.summary, 80)}` : ""}`);
                 if (result.denied?.length)
                     out(ui(lang, "ui.run.denied", { n: result.denied.length, what: result.denied.slice(0, 3).join(" · ") }));
                 if (!committed) {
@@ -611,11 +686,79 @@ register({
         const reason = ui(lang, `ui.run.stop.${stopCode}`, stopValues);
         return {
             text: lines(ui(lang, "ui.run.summary", { n: report.length, reason }), waiting ? `\n${waiting}` : undefined),
-            data: { sessions: report, stopped: reason, stop: stopCode },
-            exitCode: ["failed", "problems", "auth", "denied"].includes(stopCode) ? 1 : 0,
+            data: { sessions: report, stopped: reason, stop: stopCode, ...(gate ? { gate: { name: gate.name, answers: gates } } : {}) },
+            exitCode: ["failed", "problems", "auth", "denied", "gate.error"].includes(stopCode) ? 1 : 0,
         };
     },
 });
+/**
+ * The gate this run asks (run.gate, or --gate), or none (--no-gate). Going round the user's gate is the user's
+ * decision: an agent asks them (a window of the system).
+ */
+function runGate(ctx, opts) {
+    const set = ctx.settings.runGate();
+    const asked = typeof opts.gate === "string" ? opts.gate : undefined;
+    if (opts["no-gate"]) {
+        if (set && isAgent(ctx.env))
+            ctx.requireHuman(`Let the agent work on its own without the gate "${set}"?`, "strom run --no-gate", "run.gate", ui(ctx.uiLang(), "ui.consent.gate.skip", { name: set }));
+        return undefined;
+    }
+    const name = asked ?? set;
+    if (!name)
+        return undefined;
+    if (asked && set && asked !== set && isAgent(ctx.env))
+        ctx.requireHuman(`Ask the gate "${asked}" instead of "${set}"?`, `strom run --gate ${asked}`, "run.gate", ui(ctx.uiLang(), "ui.consent.gate.set", { name: asked }));
+    const shared = ctx.settings.shared()?.value;
+    if (!shared)
+        throw new StromError("no shared folder, so no gates", { hint: "strom setup" });
+    ensureGatesDir(shared);
+    return loadGate(shared, name);
+}
+/** Why the gate would not start, for the user: its own words, else what it answered. */
+function gateReason(said, lang) {
+    return said.reason ?? ui(lang, said.verdict === "error" ? "ui.run.gate.noanswer" : said.verdict === "wait" ? "ui.run.gate.later" : "ui.run.gate.no");
+}
+/**
+ * Tasks the user started themselves while the gate would not start: the user decides — on a terminal, a question;
+ * asked by an agent, a window of the system (going round the user's condition is never the agent's decision). A run
+ * nobody can ask keeps to the gate.
+ */
+async function startAnyway(ctx, name, reason, lang) {
+    const question = ui(lang, "ui.run.gate.anyway", { name, reason });
+    if (ctx.interactive && !isAgent(ctx.env))
+        return ctx.confirm(question, false);
+    if (!isAgent(ctx.env))
+        return false;
+    try {
+        ctx.requireHuman(`Start the tasks although the condition "${name}" would not (${reason})?`, "strom run --no-gate", "run.gate", question);
+        return true;
+    }
+    catch (err) {
+        if (err instanceof NeedsConsentError)
+            throw err; // nobody to ask: the user runs it themselves
+        return false; // the user said no in the window
+    }
+}
+/** Wait, until the time or until the user stops the run. */
+function pause(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted || ms <= 0)
+            return resolve();
+        const t = setTimeout(done, ms);
+        signal.addEventListener("abort", done, { once: true });
+        function done() {
+            clearTimeout(t);
+            signal.removeEventListener("abort", done);
+            resolve();
+        }
+    });
+}
+/** What a session cost: "$1.20"; "$0.30+" or "cost unknown" when the agent was stopped before it said. */
+function costText(m) {
+    if (m?.costPartial)
+        return m.costUsd ? `$${m.costUsd.toFixed(2)}+` : "cost unknown";
+    return m?.costUsd !== undefined ? `$${m.costUsd.toFixed(2)}` : "";
+}
 /** How the user clears the agent's context, in the agent's own words. */
 const CLEAR = { claude: "/clear", codex: "/new", opencode: "/new" };
 /** The hint after a session in a conversation: the next task in a fresh context (images stay in a context and are paid on every turn). */

package/dist/commands/setup.js

@@ -19,6 +19,7 @@ import { installation, stromLauncher } from "../core/self.js";
 import { VERSION } from "../core/tree.js";
 import { installUpdate, isNewer, knownNewerVersion, latestVersion, newerNode, newerVersion } from "../core/update.js";
 import { desktopDir } from "../core/paths.js";
+import { planMove } from "../core/relocate.js";
 import { researchUrl, stromAppUrl, stromAppState } from "../core/stromapp.js";
 import { isInstalled } from "../agents/global.js";
 import { shortcutName } from "../cli/wizard.js";
@@ -30,12 +31,17 @@ import { NeedsInputError, StromError, UsageError } from "../core/errors.js";
 import { check } from "../core/check.js";
 import { assertIntact, verifyFull } from "../core/integrity.js";
 import { ensurePluginsDir } from "../core/connector.js";
-import { downloadsDir } from "../core/browser.js";
+import { ensureGatesDir, loadGate } from "../core/gate.js";
+import { ensureHooksDir } from "../core/hooks.js";
+import { claudeInChrome, CLAUDE_IN_CHROME_URL, downloadsDir } from "../core/browser.js";
+import { browserConnectors } from "../core/connector.js";
 export const SHARED_DIRS = ["media", "catalog", "tools", "cache", "inbox"];
 export function ensureShared(dir) {
     for (const d of SHARED_DIRS)
         fs.mkdirSync(path.join(dir, d), { recursive: true });
     ensurePluginsDir(dir);
+    ensureGatesDir(dir);
+    ensureHooksDir(dir);
 }
 register({
     path: ["setup"],
@@ -67,6 +73,12 @@ register({
                     set: `strom setup --home "${ctx.display(suggestedHome)}" --yes`,
                 },
             ]);
+        if (cfg.home && flags.home)
+            guardResearchFolder(ctx, "home", flags.home);
+        if (flags.shared)
+            guardResearchFolder(ctx, "shared", flags.shared);
+        if (flags.trees)
+            guardResearchFolder(ctx, "trees", flags.trees);
         let home = flags.home ? ctx.resolvePath(flags.home) : suggestedHome;
         let shared = flags.shared ? ctx.resolvePath(flags.shared) : undefined;
         let trees = flags.trees ? ctx.resolvePath(flags.trees) : undefined;
@@ -187,6 +199,19 @@ function diagnose(ctx) {
         if (model)
             add("model", "ok", model);
     }
+    // Archives through the browser: only Claude Code has browser tools, and they work through the Claude in Chrome extension.
+    const shared = ctx.settings.shared()?.value;
+    const viaBrowser = shared ? browserConnectors(ctx.env, shared) : [];
+    if (viaBrowser.length) {
+        const names = viaBrowser.map((c) => c.manifest.title ?? c.name).join(", ");
+        const ext = claudeInChrome(ctx.env).extension;
+        if (chosen !== "claude")
+            add("browser", "warn", t("ui.doc.browser.agent", { names, agent: PROFILES[chosen]?.name ?? chosen }), found.includes("claude") ? "strom agents use claude" : undefined);
+        else if (ext.length)
+            add("browser", "ok", t("ui.doc.browser.ok", { browsers: ext.join(", ") }));
+        else
+            add("browser", "warn", t("ui.doc.browser.noext", { names }), CLAUDE_IN_CHROME_URL);
+    }
     // For a person: the shortcut on the desktop, the Strom app.
     const desktop = desktopDir(ctx.env);
     const shortcut = [`${shortcutName(lang)}.command`, `${shortcutName(lang)}.lnk`, `${shortcutName(lang)}.cmd`, "strom-research.desktop"].some((f) => fs.existsSync(path.join(desktop, f)));
@@ -389,14 +414,45 @@ function raises(now, value) {
     return PERMISSION_LEVELS.indexOf(next) > PERMISSION_LEVELS.indexOf(now);
 }
 /** Change a user setting (the config file on this computer). */
+/**
+ * Where the research lives (home, trees, shared) changes only with the research moving along — which the person does in
+ * the wizard (strom setup in a terminal, the menu's settings). A folder set to another place with the research left in
+ * the old one would lose the trees from the list and the plugins and images from sight.
+ */
+function guardResearchFolder(ctx, key, next) {
+    const now = key === "home" ? ctx.settings.home()?.value : key === "trees" ? ctx.settings.trees()?.value : key === "shared" ? ctx.settings.shared()?.value : undefined;
+    // unset: back to the default under home (none for home itself)
+    const home = ctx.settings.home()?.value;
+    const target = next !== undefined ? ctx.resolvePath(next) : key === "shared" && home ? path.join(home, "shared") : key === "trees" ? home : undefined;
+    if (!now || (target && path.resolve(target) === path.resolve(now)))
+        return;
+    if (!planMove(now, target ?? now, []).content)
+        return;
+    throw new UsageError(`the research is in ${ctx.display(now)} — changing ${key} would leave it behind`, {
+        hint: "the user moves it: strom setup in their terminal (or the menu: Settings → the setup), which moves the trees and the shared folder along",
+    });
+}
 function setUserSetting(ctx, key, value) {
     const s = ctx.settings;
+    guardResearchFolder(ctx, key, value === undefined ? undefined : String(value));
     // Loosening the agent's permissions is the user's decision alone.
     if (key === "agent.permissions" && raises(s.agentPermissions(), value))
         ctx.requireHuman(`Let the agent ${value === "full" ? "do everything but what the tree's permissions deny" : "work on its own, asking only about risky steps"}, without asking?`, `strom config set agent.permissions ${value}`, "agent.permissions", ui(ctx.uiLang(), value === "full" ? "ui.consent.level.full" : "ui.consent.level.auto"));
+    // Sessions steered from elsewhere (Remote Control): the user's decision alone.
+    if (key === "agent.remote" && value === "on" && !s.agentRemote())
+        ctx.requireHuman("Start the Claude Code sessions with Remote Control (followed and steered from claude.ai or your phone)?", "strom config set agent.remote on", "agent.remote", ui(ctx.uiLang(), "ui.consent.remote"));
     // Asking before a connector runs is the user's safeguard: only they take it away.
     if (key === "connectors.consent" && value !== "on" && s.connectorsConsent())
         ctx.requireHuman("Let connectors run without asking you first?", `strom config set connectors.consent ${value ?? "off"}`, "connectors.consent", ui(ctx.uiLang(), "ui.consent.connectors.off"));
+    // The gate decides what working alone spends: set and taken away by the user alone.
+    if (key === "run.gate" && value !== s.runGate())
+        ctx.requireHuman(value ? `Let the gate "${value}" decide when the agent working alone goes on?` : `Remove the gate "${s.runGate()}" — the agent working alone no longer asks it?`, value ? `strom config set run.gate ${value}` : "strom config unset run.gate", "run.gate", ui(ctx.uiLang(), value ? "ui.consent.gate.set" : "ui.consent.gate.unset", { name: String(value ?? s.runGate()) }));
+    // a gate that is not there (or not a gate) is said now, not at the next run
+    const sh = s.shared()?.value;
+    if (key === "run.gate" && typeof value === "string" && sh) {
+        ensureGatesDir(sh);
+        loadGate(sh, value);
+    }
     writeStored(s.config, key, s.agent(ctx.hasTree() ? ctx.tree().config : undefined).value, value);
     s.save();
     if (key === "shared" && typeof value === "string")

package/dist/commands/sources.js

@@ -245,6 +245,23 @@ register({
     },
 });
 // ── repositories ───────────────────────────────────────────────────────────
+/** The website's host without "www.", lowercase: https://www.FamilySearch.org/search → familysearch.org. */
+function siteOf(url) {
+    if (!url)
+        return undefined;
+    try {
+        return new URL(/^[a-z][a-z0-9+.-]*:\/\//i.test(url) ? url : `https://${url}`).hostname.toLowerCase().replace(/^www\./, "");
+    }
+    catch {
+        return undefined;
+    }
+}
+/** An archive already here under this name or on this website. */
+export function sameRepository(all, name, url) {
+    const folded = foldText(name);
+    const site = siteOf(url);
+    return all.find((r) => foldText(r.name) === folded || (site !== undefined && siteOf(r.url) === site));
+}
 register({
     path: ["repo", "add"],
     summary: "Add an archive, library or portal that holds records",
@@ -260,10 +277,17 @@ register({
         { name: "terms", type: "string", value: "<text>", description: "terms of use in one sentence (+ link)" },
         { name: "automation", type: "string", value: "<a>", description: "allowed, manual (browser only), forbidden, unknown (default)" },
         { name: "note", type: "string", value: "<text>", description: "short note" },
+        { name: "another", type: "boolean", description: "a different archive, though one here has its name or website" },
     ],
     examples: ['strom repo add "State Archive, online reading room" --country CZ --url https://archive.example.org --automation manual'],
     run(ctx, { args, opts }) {
         const tree = ctx.tree();
+        // One archive, one record: a second "FamilySearch" splits its books, terms and lessons in two (found in a live run).
+        const twin = opts.another ? undefined : sameRepository(tree.list("repository"), args[0], str(opts.url));
+        if (twin)
+            throw new UsageError(`${twin.id} "${twin.name}" is this archive already${twin.url ? ` (${twin.url})` : ""}`, {
+                hint: `use it: --repo ${twin.id} (strom repo show ${twin.id}) — a different archive after all: add --another`,
+            });
         const r = create(tree, "repository", {
             name: args[0].trim(),
             country: str(opts.country)?.toUpperCase(),

package/dist/commands/start.js

@@ -17,6 +17,7 @@ import { AGENTS, findAgent, isAgent } from "../core/which.js";
 import { DESKTOP_APPS, agentsHere, whereToTalk } from "../core/apps.js";
 import { assertIntact } from "../core/integrity.js";
 import { treeBrowserConnectors } from "../core/connector.js";
+import { browserNote } from "./connectors.js";
 import { appOpensResearch, importAppUrl, installedStromApp, liveAppUrl, noticeStromApp, STROM_APP_URL, stromAppUrl } from "../core/stromapp.js";
 import { liveRunning, serveLive, startLive, stopLive } from "../core/live.js";
 import { openForUser } from "../core/open.js";
@@ -131,7 +132,7 @@ register({
             // its research when there is one, the day.
             name: ["Strom", tree.config.name, researches.length === 1 ? researches[0].name : undefined, new Date().toLocaleDateString(lang, { day: "numeric", month: "numeric" })].filter(Boolean).join(" · "),
             shared,
-            ...(agent === "claude" ? { chrome: treeBrowserConnectors(tree, shared).length > 0 } : {}),
+            ...(agent === "claude" ? { chrome: treeBrowserConnectors(tree, shared).length > 0, remote: ctx.settings.agentRemote() } : {}),
         };
         const args = conversationArgs(agent, base);
         if (opts.print)
@@ -147,6 +148,9 @@ register({
         const worker = `${agent}-${process.pid}-${Date.now().toString(36)}`;
         const leave = enterWorker(tree.root, worker, `${profile.name} conversation`);
         ctx.io.stdout(ui(lang, "ui.chat.open", { agent: profile.name, exit: profile.exit }) + "\n");
+        const browserSays = browserNote(ctx, tree, agent);
+        if (browserSays)
+            ctx.io.stdout(browserSays + "\n");
         // Claude Code asks once whether the folder is to be trusted — its own safety step, kept; the user knows what to answer.
         if (agent === "claude" && !claudeTrusts(tree.root, ctx.env))
             ctx.io.stdout(ui(lang, "ui.chat.trust") + "\n");

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 } };
     },
 }, {