strom-research 1.0.0 → 1.1.0

package/dist/cli/menu.js

@@ -12,9 +12,19 @@ import { ui } from "./ui.js";
 import { Tree, VERSION } from "../core/tree.js";
 import { liveHolder } from "../core/lock.js";
 import { newerVersion } from "../core/update.js";
-import { waitingForUser } from "../commands/tasks.js";
-import { noticeStromApp, stromAppState } from "../core/stromapp.js";
+import { taskQueue, waitingForUser } from "../commands/tasks.js";
+import { humanTask } from "../commands/browse.js";
+import { lacksImages } from "../core/queue.js";
+import { othersAtWork } from "../core/session.js";
+import { DEFAULT_RUN_MINUTES } from "../core/config.js";
+import { truncate } from "./format.js";
+import { installedStromApp, noticeStromApp, stromAppState, stromAppUrl } from "../core/stromapp.js";
+import { chromiumBrowser } from "../core/chromium.js";
+import { liveWorkers, runsAtWork } from "../core/workers.js";
+import { askStromApp } from "./wizard.js";
 import { openForUser } from "../core/open.js";
+import { displayName, findPersons, label } from "../core/people.js";
+import { mainPerson } from "../core/kin.js";
 import { AGENTS, findAgent } from "../core/which.js";
 import { agentsHere } from "../core/apps.js";
 import { PROFILES } from "../agents/profiles.js";
@@ -70,6 +80,8 @@ export async function runMenu(ctx, run) {
             continue;
         }
         const items = [];
+        let appItem;
+        let appTip;
         out();
         out(t("ui.menu.title", { version: VERSION }));
         const newer = await newerVersion(ctx.settings, ctx.env);
