strom-research 1.2.0 → 1.3.0

package/dist/cli/wizard.js

@@ -18,6 +18,7 @@ import { openForUser } from "../core/open.js";
 import { createShortcut } from "../core/shortcut.js";
 import { desktopDir } from "../core/paths.js";
 import { ensureShared } from "../commands/setup.js";
+import { moveHome, planMove, repointSettings, sameFolder } from "../core/relocate.js";
 /** The shortcut's name, in the user's language. */
 export function shortcutName(lang) {
     return ui(lang, "ui.dialog.title");
@@ -46,9 +47,18 @@ export async function setupWizard(ctx) {
     // Run again: each choice can be left as it is (0), the current one suggested.
     const keep = first ? {} : { back: ui(lang, "ui.keep") };
     // 2. Where the research lives.
-    const home = ctx.resolvePath(await ctx.ask(ui(lang, "ui.setup.home"), ctx.display(s.home()?.value ?? s.suggestedHome())));
+    const was = s.home()?.value;
+    const typed = (await ctx.ask(ui(lang, first ? "ui.setup.home" : "ui.setup.home.again"), ctx.display(was ?? s.suggestedHome()))).trim();
+    // Run again: 0 (or nothing) keeps the folder, like every other answer here.
+    let home = was && (typed === "0" || !typed) ? was : ctx.resolvePath(typed || ctx.display(s.suggestedHome()));
+    // Another folder while the research is in the old one: it moves along (trees, the shared folder) — or stays where it is.
+    if (was && !sameFolder(home, was))
+        home = await moveResearch(ctx, lang, was, home);
     cfg.lang = lang;
-    cfg.home = home;
+    if (was && !sameFolder(home, was))
+        repointSettings(s, ctx.env, was, home);
+    else if (!was)
+        cfg.home = home;
     s.save();
     fs.mkdirSync(home, { recursive: true });
     fs.mkdirSync(s.trees().value, { recursive: true });
@@ -167,3 +177,39 @@ export async function askStromApp(ctx, lang, back = ui(lang, "ui.browse.back"))
     }
     return answer;
 }
+/**
+ * The research to another folder: what moves is said (the trees, the shared folder with the plugins and images), and it
+ * moves on the person's yes. Where it cannot (somebody at work, a folder with something in it, into itself) it stays.
+ * Returns the folder the research is in afterwards.
+ */
+async function moveResearch(ctx, lang, from, to) {
+    const out = (line) => ctx.io.stdout(line + "\n");
+    // Set from outside (STROM_HOME): the folder is not the wizard's to change.
+    if (ctx.settings.home()?.source !== "config") {
+        out(ui(lang, "ui.home.env", { from: ctx.display(from) }));
+        return from;
+    }
+    const plan = planMove(from, to, ctx.knownTrees().map((k) => k.root));
+    if (!plan.content)
+        return to;
+    const where = { from: ctx.display(from), to: ctx.display(plan.to) };
+    if (plan.problem) {
+        out(ui(lang, `ui.home.${plan.problem}`, { ...where, trees: plan.busy.join(", ") }));
+        out(ui(lang, "ui.home.stays", where));
+        return from;
+    }
+    out(ui(lang, "ui.home.what", { ...where, trees: plan.trees.length ? plan.trees.join(", ") : "–" }));
+    if (!(await ctx.confirm(ui(lang, "ui.home.sure"), true))) {
+        out(ui(lang, "ui.home.stays", where));
+        return from;
+    }
+    try {
+        const how = moveHome(plan);
+        out(ui(lang, how === "moved" ? "ui.home.moved" : "ui.home.copied", where));
+        return plan.to;
+    }
+    catch (err) {
+        out(ui(lang, "ui.home.failed", { ...where, reason: err.message }));
+        return from;
+    }
+}

package/dist/commands/browse.js

