strom-research 1.2.0 → 1.4.0

package/dist/cli/menu-waiting.js

@@ -0,0 +1,79 @@
+// The menu's "What waits for you": each task that waits for the person, what
+// to do for it (in their language, as the agent wrote it), the folder for the
+// images they save by hand — and their answer, taken in here (strom task wake
+// --answer): the task goes back to the agent with it.
+import path from "node:path";
+import { subMenu, translator } from "./menu-parts.js";
+import { offerChat } from "./menu-research.js";
+import { truncate } from "./format.js";
+import { Tree } from "../core/tree.js";
+import { openForUser } from "../core/open.js";
+/** At most this many are listed to answer (the menu's nine); the rest after them. */
+const SHOWN = 9;
+/** An answer is a note on the task (500 characters, with what it asked). */
+const ANSWER_MAX = 300;
+export async function waitingForYou(ctx, run, lang, root) {
+    const t = translator(lang);
+    const out = (line) => ctx.io.stdout(line + "\n");
+    const shared = ctx.settings.shared()?.value;
+    const inbox = (x) => (shared && x.awaits ? path.join(shared, "inbox", x.awaits.folder) : undefined);
+    await subMenu(ctx, lang, () => {
+        const tree = Tree.open(root, ctx.env);
+        const waiting = tree.list("task").filter((x) => x.state === "waiting");
+        if (!waiting.length)
+            return { title: t("ui.waiting.none"), items: [] };
+        const shown = waiting.slice(0, SHOWN);
+        const text = [t("ui.waiting.title", { n: waiting.length })];
+        for (const [k, x] of shown.entries()) {
+            text.push("", ` ${k + 1}. ${x.what}`);
+            if (x.awaits) {
+                const b = tree.get(x.awaits.recordset);
+                text.push(`    ${t("ui.waiting.images", { images: x.awaits.images, book: b?.title ?? x.awaits.recordset })}${b?.url ? ` · ${b.url}` : ""}`);
+                text.push(`    ${t("ui.wait.save", { dir: `${ctx.display(inbox(x) ?? `inbox/${x.awaits.folder}`)}${path.sep}` })}`);
+            }
+            else
+                text.push(`    ${t("ui.waiting.do", { what: x.waitingOn || t("ui.waiting.ask") })}`);
+        }
+        if (shown.some((x) => x.awaits))
+            text.push("", t("ui.wait.how1"), t("ui.wait.how2"));
+        if (waiting.length > SHOWN)
+            text.push("", t("ui.waiting.more", { n: waiting.length - SHOWN }));
+        const items = shown.map((x, k) => x.awaits
+            ? {
+                key: String(k + 1),
+                label: t("ui.waiting.folder", { k: k + 1 }),
+                act: async () => {
+                    const dir = inbox(x);
+                    if (dir)
+                        openForUser(dir, ctx.env);
+                    out(t("ui.waiting.opened", { dir: dir ? ctx.display(dir) : `inbox/${x.awaits.folder}` }));
+                },
+            }
+            : {
+                key: String(k + 1),
+                label: t("ui.waiting.answer", { k: k + 1, what: truncate(x.what, 60) }),
+                act: async () => {
+                    let answer = "";
+                    for (;;) {
+                        answer = (await ctx.ask(t("ui.waiting.write"))).trim();
+                        if (!answer || answer === "0")
+                            return;
+                        // kept as a note on the task, with what it asked: short — a longer story is for a conversation
+                        if (answer.length <= ANSWER_MAX)
+                            break;
+                        out(t("ui.waiting.long", { n: ANSWER_MAX }));
+                        if (ctx.io.answers !== undefined && ctx.io.answers.length === 0)
+                            return;
+                    }
+                    // meanwhile taken up by an agent (done, dropped, back in the queue): said, nothing written
+                    if (Tree.open(root, ctx.env).get(x.id)?.state !== "waiting")
+                        return void out(t("ui.waiting.gone"));
+                    if ((await run(["task", "wake", x.id, `--answer=${answer}`], true)) !== 0)
+                        return;
+                    out(t("ui.waiting.back"));
+                    await offerChat(ctx, run, lang, root, t("ui.waiting.chat"), t("ui.waiting.say", { what: truncate(x.what, 80) }));
+                },
+            });
+        return { title: `${text.join("\n")}\n\n${t("ui.waiting.pick")}`, items };
+    });
+}