@@ -82,8 +94,9 @@ export async function runMenu(ctx, run) {
             out(t("ui.menu.tree", { name: tree.config.name, persons: tree.count("person") }));
             if (waiting)
                 out(t("ui.menu.waiting", { count: waiting }));
-            if (liveHolder(path.join(root, ".strom", "run.lock")))
-                out(t("ui.menu.working"));
+            const runs = runsAtWork(root).length;
+            if (runs)
+                out(t(runs > 1 ? "ui.menu.working.more" : "ui.menu.working", { n: runs }));
             items.push({ key: "1", label: t(started ? "ui.menu.chat" : "ui.menu.start"), act: async () => void (await run(["chat"])) }, {
                 key: "2",
                 label: t("ui.menu.run"),
@@ -95,14 +108,68 @@ export async function runMenu(ctx, run) {
                         await pause(lang);
                         return;
                     }
-                    let n = 0;
-                    while (!(Number.isInteger(n) && n > 0 && n <= 100)) {
-                        if (outOfAnswers())
+                    // What comes next, as the agent working alone takes it (a story now and then), without what others hold.
+                    const fresh = Tree.open(root, ctx.env);
+                    const held = othersAtWork(fresh, fresh.env).tasks;
+                    const queue = taskQueue(fresh, { strategy: ctx.settings.strategy(fresh.config), storyTurn: true }).filter((x) => !held.has(x.id));
+                    const shown = queue.slice(0, RUN_LIST);
+                    // Another run already at work: said first, and started beside it only on a yes.
+                    const running = runsAtWork(root).length;
+                    if (running) {
+                        out(t("ui.run.beside", { n: running }));
+                        if (!(await ctx.confirm(t("ui.run.beside.sure"), false)))
                             return;
-                        n = Number(await ctx.ask(t("ui.run.how"), "3"));
+                    }
+                    let args;
+                    if (shown.length) {
+                        out(t("ui.run.next"));
+                        for (const [k, x] of shown.entries())
+                            out(`  ${String(k + 1).padStart(2)}. ${truncate(humanTask(fresh, x.what, lang), 100)}${x.level === "narrate" ? t("ui.run.story") : ""}${lacksImages(fresh, x) ? t("ui.plan.images") : ""}`);
+                        if (queue.length > shown.length)
+                            out(`      ${t("ui.plan.more", { n: queue.length - shown.length })}`);
+                    }
+                    out(t("ui.run.limit", { minutes: ctx.settings.number("run.minutes", fresh.config, DEFAULT_RUN_MINUTES) }));
+                    const how = shown.length ? await ctx.choose(t("ui.run.what"), [{ label: t("ui.run.queue") }, { label: t("ui.run.pick") }], 0, { back: t("ui.browse.back") }) : 0;
+                    if (how === undefined)
+                        return;
+                    if (how === 0) {
+                        let n = -1;
+                        while (!(Number.isInteger(n) && n >= 0 && n <= 100)) {
+                            if (outOfAnswers())
+                                return;
+                            n = Number(await ctx.ask(t("ui.run.how"), String(Math.min(3, Math.max(1, queue.length)))));
+                        }
+                        if (n === 0)
+                            return;
+                        args = ["--max", String(n)];
+                    }
+                    else {
+                        while (!args) {
+                            if (outOfAnswers())
+                                return;
+                            const a = (await ctx.ask(t("ui.run.which"))).trim();
+                            if (!a || a === "0")
+                                return;
+                            const picked = pickNumbers(a, shown.length);
+                            if (picked)
+                                args = ["--task", picked.map((k) => shown[k - 1].id).join(",")];
+                            else
+                                out(t("ui.run.which.bad", { n: shown.length }));
+                        }
+                    }
+                    // With the Strom app, the work can be watched live meanwhile (a Chromium browser reaches the bridge); the last answer is suggested.
+                    const app = stromAppState(ctx.settings);
+                    if ((app === "yes" || app === "seen") && chromiumBrowser(ctx.env)) {
+                        const follow = await ctx.confirm(t("ui.run.follow"), ctx.settings.config.stromAppFollow !== "no");
+                        if (ctx.settings.config.stromAppFollow !== (follow ? "yes" : "no")) {
+                            ctx.settings.config.stromAppFollow = follow ? "yes" : "no";
+                            ctx.settings.save();
+                        }
+                        if (follow)
+                            await run(["app", "--live"]);
                     }
                     out(t("ui.run.start"));
-                    await run(["run", "--max", String(n)]);
+                    await run(["run", ...args]);
                     await pause(lang);
                 },
             }, {
@@ -121,28 +188,25 @@ export async function runMenu(ctx, run) {
                 },
             }, {
                 key: "4",
-                label: t("ui.menu.results"),
-                act: async () => {
-                    const outDir = path.join(root, "output");
-                    const geds = ["tree.ged", "tree-strom.ged"].map((f) => path.join(outDir, f)).filter((f) => fs.existsSync(f));
-                    if (!geds.length)
-                        out(t("ui.results.none"));
-                    else {
-                        out(t("ui.results.files"));
-                        for (const g of geds)
-                            out(`  ${ctx.display(g)}`);
-                        const strom = geds.find((g) => g.endsWith("tree-strom.ged"));
-                        const app = stromAppState(ctx.settings);
-                        if (strom && (app === "yes" || app === "seen"))
-                            out(t("ui.results.app", { file: ctx.display(strom) }));
-                        else if (strom && app === "unknown")
-                            out(t("ui.results.app.maybe", { file: ctx.display(strom) }));
-                        if (await ctx.confirm(t("ui.results.open"), false))
-                            openForUser(outDir, ctx.env);
-                    }
-                    await pause(lang);
-                },
-            });
+                label: t("ui.menu.browse"),
+                act: async () => browse(ctx, run, lang, root),
+            }, ...(tree.count("person") === 0 ? [] : [{
+                    key: "4",
+                    label: t("ui.menu.review"),
+                    act: async () => {
+                        // one person, looked at again: what the tree says of them elsewhere, what to read whole, what to check
+                        const person = await pickPerson(ctx, lang, root, t("ui.review.who"));
+                        if (!person)
+                            return;
+                        const family = await ctx.confirm(t("ui.review.family"), false);
+                        await run(["review", person.id, ...(family ? ["--scope", "family"] : [])]);
+                        const research = Tree.open(root, ctx.env).list("research").find((r) => r.direction === "person" && r.focus === person.id && r.review);
+                        const open = research ? Tree.open(root, ctx.env).list("task").filter((x) => x.research === research.id && x.state === "open").length : 0;
+                        if (research && open && (await ctx.confirm(t("ui.review.run", { n: open }), false)))
+                            await run(["run", "--research", research.id, "--max", String(open)]);
+                        await pause(lang);
+                    },
+                }]));
             // Several agents on this computer: this conversation with another one (the default stays).
             const current = ctx.settings.agent(tree.config).value;
             const others = agentsHere(ctx.env)
@@ -153,13 +217,31 @@ export async function runMenu(ctx, run) {
                     key: "9",
                     label: t("ui.menu.otheragent"),
                     act: async () => {
-                        const i = others.length === 1 ? 0 : await ctx.choose(t("ui.setup.agent.pick"), others.map((a) => ({ label: a.name })), 0);
+                        // Enter (and 0) stay with the agent of the research: choosing another is a step the person takes on purpose.
+                        const i = await ctx.choose(t("ui.setup.agent.pick"), others.map((a) => ({ label: a.name })), others.length, { back: t("ui.back.stay", { name: PROFILES[current]?.name ?? current }) });
                         if (i !== undefined)
                             await run(["chat", "--agent", others[i].id]);
                     },
                 });