@@ -115,7 +115,7 @@ register({
                 (s.sessions.costUsd ? ui(lang, "ui.stats.cost", { cost: humanCost(s.sessions.costUsd, lang) }) : "") +
                 (s.sessions.costUsd && s.sessions.costPartial ? ui(lang, "ui.stats.cost.partial", { n: s.sessions.costPartial }) : ""));
         if (s.stories.written)
-            out.push(ui(lang, "ui.stats.stories", { n: s.stories.written, final: s.stories.final }));
+            out.push(ui(lang, "ui.stats.stories", { n: s.stories.written }));
         return { text: lines(...out), data: s };
     },
 }, {
@@ -164,7 +164,7 @@ register({
         }
         if (c.story) {
             const text = c.story.text.replace(/\*\*/g, "").trim();
-            out.push("", ui(lang, "ui.card.story", { status: ui(lang, c.story.status === "final" ? "ui.card.story.final" : "ui.card.story.draft") }));
+            out.push("", ui(lang, "ui.card.story"));
             // markdown headings as plain lines
             out.push(text.split("\n").map((l) => (l.trim() ? `  ${l.trim().replace(/^#+\s*/, "")}` : "")).join("\n"));
         }

package/dist/commands/connectors.js

@@ -26,7 +26,8 @@ import { imageSizeOfFile } from "../image/index.js";
 import { Tree } from "../core/tree.js";
 import { syncAgentFiles } from "../agents/files.js";
 import { clearBlock, CookieJar, DEFAULT_PACE, hostAllowed, hostPace, hostState, knownHosts, MIN_INTERVAL_MS, NetError, paceText, politeRequest, refusedBy, reserveSlots, setOwnPace } from "../core/net.js";
-import { botCheck, fileBase, findDownload, loadPage, loadPlans, pageKey, pageScript, parseResult, PLAN_TTL_MS, planScript, readSavedPage, removePlan, savePage, savePlan, SCRIPT_MS, } from "../core/browser.js";
+import { botCheck, fileBase, findDownload, loadPage, loadPlans, pageKey, pageScript, parseResult, PLAN_TTL_MS, planScript, readSavedPage, removePlan, savePage, savePlan, SCRIPT_MS, claudeInChrome, CLAUDE_IN_CHROME_URL, } from "../core/browser.js";
+import { PROFILES } from "../agents/profiles.js";
 import { bareHost, changedSinceConsent, codeWarning, consentRequired, connectorHash, connectorsDir, directNetwork, ensurePluginsDir, findConnector, hostWarning, imageProblem, INTERFACE, listConnectors, loadConsents, MANIFEST, missingConsents, NAME_RE, readManifest, routeOf, treeBrowserConnectors, routesOf, ROUTES, runConnector, saveConsents, scanConnectors, suggestName, } from "../core/connector.js";
 import { registerImages } from "./media.js";
 function shared(ctx) {
@@ -304,7 +305,7 @@ register({
         const hosts = c.manifest.hosts.map(bareHost);
         return {
             text: via === "browser"
-                ? lines(`${c.name}: images through your browser from now on (${hosts.join(", ")})`, `  · the agent gets browser tools (Claude in Chrome) for these sites only, in the family trees that work with this`, `    archive (images fetched through it, or an archive, book or record of theirs on its site), from its next session${synced.length ? ` (permissions of ${synced.join(", ")} updated)` : ""}. Chrome with the`, "    Claude extension must be running then, signed in to the account Claude Code uses; browser tools need a model", "    that can review its actions (Sonnet or Opus, not Haiku)", `  · strom plans and paces every request, and takes the files over from ${ctx.display(s.downloads())}`, "    (another folder: strom config set browser.downloads <folder>)", `  · the first time, Chrome asks whether ${hosts[0]} may download several files: allow it once`, `  · back: strom connector use ${c.name} --via direct`)
+                ? lines(`${c.name}: images through your browser from now on (${hosts.join(", ")})`, `  · the agent gets browser tools (Claude in Chrome) for these sites only, in the family trees that work with this`, `    archive (images fetched through it, or an archive, book or record of theirs on its site), from its next session${synced.length ? ` (permissions of ${synced.join(", ")} updated)` : ""}. Chrome with the`, "    Claude extension must be running then, signed in to the account Claude Code uses; browser tools need a model", "    that can review its actions (Sonnet or Opus, not Haiku)", `  · strom plans and paces every request, and takes the files over from ${ctx.display(s.downloads())}`, "    (another folder: strom config set browser.downloads <folder>)", `  · the first time, Chrome asks whether ${hosts[0]} may download several files: allow it once`, `  · back: strom connector use ${c.name} --via direct`, ...browserWarnings(ctx))
                 : lines(`${c.name}: images directly through strom from now on, paced (${hosts.join(", ")})`, routesOf(c).includes("browser") ? `  · through your browser again: strom connector use ${c.name} --via browser` : undefined),
             data: { connector: c.name, via, hosts, synced },
         };
@@ -1440,3 +1441,25 @@ function textFiles(dir) {
     walk(dir);
     return out;
 }
+/**
+ * What the person is told of the archives this tree reaches through their browser, for the agent that works: only
+ * Claude Code has browser tools (Claude in Chrome), and the extension must be in a browser here. Nothing to say: undefined.
+ */
+export function browserNote(ctx, tree, agent) {
+    const via = treeBrowserConnectors(tree, ctx.settings.shared()?.value);
+    if (!via.length)
+        return undefined;
+    const lang = ctx.uiLang();
+    const names = via.map((c) => c.manifest.title ?? c.name).join(", ");
+    if (agent !== "claude")
+        return ui(lang, "ui.browser.agent", { names, agent: PROFILES[agent]?.name ?? agent });
+    const found = claudeInChrome(ctx.env).extension;
+    return found.length ? undefined : ui(lang, "ui.browser.noext", { names, url: CLAUDE_IN_CHROME_URL });
+}
+/** Through the browser: what stands in the way here (English, for the agent — which tells the user). */
+function browserWarnings(ctx) {
+    const agent = ctx.settings.agent(ctx.hasTree() ? ctx.tree().config : undefined).value;
+    if (agent !== "claude")
+        return [`  ⚠ only Claude Code has browser tools (Claude in Chrome); this research's agent is ${PROFILES[agent]?.name ?? agent} — tell the user: they save these images by hand, or choose Claude Code (strom agents use claude)`];
+    return claudeInChrome(ctx.env).extension.length ? [] : [`  ⚠ the Claude in Chrome extension is in no browser here — tell the user to install it and sign in: ${CLAUDE_IN_CHROME_URL}`];
+}

package/dist/commands/hooks.js

@@ -0,0 +1,141 @@
+// Hooks: the user's programs told of what is saved into a research (core/hooks.ts).
+import fs from "node:fs";
+import path from "node:path";
+import { register } from "../cli/registry.js";
+import { lines, table } from "../cli/format.js";
+import { ui } from "../cli/ui.js";
+import { StromError, UsageError } from "../core/errors.js";
+import { readJsonLines } from "../core/json.js";
+import { prependPath } from "../runners/runner.js";
+import { shimDir } from "./session.js";
+import { ensureHooksDir, forHook, HOOK_INTERFACE, hooksDir, listHooks, loadHook, runHookNow } from "../core/hooks.js";
+function shared(ctx) {
+    const s = ctx.settings.shared()?.value;
+    if (!s)
+        throw new StromError("strom is not set up yet", { hint: "strom setup" });
+    ensureHooksDir(s);
+    return s;
+}
+/** Turning a hook on or off is the user's decision: an agent asks them (a window of the system). */
+function setHook(ctx, name, on) {
+    const s = shared(ctx);
+    const now = ctx.settings.config.hooks ?? [];
+    if (now.includes(name) === on)
+        return { text: `${name}: ${on ? "on" : "off"} already`, data: { hook: name, on, hooks: now } };
+    // off: also a hook whose folder is gone or broken — it goes from the list all the same
+    let hook;
+    try {
+        hook = loadHook(s, name);
+    }
+    catch (err) {
+        if (on)
+            throw err;
+    }
+    const title = hook?.manifest.title ?? name;
+    ctx.requireHuman(on ? `Let the hook "${name}" be told of everything saved into your researches?` : `Stop telling the hook "${name}"?`, `strom hook ${on ? "on" : "off"} ${name}`, "hooks", ui(ctx.uiLang(), on ? "ui.consent.hook.on" : "ui.consent.hook.off", { name: title }));
+    ctx.settings.reload();
+    const next = on ? [...(ctx.settings.config.hooks ?? []).filter((h) => h !== name), name] : (ctx.settings.config.hooks ?? []).filter((h) => h !== name);
+    ctx.settings.config.hooks = next.length ? next : undefined;
+    ctx.settings.save();
+    return {
+        text: on && hook ? `${name}: on — told of what is saved (${(hook.manifest.events ?? ["*"]).join(", ")}); its output: ${ctx.display(path.join(hook.dir, "hook.log"))}` : `${name}: off`,
+        data: { hook: name, on, hooks: next },
+    };
+}
+/** The last operations saved into this research, newest last. */
+function lastOps(root, n) {
+    const dir = path.join(root, "data", "ops");
+    let files = [];
+    try {
+        files = fs.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+    }
+    catch {
+        return [];
+    }
+    return files
+        .flatMap((f) => readJsonLines(path.join(dir, f)))
+        .sort((a, b) => a.at.localeCompare(b.at))
+        .slice(-n)
+        .map((o) => ({ op: o.op, targets: o.targets, summary: o.summary, at: o.at, by: o.by, ...(o.reason ? { reason: o.reason } : {}) }));
+}
+register({
+    path: ["hook", "list"],
+    summary: "Hooks: your programs told of what is saved into a research (a message to your phone, a log…) — which there are, which are on",
+    group: "setup",
+    run(ctx) {
+        const s = shared(ctx);
+        const on = ctx.settings.config.hooks ?? [];
+        const hooks = listHooks(s);
+        return {
+            text: lines(hooks.length
+                ? table(hooks.map((h) => [on.includes(h.name) ? `${h.name} ◀ on` : h.name, h.manifest.title ?? "", (h.manifest.events ?? ["*"]).join(" "), h.manifest.command.join(" ")]))
+                : "no hooks", on.length ? `on: ${on.join(", ")} (strom hook off <name>)` : "none is on: strom hook on <name> (only you)", `folder: ${ctx.display(hooksDir(s))} — copy a hook's folder in to install it (the interface: README.md there)`),
+            data: {
+                folder: hooksDir(s),
+                on,
+                hooks: hooks.map((h) => ({ name: h.name, title: h.manifest.title, events: h.manifest.events ?? ["*"], command: h.manifest.command, dir: h.dir, on: on.includes(h.name) })),
+            },
+        };
+    },
+}, {
+    path: ["hook", "on"],
+    summary: "Turn a hook on: from now on it is told of what is saved into your researches (only you)",
+    group: "setup",
+    args: [{ name: "name", description: "the hook's folder name", required: true }],
+    examples: ["strom hook on telegram"],
+    run: (ctx, { args }) => setHook(ctx, args[0], true),
+}, {
+    path: ["hook", "off"],
+    summary: "Turn a hook off (only you)",
+    group: "setup",
+    args: [{ name: "name", description: "the hook's folder name", required: true }],
+    run: (ctx, { args }) => setHook(ctx, args[0], false),
+}, {
+    path: ["hook", "test"],
+    summary: "Run a hook now on what was saved last in this research (or one operation you name), wait for it and show what it printed",
+    group: "setup",
+    tree: true,
+    args: [{ name: "name", description: "the hook's folder name", required: true }],
+    options: [
+        { name: "last", type: "string", value: "<n>", description: "the last n operations saved (default 5)" },
+        { name: "op", type: "string", value: "<op>", description: "one operation instead, e.g. person.add (with --target)" },
+        { name: "target", type: "string", value: "<ID>", description: "the record it concerns, e.g. P0001" },
+    ],
+    examples: ["strom hook test telegram", "strom hook test telegram --op person.add --target P0001"],
+    run(ctx, { args, opts }) {
+        const s = shared(ctx);
+        const hook = loadHook(s, args[0]);
+        const tree = ctx.tree();
+        const n = opts.last === undefined ? 5 : Number(opts.last);
+        if (!Number.isInteger(n) || n < 1)
+            throw new UsageError("--last must be a positive number");
+        const all = typeof opts.op === "string"
+            ? [{ op: opts.op, targets: typeof opts.target === "string" ? [opts.target] : [], summary: `(a test of ${opts.op})`, at: new Date().toISOString(), by: "user" }]
+            : lastOps(tree.root, n);
+        const events = forHook(hook, all);
+        if (!events.length)
+            return {
+                text: `${hook.name} wants none of these: ${[...new Set(all.map((e) => e.op))].join(", ") || "nothing saved yet"} (its events: ${(hook.manifest.events ?? ["*"]).join(", ")})`,
+                data: { hook: hook.name, events: [] },
+            };
+        const r = runHookNow(hook, prependPath(ctx.env, shimDir(tree)), {
+            interface: HOOK_INTERFACE,
+            hook: hook.name,
+            tree: { name: tree.config.name, id: tree.config.id, root: tree.root, lang: tree.lang },
+            commit: "test",
+            at: new Date().toISOString(),
+            events,
+        });
+        const ok = !r.error && r.status === 0;
+        return {
+            text: lines(`${hook.name}: ${events.length} operation(s) — ${ok ? "ended well" : `failed: ${r.error ?? `exit status ${r.status}`}`}`, r.output
+                ? r.output
+                    .split("\n")
+                    .map((l) => `  ${l}`)
+                    .join("\n")
+                : undefined),
+            data: { hook: hook.name, events, status: r.status, ...(r.error ? { error: r.error } : {}), output: r.output },
+            exitCode: ok ? 0 : 1,
+        };
+    },
+});

package/dist/commands/index.js

@@ -19,5 +19,6 @@ import "./story.js";
 import "./output.js";
 import "./session.js";
 import "./gates.js";
+import "./hooks.js";
 import "./checks.js";
 import "./setup.js";

package/dist/commands/intake.js

@@ -67,8 +67,8 @@ function groupTask(tree, inputs, research, imported, folder) {
     return create(tree, "task", { level: "intake", priority: 4, what, where: ids, why, doneWhen, subject: ids, research, state: "open", origin: tree.actor }, (id) => `+${id} task "${truncate(what, 60)}"`);
 }
 /** More images than this in one folder look like the scans of a book, not family documents. */
-const BOOK_OF_SCANS = 20;
-const IMAGE_EXT = new Set([".jpg", ".jpeg", ".png", ".tif", ".tiff", ".jp2", ".gif", ".webp", ".heic"]);
+export const BOOK_OF_SCANS = 20;
+export const IMAGE_EXT = new Set([".jpg", ".jpeg", ".png", ".tif", ".tiff", ".jp2", ".gif", ".webp", ".heic"]);
 register({
     path: ["intake"],
     summary: "Take in material to research from: folders, files, a family tree (GEDCOM / Strom JSON), or text",

package/dist/commands/research.js

@@ -3,12 +3,16 @@ import { register } from "../cli/registry.js";
 import { lines, table } from "../cli/format.js";
 import { addPerson, addResearch } from "../core/actions.js";
 import { applyFrontier, researchProposals } from "./session.js";
+import { frontier } from "../core/frontier.js";
+import { parkedWhy } from "./tasks.js";
+import { ui } from "../cli/ui.js";
 import { phrase } from "../core/phrases.js";
 import { UsageError } from "../core/errors.js";
 import { REVIEW_SCOPES } from "../core/model.js";
 import { ancestorGenerations, displayName, label, lifespan, parentsOf, resolvePerson } from "../core/people.js";
 import { foldText } from "../core/text.js";
 import { update } from "../core/records.js";
+import { isAgent } from "../core/which.js";
 function int(v, name) {
     if (v === undefined)
         return undefined;
@@ -175,22 +179,31 @@ register({
         else if (opts.model)
             throw new UsageError("--model goes with --reread");
         const review = { scope: scope, ...(reread ? { reread } : {}) };
+        const lang = tree.lang;
         // one review research per person: again later, it goes on where it was
         const existing = tree.list("research").find((r) => r.direction === "person" && r.focus === p.id && r.review);
-        let research;
-        if (existing)
-            research = update(tree, existing.id, "research", (r) => ({ ...r, state: "active", review }), {
-                op: "research.edit",
-                summary: `${existing.id} review again: ${scope}${reread ? `, second reading with ${reread}` : ""}`,
-            });
-        else {
-            const r = addResearch(tree, { name: phrase(tree.lang, "review.research", { name: displayName(p) }), focus: p.id, direction: "person" });
-            research = update(tree, r.id, "research", (x) => ({ ...x, review }), { op: "research.edit", summary: `${r.id} review: ${scope}${reread ? `, second reading with ${reread}` : ""}` });
+        // What it would propose, asked before anything is written: with nothing to do, no research is made for it.
+        const draft = existing
+            ? { ...existing, state: "active", review }
+            : { id: "G?", type: "research", name: phrase(lang, "review.research", { name: displayName(p) }), focus: p.id, direction: "person", state: "active", review, notes: [] };
+        const planned = researchProposals(tree, draft).map((x) => x.proposal);
+        let research = draft;
+        let tasks = [];
+        if (planned.length && !tree.dryRun) {
+            if (existing)
+                research = update(tree, existing.id, "research", (r) => ({ ...r, state: "active", review }), {
+                    op: "research.edit",
+                    summary: `${existing.id} review again: ${scope}${reread ? `, second reading with ${reread}` : ""}`,
+                });
+            else {
+                const r = addResearch(tree, { name: draft.name, focus: p.id, direction: "person" });
+                research = update(tree, r.id, "research", (x) => ({ ...x, review }), { op: "research.edit", summary: `${r.id} review: ${scope}${reread ? `, second reading with ${reread}` : ""}` });
+            }
+            tasks = applyFrontier(tree, research)
+                .map((id) => tree.get(id))
+                .filter((t) => !!t);
         }
-        const planned = tree.dryRun ? researchProposals(tree, research).map((x) => x.proposal) : [];
-        const created = tree.dryRun ? [] : applyFrontier(tree, research);
-        const tasks = created.map((id) => tree.get(id)).filter((t) => !!t);
-        const open = tree.list("task").filter((t) => t.research === research.id && ["open", "doing"].includes(t.state));
+        const open = existing ? tree.list("task").filter((t) => t.research === existing.id && ["open", "doing"].includes(t.state)) : [];
         // what a session costs here, from those so far: the user decides with the price in view
         const costs = tree
             .list("session")
@@ -198,8 +211,34 @@ register({
             .map((s) => s.metrics?.costUsd)
             .filter((c) => typeof c === "number");
         const avg = costs.length ? costs.reduce((a, b) => a + b, 0) / costs.length : undefined;
-        const list = tree.dryRun ? planned.map((t) => `  would add: ${t.level} · ${t.what}`) : tasks.map((t) => `  ${t.id} ${t.level} · ${t.what}`);
-        const text = lines(...tree.written.map((o) => o.summary), tree.dryRun ? "(dry run — nothing written)" : undefined, "", list.length ? `${label(p)} — ${tree.dryRun ? planned.length : tasks.length} new task(s):` : `${label(p)} — nothing new to review${open.length ? `; ${open.length} task(s) of the review still open` : ""}`, ...list, open.length ? `${open.length} open in ${research.id}, about ${open.length} session(s)${avg !== undefined ? ` — sessions here cost $${avg.toFixed(2)} on average` : ""}` : undefined, open.length ? `next   strom run --research ${research.id}   (the agent alone) · or in a conversation: strom session start --research ${research.id}` : undefined);
-        return { text, data: { research, created: tasks, planned, open: open.map((t) => t.id), ...(avg !== undefined ? { avgCostUsd: avg } : {}) } };
+        // A person at a terminal (the menu) reads the tasks and what comes next, not the operations and commands.
+        const human = ctx.io.tty && !isAgent(ctx.env);
+        const list = tree.dryRun
+            ? planned.map((t) => ui(lang, "ui.review.would", { level: t.level, what: t.what }))
+            : tasks.map((t) => (human ? `  • ${t.what}` : `  ${t.id} ${t.level} · ${t.what}`));
+        // Nothing new: why — the work that covers them already (a parked task says how to go on), a search done in vain.
+        const why = list.length ? [] : coveredLines(tree, draft, lang, human);
+        const inReview = existing ?? (planned.length && !tree.dryRun ? research : undefined);
+        const text = lines(...(human ? [] : tree.written.map((o) => o.summary)), tree.dryRun ? ui(lang, "ui.review.dry") : undefined, (tree.written.length && !human) || tree.dryRun ? "" : undefined, list.length ? ui(lang, "ui.review.new", { name: label(p), n: list.length }) : ui(lang, "ui.review.nothing", { name: label(p) }), ...list, ...why, open.length || tasks.length
+            ? ui(lang, "ui.review.open", { n: open.length || tasks.length, research: inReview.id }) + (avg !== undefined ? ui(lang, "ui.review.cost", { cost: avg.toFixed(2) }) : "")
+            : undefined, (open.length || tasks.length) && inReview ? ui(lang, human ? "ui.review.next.human" : "ui.review.next", { research: inReview.id }) : undefined);
+        return { text, data: { research: inReview ?? null, created: tasks, planned, open: open.map((t) => t.id), ...(why.length ? { why } : {}), ...(avg !== undefined ? { avgCostUsd: avg } : {}) } };
     },
 });
+/** Why a review found nothing new, person by person: the work that covers them already, or a search done in vain. */
+function coveredLines(tree, research, lang, human = false) {
+    const out = [];
+    for (const item of frontier(tree, research)) {
+        const name = label(item.person);
+        const t = item.coveredBy ? tree.get(item.coveredBy) : undefined;
+        if (t) {
+            const why = parkedWhy(tree, t);
+            out.push(ui(lang, "ui.review.covered", { name, task: t.id, state: ui(lang, `ui.review.state.${t.state}`) + (why ? `: ${why}` : ""), what: t.what }));
+            if (t.state === "parked")
+                out.push(ui(lang, human ? "ui.review.wake.human" : "ui.review.wake", { task: t.id }));
+        }
+        else if (item.exhausted?.length)
+            out.push(ui(lang, "ui.review.exhausted", { name, tasks: item.exhausted.join(", ") }));
+    }
+    return out;
+}

package/dist/commands/session.js

@@ -37,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);
@@ -479,6 +480,10 @@ 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,
@@ -598,7 +603,7 @@ register({
                     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,
@@ -624,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 }));
                 }

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";
@@ -31,13 +32,16 @@ import { check } from "../core/check.js";
 import { assertIntact, verifyFull } from "../core/integrity.js";
 import { ensurePluginsDir } from "../core/connector.js";
 import { ensureGatesDir, loadGate } from "../core/gate.js";
-import { downloadsDir } from "../core/browser.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"],
@@ -69,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;
@@ -189,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)));
@@ -391,11 +414,33 @@ 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"));

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");