strom-research 1.1.1 → 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

@@ -112,9 +112,10 @@ register({
         out.push("", ui(lang, "ui.stats.tasks", s.tasks));
         if (s.sessions.count)
             out.push(ui(lang, "ui.stats.sessions", { n: s.sessions.count, last: humanDay(s.sessions.last, lang) }) +
-                (s.sessions.costUsd ? ui(lang, "ui.stats.cost", { cost: humanCost(s.sessions.costUsd, lang) }) : ""));
+                (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 };
     },
 }, {
@@ -163,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/gates.js

@@ -0,0 +1,58 @@
+// Gates: the user's condition on the agent working alone (core/gate.ts).
+import { register } from "../cli/registry.js";
+import { lines, table } from "../cli/format.js";
+import { StromError } from "../core/errors.js";
+import { askGate, ensureGatesDir, gatesDir, listGates, loadGate } from "../core/gate.js";
+function shared(ctx) {
+    const s = ctx.settings.shared()?.value;
+    if (!s)
+        throw new StromError("strom is not set up yet", { hint: "strom setup" });
+    ensureGatesDir(s);
+    return s;
+}
+register({
+    path: ["gate", "list"],
+    summary: "Gates: conditions on the agent working alone (strom run) — which there are, which one is asked",
+    group: "research",
+    run(ctx) {
+        const s = shared(ctx);
+        const set = ctx.settings.runGate();
+        const setName = set?.split(" ")[0];
+        const gates = listGates(s);
+        const folder = `folder: ${ctx.display(gatesDir(s))} — copy a gate's folder in to install it (the interface: README.md there)`;
+        return {
+            text: lines(gates.length ? table(gates.map((g) => [g.name === setName ? `${g.name} ◀ run.gate${set !== setName ? ` (${set})` : ""}` : g.name, g.manifest.title ?? "", g.manifest.command.join(" ")])) : "no gates", set ? `asked before each session of strom run: ${set} (strom config unset run.gate: none)` : "none is asked: strom config set run.gate <name> (only you)", folder),
+            data: { folder: gatesDir(s), gate: set ?? null, gates: gates.map((g) => ({ name: g.name, title: g.manifest.title, command: g.manifest.command, dir: g.dir })) },
+        };
+    },
+}, {
+    path: ["gate", "test"],
+    summary: "Ask a gate now what it would answer before a session: go on, wait (until when) or stop — and why",
+    group: "research",
+    args: [{ name: "gate", description: 'the gate and what it is given, e.g. "claude-usage 10" (default: run.gate)' }],
+    examples: ["strom gate test", 'strom gate test "claude-usage 10"'],
+    run(ctx, { args }) {
+        const s = shared(ctx);
+        const name = args[0] ?? ctx.settings.runGate();
+        if (!name)
+            throw new StromError("no gate named and none set", { hint: "strom gate list — strom gate test <name>" });
+        const gate = loadGate(s, name);
+        const tree = ctx.hasTree() ? ctx.tree() : undefined;
+        const agent = ctx.settings.agent(tree?.config).value;
+        const said = askGate(gate, ctx.env, {
+            tree: tree?.root ?? "",
+            lang: tree?.lang ?? ctx.uiLang(),
+            agent,
+            model: ctx.settings.models(agent, tree?.config).lead,
+            sessions: 0,
+            costUsd: 0,
+        });
+        const until = said.verdict === "wait" ? new Date(Date.now() + said.waitMs) : undefined;
+        const word = { go: "go on", wait: `wait until ${until?.toLocaleString(ctx.uiLang(), { weekday: "short", day: "numeric", month: "numeric", hour: "2-digit", minute: "2-digit" })}`, stop: "stop", error: "error — a run would stop" }[said.verdict];
+        return {
+            text: `${[gate.name, ...gate.args].join(" ")}: ${word}${said.reason ? ` — ${said.reason}` : ""}`,
+            data: { gate: gate.name, verdict: said.verdict, ...(said.reason ? { reason: said.reason } : {}), ...(until ? { until: until.toISOString() } : {}) },
+            exitCode: said.verdict === "error" ? 1 : 0,
+        };
+    },
+});

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

@@ -18,5 +18,7 @@ import "./browse.js";
 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,27 +179,66 @@ 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").map((s) => s.metrics?.costUsd).filter((c) => typeof c === "number");
+        const costs = tree
+            .list("session")
+            .filter((s) => !s.metrics?.costPartial) // stopped before it said: more than it shows
+            .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;
+}