-            if (stromAppState(ctx.settings) !== "no")
-                items.push({ key: "5", label: t("ui.menu.app"), act: async () => void (await run(["app"])) });
+            // The Strom app: open the research in it (live while an agent is at work); not known yet: what it is, and whether they want it.
+            const app = stromAppState(ctx.settings);
+            if (app !== "no") {
+                const atWork = liveWorkers(root).length > 0 || runsAtWork(root).length > 0;
+                const hasApp = app !== "unknown" || Boolean(installedStromApp(ctx.env, process.platform, stromAppUrl(ctx.settings)));
+                appItem = {
+                    key: "5",
+                    label: t(!hasApp ? "ui.menu.app.new" : atWork ? "ui.menu.app.watch" : "ui.menu.app"),
+                    act: async () => {
+                        if (hasApp)
+                            return void (await run(["app"]));
+                        const answer = await askStromApp(ctx, lang);
+                        if (answer === "install" && (await ctx.confirm(t("ui.app.open.now"), true)))
+                            await run(["app"]);
+                    },
+                };
+                appTip = !hasApp ? "ui.menu.app.tip" : atWork ? "ui.menu.app.live" : undefined;
+                items.push(appItem);
+            }
         }
         else {
             // Several trees and none chosen: pick one first.
@@ -180,6 +262,10 @@ export async function runMenu(ctx, run) {
         if (root)
             items.push({ key: "8", label: known.length > 1 ? t("ui.menu.trees") : t("ui.menu.newtree"), act: async () => pickTree(ctx, run, lang) });
         items.push({ key: "0", label: t("ui.menu.quit"), act: async () => true });
+        // One quiet line on the Strom app: what it can do while the person has not said, or that the agent can be watched now.
+        const numbered = items.filter((it) => it.key !== "0");
+        if (appItem && appTip)
+            out(t(appTip, { key: numbered.indexOf(appItem) + 1 }));
         // Numbered in the order shown; 0 always quits.
         let n = 0;
         const i = await ctx.choose("", items.map((it) => ({ key: it.key === "0" ? "0" : String(++n), label: it.label })), 0);
@@ -192,18 +278,148 @@ export async function runMenu(ctx, run) {
         }
     }
 }