package/dist/cli/menu.js

@@ -24,7 +24,12 @@ 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 { displayName } from "../core/people.js";
+import { agentReady, guarded, pause as partsPause, pickPerson, subMenu } from "./menu-parts.js";
+import { offerAgent } from "./fixes.js";
+import { addToResearch } from "./menu-research.js";
+import { waitingForYou } from "./menu-waiting.js";
+import { settingsMenu } from "./menu-settings.js";
 import { mainPerson } from "../core/kin.js";
 import { AGENTS, findAgent } from "../core/which.js";
 import { agentsHere } from "../core/apps.js";
@@ -72,10 +77,13 @@ export async function runMenu(ctx, run) {
             if (outOfAnswers())
                 return;
             const name = await ctx.ask(t("ui.tree.name"), t("ui.tree.default"));
-            if (!(await createTree(ctx, run, lang, name)))
+            const made = await createTree(ctx, run, lang, name);
+            if (!made)
                 return;
             reload();
-            await run(["chat"]);
+            // Straight into the first conversation — with an agent here; without one, the menu says how to get it.
+            if (agentReady(ctx, Tree.open(made, ctx.env).config))
+                await run(["chat"]);
             if (outOfAnswers())
                 return;
             continue;
@@ -83,26 +91,48 @@ export async function runMenu(ctx, run) {
         const items = [];
         let appItem;
         let appTip;
+        let other;
         out();
         out(t("ui.menu.title", { version: VERSION }));
         const newer = await newerVersion(ctx.settings, ctx.env);
-        if (newer)
-            out(t("ui.menu.update.line", { version: newer }));
         if (root) {
             const tree = Tree.open(root, ctx.env);
             const waiting = waitingForUser(tree).length;
             const started = tree.list("research").length > 0;
             out(t("ui.menu.tree", { name: tree.config.name, persons: tree.count("person") }));
+            // No agent yet (none installed, or not the one chosen): the research waits for it, and item 1 gets one.
+            const ready = agentReady(ctx, tree.config);
+            if (!ready)
+                out(t(agentsHere(ctx.env).length ? "ui.menu.noagent.chosen" : "ui.menu.noagent"));
             if (waiting)
                 out(t("ui.menu.waiting", { count: waiting }));
             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"])) }, {
+            items.push(ready
+                ? { key: "1", label: t(started ? "ui.menu.chat" : "ui.menu.start"), act: async () => void (await run(["chat"])) }
+                : {
+                    key: "1",
+                    label: t("ui.menu.getagent"),
+                    act: async () => {
+                        // Nothing here at all: Claude Code offered (or the page about agents); another one here: the wizard lets them pick it.
+                        if (agentsHere(ctx.env).length)
+                            await run(["setup"]);
+                        else
+                            await offerAgent(ctx, out);
+                        await pause(lang);
+                    },
+                }, {
                 key: "2",
                 label: t("ui.menu.run"),
                 act: async () => {
                     // Working alone is the agent's CLI; with only its app on this computer, strom says so.
+                    // No agent here yet: said, and item 1 gets one — the item stays, so the numbers never move.
+                    if (!ready) {
+                        out(t(agentsHere(ctx.env).length ? "ui.menu.noagent.chosen" : "ui.menu.noagent"));
+                        await pause(lang);
+                        return;
+                    }
                     const who = PROFILES[ctx.settings.agent(tree.config).value];
                     if (who && !findAgent(who.command, ctx.env)) {
                         out(t("ui.run.needscli", { agent: who.name }));
@@ -182,44 +212,28 @@ export async function runMenu(ctx, run) {
                 key: "3",
                 label: `${t("ui.menu.waitlist")}${waiting ? ` (${waiting})` : ""}`,
                 act: async () => {
-                    if (!waiting)
-                        out(t("ui.waiting.none"));
-                    else {
-                        await run(["task", "list", "--state", "waiting"]);
-                        const inbox = ctx.settings.shared() ? path.join(ctx.settings.shared().value, "inbox") : undefined;
-                        if (inbox && (await ctx.confirm(t("ui.waiting.open"), false)))
-                            openForUser(inbox, ctx.env);
-                    }
+                    if (waiting)
+                        return waitingForYou(ctx, run, lang, root);
+                    out(t("ui.waiting.none"));
                     await pause(lang);
                 },
+            }, {
+                key: "4",
+                label: t("ui.menu.more"),
+                act: async () => addToResearch(ctx, run, lang, root),
             }, {
                 key: "4",
                 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)
                 .filter((a) => a.id !== current)
                 .map((a) => AGENTS.find((x) => x.id === a.id));
-            if (others.length)
-                items.push({
+            other = !others.length
+                ? undefined
+                : {
                     key: "9",
                     label: t("ui.menu.otheragent"),
                     act: async () => {
@@ -228,7 +242,7 @@ export async function runMenu(ctx, run) {
                         if (i !== undefined)
                             await run(["chat", "--agent", others[i].id]);
                     },
-                });
+                };
             // 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") {
@@ -237,13 +251,7 @@ export async function runMenu(ctx, run) {
                 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"]);
-                    },
+                    act: async () => openStromApp(ctx, run, lang, hasApp),
                 };
                 appTip = !hasApp ? "ui.menu.app.tip" : atWork ? "ui.menu.app.live" : undefined;
                 items.push(appItem);
@@ -253,31 +261,28 @@ export async function runMenu(ctx, run) {
             // Several trees and none chosen: pick one first.
             items.push({ key: "1", label: t("ui.menu.trees"), act: async () => pickTree(ctx, run, lang) });
         }
-        items.push({ key: "6", label: t("ui.menu.settings"), act: async () => void (await run(["setup"])) }, {
-            key: "7",
-            label: t("ui.menu.doctor"),
-            act: async () => {
-                const code = await run(["doctor"]);
-                if (code !== 0 && (await ctx.confirm(t("ui.menu.fix"), true)))
-                    await run(["doctor", "--fix"]);
-                await pause(lang);
-            },
-        });
-        if (newer)
-            items.push({ key: "9", label: t("ui.menu.update", { version: newer }), act: async () => void (await run(["update"])) });
+        // What changes nothing of the research: the newer strom, the settings of this computer (with the check), another tree.
+        // At most nine: the newer strom is taken in the settings, the line above says where.
+        const settings = { key: "6", label: t("ui.menu.settings"), act: async () => settingsMenu(ctx, run, lang, root, newer) };
+        items.push(settings);
         if (root)
             items.push({ key: "8", label: known.length > 1 ? t("ui.menu.trees") : t("ui.menu.newtree"), act: async () => pickTree(ctx, run, lang) });
+        // Only with several agents here: last, so that it moves no other number.
+        if (other)
+            items.push(other);
         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 }));
+        if (newer)
+            out(t("ui.menu.update.where", { version: newer, key: numbered.indexOf(settings) + 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);
         if (i === undefined)
             return;
-        const quit = await items[i].act();
+        const quit = await guarded(ctx, lang, items[i].act);
         if (quit === true) {
             out(t("ui.menu.bye"));
             return;
@@ -316,27 +321,6 @@ export function pickNumbers(answer, max) {
     }
     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),
@@ -345,28 +329,27 @@ async function pickPerson(ctx, lang, root, question, suggested) {
 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"));
+    // A long answer waits for Enter before the menu comes again; 0 anywhere goes back without it.
+    const show = async (argv) => {
+        await run(argv);
+        await partsPause(ctx, lang);
     };
-    for (;;) {
-        if (ctx.io.answers !== undefined && ctx.io.answers.length === 0)
-            return;
+    await subMenu(ctx, lang, () => {
         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: "1", label: t("ui.browse.stats"), act: async () => show(["stats"]) },
+                    { key: "2", label: t("ui.browse.recent"), act: async () => show(["recent"]) },
+                    { key: "2", label: t("ui.browse.plan"), act: async () => show(["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]);
+                                await show(["person", "card", p.id]);
                         },
                     },
                     {
@@ -376,7 +359,7 @@ async function browse(ctx, run, lang, root) {
                             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]);
+                                await show(["pedigree", p.id]);
                         },
                     },
                 ]
@@ -404,18 +387,28 @@ async function browse(ctx, run, lang, root) {
                     }
                 },
             },
-            ...(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 },
+            ...(stromAppState(ctx.settings) === "no" ? [] : [{ key: "6", label: t("ui.menu.app"), act: async () => openStromApp(ctx, run, lang, stromAppState(ctx.settings) !== "unknown") }]),
         ];
-        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();
+        return { items };
+    });
+}
+/**
+ * The Strom app: not asked about yet — what it is, and whether they want it; wanted but not installed here — installing
+ * it from the browser (an app of its own, PWA) is offered first, else it opens in the browser; installed — it opens.
+ */
+async function openStromApp(ctx, run, lang, said) {
+    const t = (key) => ui(lang, key);
+    if (!said) {
+        const answer = await askStromApp(ctx, lang);
+        if (answer === "install" && (await ctx.confirm(t("ui.app.open.now"), true)))
+            await run(["app"]);
+        return;
+    }
+    if (!installedStromApp(ctx.env, process.platform, stromAppUrl(ctx.settings)) && (await ctx.confirm(t("ui.app.notinstalled"), true))) {
+        await run(["app", "install"]);
+        return;
     }
+    await run(["app"]);
 }
 /** 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) {
@@ -444,5 +437,6 @@ async function pickTree(ctx, run, lang) {
     if (!made)
         return;
     await run(["trees", "use", made], true);
-    await run(["chat"]);
+    if (agentReady(ctx, Tree.open(made, ctx.env).config))
+        await run(["chat"]);
 }

package/dist/cli/registry.js

@@ -22,7 +22,7 @@ export const GLOBAL_OPTIONS = [
     { name: "home", type: "string", value: "<dir>", description: "Strom home folder (default from config)" },
     { name: "shared", type: "string", value: "<dir>", description: "shared data folder (media, catalog, tools)" },
     { name: "trees", type: "string", value: "<dir>", description: "folder holding the trees" },
-    { name: "agent", type: "string", value: "<agent>", description: "AI agent: claude, codex, antigravity, opencode (default from config)" },
+    { name: "agent", type: "string", value: "<agent>", description: "AI agent: claude, codex, antigravity, opencode, grok (default from config)" },
     { name: "yes", type: "boolean", description: "accept suggested defaults, never ask" },
     { name: "debug", type: "boolean", description: "show technical details on errors" },
     { name: "version", type: "boolean", description: "print the version of strom" },

package/dist/cli/ui.js

@@ -38,7 +38,7 @@ 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.settings": "Settings",
+    "ui.menu.settings": "Settings: the agent, working alone, messages, archives, the check",
     "ui.menu.doctor": "Check the installation",
     "ui.menu.trees": "Another family tree",
     "ui.menu.newtree": "Create a family tree",
@@ -154,7 +154,7 @@ export const UI = {
     "ui.run.stop.time": "time limit",
     "ui.run.stop.empty": "no open tasks",
     "ui.run.stop.problems": "the evidence has problems — strom check",
-    "ui.run.stop.denied": "the agent was not allowed to run strom — its permissions are wrong (.claude/settings.json of the tree); nothing more was started",
+    "ui.run.stop.denied": "the agent was not allowed to run strom — its permissions or its sandbox kept it away; nothing more was started",
     "ui.run.stop.limit": "subscription limit{resets}",
     "ui.run.stop.resets": " (resets {at})",
     "ui.run.stop.auth": "the agent is not logged in — run {command} once and log in",
@@ -187,6 +187,7 @@ export const UI = {
     "ui.doc.yes": "yes",
     "ui.doc.default": "default",
     "ui.doc.noagent": "no AI agent installed",
+    "ui.doc.agent.other": "none strom knows is installed — strom is run by another agent or program now, which does the research through strom",
     "ui.doc.knows.yes": "yes, in any folder",
     "ui.doc.knows.no": "not yet: {agents}",
     "ui.doc.app.yes": "you use it",
@@ -348,9 +349,7 @@ export const UI = {
     "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.card.story": "Story:",
     "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}",
@@ -362,7 +361,7 @@ export const UI = {
     "ui.stats.sessions": "Sessions of the agent: {n} · the last {last}",
     "ui.stats.cost": " · cost so far {cost}",
     "ui.stats.cost.partial": " (without sessions stopped before they said what they cost: {n})",
-    "ui.stats.stories": "Stories: {n} (approved {final})",
+    "ui.stats.stories": "Stories: {n}",
     "ui.ped.noparents": "parents not known yet",
     "ui.ped.nofather": "father not known yet",
     "ui.ped.nomother": "mother not known yet",
@@ -379,6 +378,20 @@ export const UI = {
     "ui.recent.sessions": "What the agent did:",
     "ui.recent.more": "… and {n} more",
     "ui.browse.plan": "What the agent will do next",
+    "ui.review.new": "{name} — {n} new task(s):",
+    "ui.review.nothing": "{name} — nothing new to review",
+    "ui.review.would": "  would add: {level} · {what}",
+    "ui.review.dry": "(dry run — nothing written)",
+    "ui.review.covered": "  {name}: already covered by {task} ({state}) — {what}",
+    "ui.review.wake": "    to go on with it: strom task wake {task}",
+    "ui.review.exhausted": "  {name}: searched in vain ({tasks}) — what next is your decision",
+    "ui.review.open": "{n} task(s) open in {research}, about as many sessions",
+    "ui.review.cost": " — a session here costs ${cost} on average",
+    "ui.review.next": "next: strom run --research {research} (the agent alone) · or in a conversation: strom session start --research {research}",
+    "ui.review.state.open": "in the queue",
+    "ui.review.state.doing": "being worked on",
+    "ui.review.state.parked": "parked",
+    "ui.review.state.waiting": "waiting for you",
     "ui.plan.title": "What the agent will do next – {name}:",
     "ui.plan.now": "now",
     "ui.plan.images": " (needs the scans first)",
@@ -423,6 +436,149 @@ export const UI = {
     "ui.consent.gate.set": "Let the condition “{name}” decide when the agent working alone goes on?",
     "ui.consent.gate.unset": "Remove the condition “{name}” — the agent working alone no longer asks it?",
     "ui.consent.gate.skip": "Let the agent work on its own without the condition “{name}”?",
+    "ui.consent.remote": "Start the Claude Code sessions strom opens with Remote Control, so that you can follow and steer them from claude.ai or the Claude app on your phone?",
+    "ui.consent.hook.on": "Let the hook “{name}” be told of everything saved into your researches? It is a program on this computer and does with it what it was written to do.",
+    "ui.consent.hook.off": "Stop telling the hook “{name}” what is saved?",
+    "ui.menu.more": "Add to the research: material, a new direction, one person reviewed",
+    "ui.more.title": "Add to the research",
+    "ui.more.intake": "Material from the family: documents, photos, a family tree from another program, what you know",
+    "ui.more.research": "A new direction: the ancestors or descendants of someone else, or one question",
+    "ui.intake.what": "What do you bring?",
+    "ui.intake.files": "Files or a folder from this computer",
+    "ui.intake.text": "What you know — names, dates, places, family memories",
+    "ui.intake.write": "Write what you know (Enter or 0 goes back)",
+    "ui.intake.path": "The folder or file — you can drag it into this window (Enter or 0 goes back)",
+    "ui.intake.missing": "Not found: {path} — check the path, or drag the folder in.",
+    "ui.intake.scans": "The folder {folder} holds {n} images. Are they family documents and photos? (no: scans of a register or another book)",
+    "ui.intake.book": "{folder}: scans of a register or another book go with that book — tell the agent in a conversation where they come from, and it registers them.",
+    "ui.intake.known": "This material is in the research already — nothing added.",
+    "ui.intake.done": "✓ Added to the research: {n}. The agent goes through it in its next work.",
+    "ui.intake.chat": "Go through it with the agent now?",
+    "ui.intake.say": "I added new material to the research — let us go through it.",
+    "ui.research.kind": "What do you want to find out?",
+    "ui.research.ancestors": "The ancestors of someone",
+    "ui.research.descendants": "The descendants of someone",
+    "ui.research.question": "One question (e.g. who was Mary's father?)",
+    "ui.research.ask": "The question (Enter or 0 goes back)",
+    "ui.research.whom": "Who is it about?",
+    "ui.research.known": "Someone already in the family tree",
+    "ui.research.newperson": "Someone new",
+    "ui.research.name": "Their name (e.g. John Smith; 0 goes back)",
+    "ui.research.sex": "A man or a woman?",
+    "ui.research.male": "A man",
+    "ui.research.female": "A woman",
+    "ui.research.unknown": "I don't know",
+    "ui.research.title": "The research's name",
+    "ui.research.title.ancestors": "Ancestors: {name}",
+    "ui.research.title.descendants": "Descendants: {name}",
+    "ui.research.knows": "What do you know of it? Dates, places, stories of the family help the agent (Enter: nothing)",
+    "ui.research.done": "✓ The research “{name}” is started.",
+    "ui.research.chat": "Start on it with the agent now?",
+    "ui.research.say": "I started a new research, “{name}” — let us begin with it.",
+    "ui.settings.title": "Settings (on this computer)",
+    "ui.settings.wizard": "Language, agent, model, what the agent may do alone, stories… (the setup)",
+    "ui.settings.alone": "The agent working alone: {minutes} min a task · condition: {gate}",
+    "ui.settings.gate.none": "none",
+    "ui.settings.hooks": "Messages of what is saved (hooks): {state}",
+    "ui.settings.on": "on",
+    "ui.settings.off": "off",
+    "ui.settings.remote": "Watch the agent from your phone (Remote Control): {state}",
+    "ui.settings.remote.about": "With it on you can follow and steer the Claude Code sessions strom starts — conversations and working alone — from claude.ai or the Claude app on your phone.",
+    "ui.settings.remote.on": "Turn it on?",
+    "ui.settings.remote.off": "Turn it off?",
+    "ui.settings.archives": "Archives: your logins, downloaders asking first",
+    "ui.alone.title": "The agent working alone",
+    "ui.alone.minutes": "Time for one task: {minutes} min",
+    "ui.alone.minutes.ask": "How many minutes may one task take? (5–600; 0 goes back)",
+    "ui.alone.minutes.bad": "Please a number of minutes from 5 to 600.",
+    "ui.alone.gate": "Working on and on under a condition: {gate}",
+    "ui.alone.gate.about": "A condition is asked before each session while the agent works on and on by itself; the menu offers that only with one set. Tasks you start yourself are your choice.",
+    "ui.alone.gate.pick": "Which condition?",
+    "ui.alone.gate.claude": "By how many points should the week's usage of your Claude subscription stay behind the part of the week gone? (a day ≈ 14.3; 0: just not ahead of the week)",
+    "ui.alone.gate.args": "What to give it (Enter: nothing)",
+    "ui.alone.test": "What would the condition say now?",
+    "ui.alone.asking": "Asking the condition…",
+    "ui.alone.said.go": "It would start now{reason}",
+    "ui.alone.said.wait": "It would wait until {at}{reason}",
+    "ui.alone.said.stop": "It would stop{reason}",
+    "ui.alone.said.error": "No proper answer{reason}",
+    "ui.hooks.title": "Hooks — a number turns one on or off:",
+    "ui.hooks.on": "{name}: on",
+    "ui.hooks.off": "{name}: off",
+    "ui.hooks.none": "No hooks here yet. A hook is your own program told of what is saved (e.g. a message to your phone) — how: {readme}",
+    "ui.archives.title": "Downloaders of the archives here:",
+    "ui.archives.empty": "No downloaders here yet — the agent builds one when the research needs an archive.",
+    "ui.archives.login.saved": "your login saved {date}",
+    "ui.archives.login.none": "can use your account — no login saved",
+    "ui.archives.consent": "Downloaders ask you before they run: {state}",
+    "ui.archives.consent.about": "Off (usual): downloaders run by themselves — slowly, and only to their archive. On: each needs your yes first, here in the terminal, and so does each archive it reaches.",
+    "ui.archives.consent.on": "Turn it on?",
+    "ui.archives.consent.off": "Turn it off?",
+    "ui.hooks.nothing": "none",
+    "ui.menu.noagent": "No AI agent on this computer yet — the research is its work. Item 1 installs one.",
+    "ui.menu.getagent": "Install or choose the AI agent",
+    "ui.menu.update.where": "A new version of strom is out: {version} — update it in the settings (item {key}).",
+    "ui.more.noagent": "The agent takes it up once it is on this computer (item 1 of the menu).",
+    "ui.menu.noagent.chosen": "The AI agent this research uses is not on this computer — item 1 chooses another.",
+    "ui.waiting.title": "The agent needs you for {n} thing(s):",
+    "ui.waiting.do": "What to do: {what}",
+    "ui.waiting.ask": "the agent will tell you in a conversation",
+    "ui.waiting.images": "Save by hand: images {images} of {book}",
+    "ui.waiting.more": "…and {n} more — the agent goes through them with you in a conversation.",
+    "ui.waiting.pick": "Have you got it? Choose the number and write what you found:",
+    "ui.waiting.answer": "Answer {k}: {what}",
+    "ui.waiting.folder": "Open the folder for the images of {k}",
+    "ui.waiting.opened": "The folder: {dir} — once the images are there, the next work of the agent takes them in by itself.",
+    "ui.waiting.write": "Your answer — a link, a book's number, what you found out (Enter or 0 goes back)",
+    "ui.waiting.back": "✓ The task goes back to the agent with your answer.",
+    "ui.waiting.chat": "Go on with the agent now?",
+    "ui.waiting.say": "I answered what you asked of me: {what} — let us go on with it.",
+    "ui.intake.empty": "There is nothing in it to take in.",
+    "ui.intake.ours": "{path} is strom's own folder (the research itself), not material of the family.",
+    "ui.research.exists": "This research is there already: “{name}” — the agent goes on with it.",
+    "ui.alone.gate.bad": "Please a number of points from 0 to 100 (e.g. 10).",
+    "ui.waiting.long": "That is long for an answer here (at most {n} characters) — a link or a sentence; the rest tell the agent in a conversation.",
+    "ui.settings.remote.chats": "conversations yes, working alone no",
+    "ui.settings.remote.own": "Conversations with the agent you can watch from your phone already — Claude Code does it itself (its own setting). The agent working alone (item 2 of the menu) only once this is on too.",
+    "ui.settings.remote.both": "conversations and working alone",
+    "ui.settings.remote.onalone": "Turn it on for working alone too?",
+    "ui.archives.login.nobody": "None of them needs a login: the archives are open. A login shows here only for a downloader of a portal with an account (perhaps a paid one).",
+    "ui.archives.login.how": "Your login is typed in here and kept on this computer only; strom puts it into the downloader's requests — neither the downloader nor the agent sees it.",
+    "ui.archives.login.save": "Save your login to {title}",
+    "ui.archives.login.change": "Change your login to {title}",
+    "ui.home.what": "The research is in {from} (family trees: {trees}), with the shared folder — downloaders, hooks, the inbox, big images. It moves to {to} as a whole.",
+    "ui.home.sure": "Move it there?",
+    "ui.home.moved": "✓ The research is in {to} now.",
+    "ui.home.copied": "✓ The research is copied to {to} (another disk) and works from there. The old folder {from} is left as it was — delete it once you have seen all is well.",
+    "ui.home.stays": "The research stays in {from}.",
+    "ui.home.inside": "{to} is inside the research's folder {from} (or the other way round) — pick a folder beside it.",
+    "ui.home.notEmpty": "{to} holds something already — the research moves only into an empty or new folder.",
+    "ui.home.busy": "Somebody is at work in {trees} right now (an agent, a run, or the Strom app following it live) — the research can move once that has finished.",
+    "ui.home.failed": "It could not be moved ({reason}) — nothing changed.",
+    "ui.app.notinstalled": "The Strom app is not installed on this computer yet. Install it now as an app from the browser (free; strom shows where to click)?",
+    "ui.browser.agent": "{names}: through the browser — that only Claude Code can (the Claude in Chrome extension); this research is done by {agent}. Save those images by hand, or let Claude Code do the research (strom agents use claude).",
+    "ui.browser.noext": "{names}: through the browser — Chrome needs the Claude in Chrome extension, signed in to the account Claude Code uses; it is not in a browser here: {url}",
+    "ui.doc.browser": "browser (Claude in Chrome)",
+    "ui.doc.browser.ok": "the extension in {browsers} — Chrome must run while the agent works",
+    "ui.doc.browser.noext": "the extension is not installed (needed by {names})",
+    "ui.doc.browser.agent": "{names} go through the browser — only Claude Code can (now: {agent})",
+    "ui.archives.via.direct": "images directly, paced by strom",
+    "ui.archives.via.browser": "images through your browser",
+    "ui.archives.via.manual": "images saved by hand (the archive allows no automation)",
+    "ui.archives.browser.ok": "Through the browser: the Claude in Chrome extension is in {browsers}; Chrome must run while the agent works, signed in to the account Claude Code uses.",
+    "ui.archives.to.browser": "{title}: fetch through your browser instead",
+    "ui.archives.to.direct": "{title}: fetch directly instead",
+    "ui.archives.browser.about": "Through your browser the agent fetches the images in your own Chrome (where your login to the archive is), with the Claude in Chrome extension — only Claude Code can. strom still plans and paces every request.",
+    "ui.archives.direct.about": "Directly, strom fetches the images itself, paced, without a browser — any agent can.",
+    "ui.archives.switch": "Switch it?",
+    "ui.archives.now.browser": "✓ {title}: through your browser from now on.",
+    "ui.archives.now.direct": "✓ {title}: directly from now on.",
+    "ui.setup.home.again": "Where to keep the research (0 keeps it where it is)",
+    "ui.home.env": "The research's folder {from} is set from outside (STROM_HOME) — it stays; change it there.",
+    "ui.menu.failed": "That did not work: {reason}",
+    "ui.review.next.human": "The agent takes them up in a conversation or when it works alone.",
+    "ui.review.wake.human": "    to go on with it, tell the agent in a conversation",
+    "ui.waiting.gone": "This one no longer waits for you — the agent has taken it up meanwhile.",
 };
 /** A text for the person, in their language. */
 export function ui(lang, key, values = {}) {