-/** Choose another family tree, or create a new one (and start its research). */
+/** How many tasks of the queue the menu lists before the agent works alone. */
+const RUN_LIST = 15;
+/** "2", "1,4", "2-5", "1 3 6-8" → those numbers (1…max), in the order given, each once; undefined when anything else. */
+export function pickNumbers(answer, max) {
+    const out = [];
+    for (const part of answer.replace(/\s*[-–]\s*/g, "-").split(/[\s,;]+/).filter(Boolean)) {
+        const m = /^(\d+)(?:\s*[-–]\s*(\d+))?$/.exec(part);
+        if (!m)
+            return undefined;
+        const [a, b] = [Number(m[1]), Number(m[2] ?? m[1])];
+        if (a < 1 || b > max || a > b)
+            return undefined;
+        for (let k = a; k <= b; k++)
+            if (!out.includes(k))
+                out.push(k);
+    }
+    return out.length ? out : undefined;
+}
+/** Ask for a person by name or ID; several match: pick one. Nobody (Enter, or no answers left): undefined. */
+async function pickPerson(ctx, lang, root, question, suggested) {
+    const tree = Tree.open(root, ctx.env);
+    for (;;) {
+        if (ctx.io.answers !== undefined && ctx.io.answers.length === 0)
+            return undefined;
+        const who = (await ctx.ask(question, suggested)).trim();
+        if (!who || who === "0")
+            return undefined;
+        const byId = /^P\d+$/i.test(who) ? tree.get(who.toUpperCase()) : undefined;
+        const hits = byId && !byId.retracted ? [byId] : findPersons(tree, who);
+        if (!hits.length)
+            ctx.io.stdout(ui(lang, "ui.review.none", { who }) + "\n");
+        else if (hits.length === 1)
+            return hits[0];
+        else {
+            const i = await ctx.choose(ui(lang, "ui.review.pick"), hits.slice(0, 9).map((p) => ({ label: label(p) })), 0, { back: ui(lang, "ui.browse.back") });
+            return i === undefined ? undefined : hits[i];
+        }
+    }
+}
+/**
+ * Look through the family tree: the research at a glance, what is new, what the agent does next, one person, the
+ * ancestors of one, and the result files — each an ordinary command (stats, recent, plan, person card, pedigree),
+ * shown in the person's language.
+ */
+async function browse(ctx, run, lang, root) {
+    const t = (key, values = {}) => ui(lang, key, values);
+    const out = (line = "") => ctx.io.stdout(line + "\n");
+    const pause = async () => {
+        if (!(ctx.io.answers !== undefined && ctx.io.answers.length === 0))
+            await ctx.ask(t("ui.enter"));
+    };
+    for (;;) {
+        if (ctx.io.answers !== undefined && ctx.io.answers.length === 0)
+            return;
+        const tree = Tree.open(root, ctx.env);
+        const people = tree.count("person") > 0;
+        const items = [
+            ...(people
+                ? [
+                    { key: "1", label: t("ui.browse.stats"), act: async () => void (await run(["stats"])) },
+                    { key: "2", label: t("ui.browse.recent"), act: async () => void (await run(["recent"])) },
+                    { key: "2", label: t("ui.browse.plan"), act: async () => void (await run(["plan"])) },
+                    {
+                        key: "3",
+                        label: t("ui.browse.card"),
+                        act: async () => {
+                            const p = await pickPerson(ctx, lang, root, t("ui.review.who"));
+                            if (p)
+                                await run(["person", "card", p.id]);
+                        },
+                    },
+                    {
+                        key: "4",
+                        label: t("ui.browse.pedigree"),
+                        act: async () => {
+                            const main = mainPerson(tree);
+                            const p = await pickPerson(ctx, lang, root, t("ui.browse.whose"), main ? displayName(tree.get(main)) : undefined);
+                            if (p)
+                                await run(["pedigree", p.id]);
+                        },
+                    },
+                ]
+                : []),
+            {
+                key: "5",
+                label: t("ui.browse.files"),
+                act: async () => {
+                    const outDir = path.join(root, "output");
+                    const geds = ["tree.ged", "tree-strom.ged"].map((f) => path.join(outDir, f)).filter((f) => fs.existsSync(f));
+                    if (!geds.length)
+                        out(t("ui.results.none"));
+                    else {
+                        out(t("ui.results.files"));
+                        for (const g of geds)
+                            out(`  ${ctx.display(g)}`);
+                        const strom = geds.find((g) => g.endsWith("tree-strom.ged"));
+                        const app = stromAppState(ctx.settings);
+                        if (strom && (app === "yes" || app === "seen"))
+                            out(t("ui.results.app", { file: ctx.display(strom) }));
+                        else if (strom && app === "unknown")
+                            out(t("ui.results.app.maybe", { file: ctx.display(strom) }));
+                        if (await ctx.confirm(t("ui.results.open"), false))
+                            openForUser(outDir, ctx.env);
+                    }
+                },
+            },
+            ...(stromAppState(ctx.settings) === "no" ? [] : [{ key: "6", label: t("ui.menu.app"), act: async () => void (await run(["app"])) }]),
+            { key: "0", label: t("ui.browse.back"), act: async () => true },
+        ];
+        out();
+        let n = 0;
+        const i = await ctx.choose("", items.map((it) => ({ key: it.key === "0" ? "0" : String(++n), label: it.label })), 0);
+        if (i === undefined)
+            return;
+        if ((await items[i].act()) === true)
+            return;
+        await pause();
+    }
+}
+/** Choose another family tree, or create a new one (and start its research). The one worked on now is suggested; 0 stays with it. */
 async function pickTree(ctx, run, lang) {
     const known = ctx.knownTrees();
+    let here;
+    try {
+        here = ctx.locateTree();
+    }
+    catch {
+        here = undefined;
+    }
+    const at = known.findIndex((k) => k.root === here);
     const options = [...known.map((k) => ({ label: `${k.name}  (${ctx.display(k.root)})` })), { label: ui(lang, "ui.trees.new") }];
-    const i = await ctx.choose(ui(lang, "ui.trees.pick"), options, 0);
-    if (i === undefined)
+    const back = at >= 0 ? { back: ui(lang, "ui.back.stay", { name: known[at].name }) } : {};
+    const i = await ctx.choose(ui(lang, "ui.trees.pick"), options, Math.max(0, at), back);
+    if (i === undefined || i === at)
         return;
     if (i < known.length) {
         await run(["trees", "use", known[i].root], true);
         return;
     }
-    const name = await ctx.ask(ui(lang, "ui.tree.name"), ui(lang, "ui.tree.default"));
+    const name = (await ctx.ask(ui(lang, "ui.tree.name.new"), ui(lang, "ui.tree.default"))).trim();
+    if (name === "0")
+        return;
     const made = await createTree(ctx, run, lang, name);
     if (!made)
         return;

package/dist/cli/ui.js

@@ -17,6 +17,9 @@ export const UI = {
     "ui.consent.level.full": "Let the agent do everything except what strom forbids, without asking you?\n\nOnly for a computer where nothing else of value is kept.",
     "ui.consent.connector": "Allow the downloader \"{name}\" to fetch images for the research?",
     "ui.consent.connector.revoke": "Stop the downloader \"{name}\"?",
+    "ui.consent.host.pace": "Your own pace for {host}: at least {seconds} s between two requests, {cap}. Going too fast slows the archive for everyone and can get your IP blocked — set it so?",
+    "ui.pace.cap": "at most {n} an hour",
+    "ui.pace.nocap": "no hourly cap",
     "ui.consent.host": "Allow automatic downloading from {host}?",
     "ui.consent.host.revoke": "Stop automatic downloading from {host}?",
     "ui.consent.connector.hosts": "It will reach only {hosts} — slowly, through strom's limiter.",
@@ -25,6 +28,7 @@ export const UI = {
     "ui.consent.connector.terms": "The archive's terms of use: {terms}",
     "ui.consent.host.unblock": "{host} refused us. Allow it again — only if the archive said it is fine?",
     "ui.consent.connectors.off": "Let downloaders run without asking you first?",
+    "ui.migrated": "The family tree's data were brought up to date for this version of strom ({step}).",
     "ui.menu.title": "Strom research {version}",
     "ui.menu.tree": "Family tree: {name} · {persons} people",
     "ui.menu.waiting": "Waiting for you: {count}",
@@ -34,14 +38,13 @@ export const UI = {
     "ui.menu.otheragent": "Talk with another agent this time",
     "ui.menu.run": "Let the agent work on its own",
     "ui.menu.waitlist": "What waits for you",
-    "ui.menu.results": "Results",
     "ui.menu.settings": "Settings",
     "ui.menu.doctor": "Check the installation",
     "ui.menu.trees": "Another family tree",
     "ui.menu.newtree": "Create a family tree",
     "ui.menu.quit": "Quit",
     "ui.menu.bye": "See you next time. Start again with: strom",
-    "ui.run.how": "How many tasks should the agent work on? (it stops earlier when there is nothing to do)",
+    "ui.run.how": "How many tasks? (it stops earlier when there is nothing to do; 0 goes back)",
     "ui.run.start": "The agent works on its own now. You can stop it with Ctrl-C — nothing is lost.",
     "ui.waiting.none": "Nothing waits for you.",
     "ui.waiting.open": "Open the folder for the images?",
@@ -56,7 +59,7 @@ export const UI = {
     "ui.tree.default": "My family",
     "ui.chat.open": "Opening the conversation with the agent ({agent}). When you are done, type {exit}.",
     "ui.chat.first": "Hello, I want to start researching my ancestors. Run `strom`, explain to me in a few sentences how we will work together, and ask me whom we are looking for and what we already know.",
-    "ui.chat.continue": "Let's continue the research. Run `strom`, tell me briefly where the research stands and what waits for me, suggest what to do next, and tell me in a sentence what I can ask you about the tree.",
+    "ui.chat.continue": "Let's continue the research. Run `strom`, tell me briefly where the research stands and what waits for me, and suggest what to do next.",
     "ui.setup.welcome": "Welcome to Strom research. Let's set up a few things — press Enter to accept the suggested answer.",
     "ui.setup.again": "Settings — press Enter to keep the current value.",
     "ui.setup.lang": "Language (cs, en, de, pl, …)",
@@ -86,14 +89,24 @@ export const UI = {
     "ui.setup.shortcut": "Put a \"Strom research\" shortcut on the desktop?",
     "ui.setup.shortcut.done": "✓ Shortcut: {file}",
     "ui.setup.skill": "✓ {agent} now knows strom in any folder.",
-    "ui.setup.app": "✓ The Strom app is on this computer — results will be ready to import into it.",
+    "ui.setup.app": "✓ The Strom app is on this computer — the menu opens the research in it, and while the agent works the app follows it live.",
     "ui.setup.done": "All set.",
+    "ui.setup.stromapp": "The Strom app (free, in the browser) shows the research as a family tree — each entry with its image cut out of the scan, the stories of the ancestors — and follows it live while the agent works. Do you want to use it?",
+    "ui.setup.stromapp.install": "Yes — install it now (it opens in the browser, strom says where to click)",
+    "ui.setup.stromapp.later": "Yes, but not now",
+    "ui.setup.stromapp.no": "No — do not mention it again",
+    "ui.menu.app.watch": "Watch the agent at work in the Strom app (live)",
+    "ui.menu.app.new": "The Strom app — the research as a family tree, followed live",
+    "ui.menu.app.tip": "Tip: the research can be seen as a family tree in the Strom app, and followed live while the agent works — choice {key}.",
+    "ui.menu.app.live": "The agent is at work — you can watch it live in the Strom app: choice {key}.",
+    "ui.app.open.now": "Once it is installed: open the research in it?",
+    "ui.run.follow": "Watch the work live in the Strom app meanwhile?",
     "ui.app.opened": "Opening the Strom app ({where}).",
     "ui.app.browser": "in your browser",
     "ui.app.url": "Open it here: {url}",
     "ui.app.installed": "The Strom app is installed ({kind}).",
     "ui.app.install": "The Strom app opened in your browser. To install it as an app, click the install icon at the right end of the address bar (Chrome, Edge); in Safari choose File → Add to Dock.",
-    "ui.menu.app": "Open the Strom app",
+    "ui.menu.app": "Open the research in the Strom app",
     "ui.chat.agent.missing": "{agent} is not installed — run the settings (strom setup) to install it.",
     "ui.shortcut.done": "Shortcut on the desktop: {file}",
     "ui.o.title": "strom {version} — genealogical research toolkit for AI agents",
@@ -208,17 +221,29 @@ export const UI = {
     "ui.o.results": "results",
     "ui.o.results.installed": "{file} — for the Strom app, installed here: strom app opens it (in the app: Import; on the web: {url})",
     "ui.o.results.offer": "{file} — for the Strom app, not installed here yet: offer the user to install it from {url} (strom app install opens it there)",
+    "ui.o.results.offered": "{file} — for the Strom app, not installed here; the user has heard of it — bring it up again only when they want to see the results (strom app install, then strom app)",
+    "ui.o.ask": "asking",
+    "ui.o.ask.tell": "tell the user once, in a sentence, that they can ask you here about anyone in the tree — strom says this once",
     "ui.o.results.plain": "{file} — for any family tree program",
-    "ui.o.results.installed.live": "{file} — for the Strom app, installed here: strom app opens this research in it, and while you work the app follows it live (what you record shows there by itself) — offer it once",
+    "ui.o.results.installed.live": "{file} — for the Strom app, installed here: strom app opens this research in it, and while you work the app follows it live (what you record shows there by itself) — offer it (strom says this once)",
     "ui.o.results.offer.live": "{file} — for the Strom app, not installed here yet: offer the user to watch the research grow in it live — installed from {url} (strom app install opens it there and says where to click), then strom app",
     "ui.chat.handover": "The research goes on in its own conversation: a new window opened with {agent} in your family tree's folder. Continue there — this conversation can end.",
     "ui.chat.handover.failed": "A new window could not be opened here. Start the research yourself: run strom in a terminal (or the Strom research shortcut on the desktop).",
+    "ui.chat.handover.recent": "A window with the research and {agent} opened a moment ago — continue there. This conversation can end.",
     "ui.chat.handover.end": "Continue there — this conversation can end.",
     "ui.why.handover": "the research belongs in its own conversation in the tree folder (its permissions, no asking at every step): this opens it — tell the user to continue there; go on here only if they want",
     "ui.app.research": "Opening the research {name} in the Strom app ({where}): the first time as a new tree, after that the same tree, updated.",
     "ui.app.following": "The Strom app follows the research {name} while it goes on ({where}): what is found shows there by itself.",
+    "ui.menu.review": "Review one person: check and complete what is known of them",
+    "ui.review.who": "Whom? (a name or an ID such as P0012; Enter or 0 goes back)",
+    "ui.review.none": "Nobody called \"{who}\" in this family tree.",
+    "ui.review.pick": "Which one?",
+    "ui.review.family": "With their spouse and children?",
+    "ui.review.run": "Let the agent work on it now, on its own? ({n} tasks)",
+    "ui.o.reread": "second reading",
+    "ui.o.reread.offer": "{n} facts rest only on readings by another model ({models}); the user reads with {model} now — offer it once, in a sentence: strom review <whom> --reread (a task per person; the user decides)",
     "ui.o.stories": "stories",
-    "ui.o.stories.tell": "on (the default): when the research starts, tell the user in a sentence that you will also write stories of their ancestors for the family book in the Strom app, and that they may say no — strom config set stories no (yes: strom config set stories yes)",
+    "ui.o.stories.tell": "on (the default): tell the user (strom says this once) in a sentence that you will also write stories of their ancestors for the family book in the Strom app, and that they may say no — strom config set stories no (yes: strom config set stories yes)",
     "ui.o.stories.on": "on: strom proposes a story once records tell a life (narrate tasks)",
     "ui.o.stories.off": "off (the user said no) — do not bring it up",
     "ui.setup.model.strong": "The research needs a strong model — it reads old handwriting and weighs the records: in {agent}, choose its best model, not a fast or mini one.",
@@ -254,11 +279,135 @@ export const UI = {
     "ui.update.done": "✓ strom is updated: {previous} → {version}.",
     "ui.o.update": "update",
     "ui.o.update.new": "{version} is out (this is {current}) — tell the user; strom update installs it with their yes",
+    "ui.app.where.installed": "the installed app",
     "ui.app.drag": "The Strom app opened. Drag the file {file}{shown} into its window — the first time it becomes a new tree, after that the same tree is updated. With Chrome or Edge on this computer, strom hands it over by itself.",
     "ui.app.drag.shown": " (shown in the file window)",
     "ui.app.nolive": "Following the research live needs Chrome or Edge — Safari does not let a web page reach this computer.",
+    "ui.app.images": "With images: {n} entries cut out of their scans ({mb} MB).",
+    "ui.app.images.unclipped": "{n} more sources are on images, but nobody has marked where their entry is yet — the agent can do it.",
+    "ui.app.images.smaller": "To fit the limit of {limit} MB, the images are smaller than set: {level} instead of {asked}.",
+    "ui.app.images.left": "{n} entries farthest from the research are without their image, to fit the limit of {limit} MB.",
+    "ui.app.images.scope": "{n} entries of people farther from the research have no image (setting excerpts.for: {for}).",
     "ui.doc.installed": "strom {version} on its own Node {node} (official, from nodejs.org)",
     "ui.update.source": "A new version is out: {version}. This strom runs from its sources: git pull",
+    "ui.update.node.available": "Node {from} → {to}: security fixes of its line — strom update installs them.",
+    "ui.update.node.sure": "Update strom's Node from {from} to {to} (security fixes)?",
+    "ui.update.node.done": "✓ Node is updated: {from} → {to}.",
+    "ui.menu.browse": "Look through the family tree: overview, people, ancestors, what is new",
+    "ui.browse.stats": "Overview of the research",
+    "ui.browse.recent": "What is new (the last 7 days)",
+    "ui.browse.card": "One person: their life, family and records",
+    "ui.browse.pedigree": "The ancestors of one person",
+    "ui.browse.files": "The result files (GEDCOM)",
+    "ui.browse.back": "Back",
+    "ui.browse.whose": "Whose ancestors? (a name or an ID such as P0012; 0 goes back)",
+    "ui.date.about": "about {date}",
+    "ui.date.before": "before {date}",
+    "ui.date.after": "after {date}",
+    "ui.date.between": "between {a} and {b}",
+    "ui.date.fromto": "from {a} to {b}",
+    "ui.date.from": "from {date}",
+    "ui.date.to": "until {date}",
+    "ui.st.proven": "proven",
+    "ui.st.probable": "probable",
+    "ui.st.possible": "possible",
+    "ui.st.lead": "only a lead",
+    "ui.ev.BIRT": "birth",
+    "ui.ev.CHR": "baptism",
+    "ui.ev.DEAT": "death",
+    "ui.ev.BURI": "burial",
+    "ui.ev.CREM": "cremation",
+    "ui.ev.MARR": "marriage",
+    "ui.ev.MARB": "banns",
+    "ui.ev.ENGA": "engagement",
+    "ui.ev.DIV": "divorce",
+    "ui.ev.OCCU": "occupation",
+    "ui.ev.RESI": "residence",
+    "ui.ev.EDUC": "education",
+    "ui.ev.RELI": "religion",
+    "ui.ev.TITL": "title",
+    "ui.ev.CENS": "census",
+    "ui.ev.CONF": "confirmation",
+    "ui.ev.EMIG": "emigration",
+    "ui.ev.IMMI": "immigration",
+    "ui.ev.NATU": "naturalisation",
+    "ui.ev.PROB": "probate",
+    "ui.ev.WILL": "will",
+    "ui.gen.2": "parents",
+    "ui.gen.3": "grandparents",
+    "ui.gen.4": "great-grandparents",
+    "ui.gen.5": "great-great-grandparents",
+    "ui.gen.n": "generation {n}",
+    "ui.card.house": "{place}, house {house}",
+    "ui.card.also": "other forms of the name: {names}",
+    "ui.card.nofacts": "no facts recorded yet",
+    "ui.card.parents": "Parents: {names}",
+    "ui.card.noparents": "Parents: not known yet",
+    "ui.card.wife": "Wife: {name}",
+    "ui.card.husband": "Husband: {name}",
+    "ui.card.partner": "Partner: {name}",
+    "ui.card.unknown": "not known yet",
+    "ui.card.children": "Children: {names}",
+    "ui.card.story": "Story ({status}):",
+    "ui.card.story.draft": "a draft",
+    "ui.card.story.final": "approved",
+    "ui.stats.title": "{name} – the research at a glance",
+    "ui.stats.counts": "People: {persons} · families: {families} · records from sources: {sources} · scans: {images} · places: {places}",
+    "ui.stats.facts": "Facts: proven {proven} · probable {probable} · possible {possible} · only leads {lead}",
+    "ui.stats.from": "Ancestors of {name}:",
+    "ui.stats.gen": "{known} of {expected} known · birth proven: {proven}",
+    "ui.stats.oldest": "Earliest-born proven ancestor: {name}",
+    "ui.stats.noancestors": "No ancestors recorded yet.",
+    "ui.stats.tasks": "Tasks: in the queue {queued} · waiting for you {waiting} · done {done}",
+    "ui.stats.sessions": "Sessions of the agent: {n} · the last {last}",
+    "ui.stats.cost": " · cost so far {cost}",
+    "ui.stats.stories": "Stories: {n} (approved {final})",
+    "ui.ped.noparents": "parents not known yet",
+    "ui.ped.nofather": "father not known yet",
+    "ui.ped.nomother": "mother not known yet",
+    "ui.ped.seen": "(shown above)",
+    "ui.ped.legend": "Father first, then mother · ✓ birth proven by a record",
+    "ui.ped.more": "The known ancestors go on to generation {n}: strom pedigree {id} --generations {n}",
+    "ui.recent.title": "What came in since {since}",
+    "ui.recent.nothing": "Nothing new since {since}.",
+    "ui.recent.counts": "New people: {persons} · facts: new {facts}, refined {refined} · records from sources: {sources} · stories: {stories} · tasks done: {done}",
+    "ui.recent.persons": "New people:",
+    "ui.recent.facts": "New and refined facts:",
+    "ui.recent.refined": "refined",
+    "ui.recent.stories": "Stories written:",
+    "ui.recent.sessions": "What the agent did:",
+    "ui.recent.more": "… and {n} more",
+    "ui.browse.plan": "What the agent will do next",
+    "ui.plan.title": "What the agent will do next – {name}:",
+    "ui.plan.now": "now",
+    "ui.plan.images": " (needs the scans first)",
+    "ui.plan.more": "… and {n} more tasks",
+    "ui.plan.stories": "Then the stories: {n} ({names})",
+    "ui.plan.waiting": "Waiting for you: {n} (in the menu: What waits for you)",
+    "ui.plan.none": "Nothing in the queue — the agent proposes new tasks after its next session, or tell it in a conversation what to look for.",
+    "ui.plan.steer": "To change the order, tell the agent in a conversation what comes first.",
+    "ui.plan.session": "the session of {day}",
+    "ui.back.stay": "Back – stay with {name}",
+    "ui.keep": "Keep it as it is",
+    "ui.tree.name.new": "What should the new family tree be called? (e.g. the family surname; 0 goes back)",
+    "ui.run.skip": "  · {task} left out: it is done or dropped already",
+    "ui.run.skip.held": "  · {task} left out: another agent is working on it",
+    "ui.run.next": "Next in the queue, in the order the agent takes them:",
+    "ui.run.story": " (a story)",
+    "ui.run.what": "What should the agent do?",
+    "ui.run.queue": "Work through the queue in this order – you say how many",
+    "ui.run.pick": "Only the tasks you pick from the list",
+    "ui.run.which": "Which ones? Their numbers, e.g. 2 or 1,4 or 2-5 (0 goes back)",
+    "ui.run.which.bad": "Numbers from the list, 1 to {n}: e.g. 2 or 1,4 or 2-5.",
+    "ui.run.limit": "One task has at most {minutes} minutes; then the agent is stopped and the task goes back to the queue (setting run.minutes).",
+    "ui.run.empty": "Nothing in the queue — tell the agent in a conversation what to look for.",
+    "ui.run.browser": "· {name}: images through your browser — the agent gets browser tools for {hosts}; Chrome with the Claude extension must be running",
+    "ui.run.browser.model": "  note: browser tools need a model that can review its actions — Sonnet or Opus, not {model}: strom config set model.lead sonnet",
+    "ui.run.full": "· permissions: full — the agent does everything but what the tree's permissions deny (back: strom config set agent.permissions auto)",
+    "ui.menu.working.more": "{n} agents are working on their own right now.",
+    "ui.run.beside": "⚠ An agent is already working on its own here (runs: {n}). Another one beside it takes other tasks — the costs add up.",
+    "ui.run.beside.sure": "Start another one beside it?",
+    "ui.run.others": "⚠ Another run works in this family tree already (since {since}): this one takes other tasks — the costs add up.",
 };
 /** A text for the person, in their language. */
 export function ui(lang, key, values = {}) {