strom-research 1.4.1 → 1.6.0

package/dist/cli/menu-links.js

@@ -0,0 +1,249 @@
+// What the Strom app's menus ask through strom-research:// links (the app's
+// second wave): a task put aside, given up or back in the queue, the agent's
+// sessions and what they cost, a conflict decided, a story approved, a sending
+// taken back — and a tree of the app that becomes a new research. Each is said
+// in the research's terminal and done on the person's word, as the menu does.
+import fs from "node:fs";
+import path from "node:path";
+import { outOfAnswers, translator } from "./menu-parts.js";
+import { offerChat } from "./menu-research.js";
+import { humanCost, humanDay, humanTask } from "./human.js";
+import { lines, truncate } from "./format.js";
+import { Tree } from "../core/tree.js";
+import { monthSpend } from "../core/session.js";
+import { adoptFailedSince, adoptedSince, awaitAdoption, nothingSince } from "../core/sync.js";
+import { startLive } from "../core/live.js";
+import { adoptAppUrl } from "../core/stromapp.js";
+import { isValidLang } from "../core/lang.js";
+import { agentsHere } from "../core/apps.js";
+import { PROFILES } from "../agents/profiles.js";
+import { foldText, safeFolderName } from "../core/text.js";
+import { StromError } from "../core/errors.js";
+/** What the Strom app asks, said before anything is done; true when the person goes on. */
+export async function asks(ctx, lang, root, what, note) {
+    const name = Tree.open(root, ctx.env).config.name;
+    ctx.io.stdout(lines(translator(lang)("ui.link.asks", { what, name }), note, "") + "\n");
+    return ctx.confirm(translator(lang)("ui.link.go"), true);
+}
+const out = (ctx, line) => ctx.io.stdout(line + "\n");
+/** What stopped it, said; nothing was done. */
+function stop(ctx, line) {
+    out(ctx, line);
+    return false;
+}
+/** A task put aside, given up (each with the person's reason) or back in the queue. */
+export async function taskDo(ctx, run, lang, root, id, what) {
+    const t = translator(lang);
+    const tree = Tree.open(root, ctx.env);
+    const task = tree.get(id);
+    if (!task || task.retracted)
+        return stop(ctx, t("ui.link.task.none", { task: id }));
+    const can = { park: ["open"], drop: ["open", "parked", "waiting"], wake: ["parked", "waiting"] }[what];
+    if (!can.includes(task.state))
+        return stop(ctx, t("ui.link.task.cannot"));
+    if (!(await asks(ctx, lang, root, t(`ui.link.what.task.${what}`, { what: humanTask(tree, task.what, lang) }))))
+        return false;
+    let reason = [];
+    if (what !== "wake") {
+        const why = (await ctx.ask(t("ui.link.task.why"), t(`ui.link.task.${what}.default`))).trim();
+        if (why === "0")
+            return false;
+        reason = [`--reason=${why || t(`ui.link.task.${what}.default`)}`];
+    }
+    if ((await run(["task", what, id, ...reason], true)) !== 0)
+        return false;
+    out(ctx, t(`ui.link.task.${what}.done`));
+    return true;
+}
+/** The agent's sessions, the latest first, and what this month's cost. */
+export function sessionsView(ctx, lang, root) {
+    const t = translator(lang);
+    const tree = Tree.open(root, ctx.env);
+    const all = tree.list("session").sort((a, b) => b.started.localeCompare(a.started));
+    out(ctx, t("ui.link.sessions.title", { name: tree.config.name }));
+    if (!all.length)
+        return void out(ctx, `  ${t("ui.link.sessions.none")}`);
+    const month = monthSpend(tree, new Date().toISOString().slice(0, 7));
+    out(ctx, t("ui.link.sessions.month", { n: month.sessions, cost: humanCost(month.amount, lang) }));
+    out(ctx, "");
+    const shown = all.slice(0, 15);
+    for (const s of shown) {
+        const task = s.task ? tree.get(s.task) : undefined;
+        const agent = PROFILES[s.agent ?? ""]?.name ?? s.agent ?? "";
+        const what = truncate(humanTask(tree, task?.what ?? s.summary ?? "", lang), 80);
+        const cost = s.metrics?.costUsd !== undefined ? `${humanCost(s.metrics.costUsd, lang)}${s.metrics.costPartial ? "+" : ""}` : "";
+        out(ctx, `  ${humanDay(s.started, lang)}  ${[agent, what, cost].filter(Boolean).join(" · ")}`);
+    }
+    if (all.length > shown.length)
+        out(ctx, `  ${t("ui.link.sessions.more", { n: all.length - shown.length })}`);
+}
+/** A conflict the person decides: which claim holds (or their own words), and why. */
+export async function decideConflict(ctx, run, lang, root, id) {
+    const t = translator(lang);
+    const tree = Tree.open(root, ctx.env);
+    const c = tree.get(id);
+    if (!c || c.type !== "conflict")
+        return stop(ctx, t("ui.link.conflict.none", { id }));
+    if (c.state === "resolved")
+        return stop(ctx, t("ui.link.conflict.decided", { resolution: c.resolution ?? "" }));
+    if (!(await asks(ctx, lang, root, t("ui.link.what.conflict.decide", { title: c.title }))))
+        return false;
+    const claim = (x) => `${x.value}${x.source ? ` — ${tree.get(x.source)?.title ?? x.source}` : ""}`;
+    const i = await ctx.choose(t("ui.link.conflict.pick"), [...c.claims.map((x) => ({ label: claim(x) })), { label: t("ui.link.conflict.other") }], 0, { back: t("ui.browse.back") });
+    if (i === undefined)
+        return false;
+    let resolution = i < c.claims.length ? `${c.claims[i].value}${c.claims[i].source ? ` (${c.claims[i].source})` : ""}` : "";
+    if (!resolution) {
+        resolution = (await ctx.ask(t("ui.link.conflict.own"))).trim();
+        if (!resolution || resolution === "0")
+            return false;
+    }
+    let why = "";
+    while (!why) {
+        why = (await ctx.ask(t("ui.link.conflict.why"))).trim();
+        if (why === "0" || outOfAnswers(ctx))
+            return false;
+    }
+    if ((await run(["conflict", "resolve", id, `--resolution=${resolution}`, `--reasoning=${t("ui.link.conflict.by", { why })}`], true)) !== 0)
+        return false;
+    out(ctx, t("ui.link.conflict.done"));
+    return true;
+}
+/** A story the person read and approves: no longer a draft. */
+export async function approveStory(ctx, run, lang, root, person, who) {
+    const t = translator(lang);
+    const st = person.story;
+    if (!st)
+        return stop(ctx, t("ui.link.story.none", { person: who }));
+    if (st.status === "final")
+        return stop(ctx, t("ui.link.story.final", { person: who }));
+    out(ctx, lines(st.title ? `„${st.title}“` : undefined, "", st.text.replace(/\*\*/g, ""), ""));
+    if (!(await asks(ctx, lang, root, t("ui.link.what.story", { person: who }))))
+        return false;
+    if ((await run(["story", "approve", person.id], true)) !== 0)
+        return false;
+    out(ctx, t("ui.link.story.done"));
+    return true;
+}
+/** What the research took from the Strom app, taken back on the person's word. */
+export async function undoSending(ctx, run, lang, root, id) {
+    const t = translator(lang);
+    const input = Tree.open(root, ctx.env).get(id);
+    if (!input || input.type !== "input" || !input.sync)
+        return stop(ctx, t("ui.link.sync.none", { input: id }));
+    if (input.sync.undone)
+        return stop(ctx, t("ui.link.sync.was"));
+    if (!(await asks(ctx, lang, root, t("ui.link.what.sync", { day: humanDay(input.created, lang), n: input.sync.applied.length }))))
+        return false;
+    return (await run(["sync", "undo", id])) === 0;
+}
+/**
+ * A tree of the Strom app becomes a new research (strom-research://new?app=<its mark>): named, its language and
+ * agent chosen, made; the app opened to hand the tree over (?adopt=<the bridge>), the tree taken in as leads,
+ * the research sent back to the app — then the conversation offered.
+ */
+export async function newFromApp(ctx, runIn, token, openAt, forward) {
+    // strom not set up yet (the app is how this person came): the setup first
+    if (!ctx.settings.home()?.value) {
+        await (await runIn(undefined))(["setup"]);
+        ctx.settings.reload();
+        if (!ctx.settings.home()?.value)
+            return false;
+    }
+    let lang = ctx.uiLang();
+    let t = translator(lang);
+    out(ctx, t("ui.link.new.title"));
+    out(ctx, "");
+    // the name; an empty research of that name (a handover that did not come) is taken again
+    let name = "";
+    let root;
+    for (;;) {
+        name = (await ctx.ask(t("ui.link.new.name"))).trim().replace(/\s+/gu, " ");
+        if (!name || name === "0")
+            return false;
+        const same = ctx.knownTrees().find((k) => foldText(k.name) === foldText(name) || path.basename(k.root) === safeFolderName(name));
+        if (!same)
+            break;
+        if (Tree.open(same.root, ctx.env).count("person") === 0) {
+            root = same.root;
+            break;
+        }
+        out(ctx, t("ui.link.new.exists", { name }));
+        if (outOfAnswers(ctx))
+            return false;
+    }
+    for (;;) {
+        const a = (await ctx.ask(t("ui.setup.lang"), lang)).trim().toLowerCase();
+        if (a === "0")
+            return false;
+        if (isValidLang(a)) {
+            lang = a;
+            t = translator(lang);
+            break;
+        }
+        if (outOfAnswers(ctx))
+            return false;
+    }
+    const here = agentsHere(ctx.env).map((a) => a.id);
+    const mine = ctx.settings.agent().value;
+    let agent = mine;
+    if (here.length > 1) {
+        const i = await ctx.choose(t("ui.setup.agent.pick"), here.map((id) => ({ label: PROFILES[id].name })), Math.max(0, here.indexOf(mine)), { back: t("ui.browse.back") });
+        if (i === undefined)
+            return false;
+        agent = here[i];
+    }
+    if (!root) {
+        let said = "";
+        const code = await (await runIn(undefined))(["init", name, "--lang", lang, "--json"], true, (s) => (said += s));
+        if (code !== 0)
+            return false;
+        root = JSON.parse(said).root;
+    }
+    const run = await runIn(root);
+    if (agent !== mine)
+        await run(["agents", "use", agent, "--for-tree"], true);
+    // the app hands its tree over to the bridge of this research
+    awaitAdoption(root, token);
+    const info = startLive(root, ctx.env, { current: true });
+    if (!info)
+        throw new StromError("the bridge did not start", { hint: "strom live serve shows why" });
+    const url = adoptAppUrl(info.url, ctx.settings);
+    const since = Date.now();
+    const waitMs = Number(ctx.env.STROM_ADOPT_WAIT_MS ?? 30 * 60_000);
+    const minutes = Math.max(1, Math.round(waitMs / 60_000));
+    out(ctx, openAt(url) ? `${t("ui.link.new.wait", { min: minutes })}\n${t("ui.sync.wait.open", { url })}` : t("ui.app.url", { url }));
+    let file;
+    while (Date.now() < since + waitMs) {
+        file = adoptedSince(root, since);
+        if (file)
+            break;
+        const failed = adoptFailedSince(root, since);
+        if (failed) {
+            forward();
+            return stop(ctx, t(failed === "empty" ? "ui.link.new.empty" : "ui.link.new.failed", { name }));
+        }
+        if (nothingSince(root, since)) {
+            forward();
+            out(ctx, t("ui.link.new.none", { name }));
+            return false;
+        }
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    forward();
+    if (!file)
+        return stop(ctx, t("ui.link.new.waited", { name, min: minutes }));
+    // the family's tree, as leads (without the images written into it: the research keeps its own)
+    const { withoutImages } = await import("../commands/sync.js");
+    const kept = path.join(path.dirname(file), `${safeFolderName(name)}.ged`);
+    fs.writeFileSync(kept, withoutImages(fs.readFileSync(file, "utf8")));
+    if ((await run(["intake", kept], true)) !== 0)
+        return false;
+    const tree = Tree.open(root, ctx.env);
+    out(ctx, t("ui.link.new.taken", { name, persons: tree.count("person"), families: tree.count("family") }));
+    // the research as it is now back into the app's window: the same tree, now of the research
+    if ((await run(["app"], true)) === 0)
+        out(ctx, t("ui.link.new.back"));
+    await offerChat(ctx, run, lang, root, t("ui.link.new.chat"), t("ui.link.new.say"));
+    return true;
+}

package/dist/cli/menu-parts.js

@@ -11,9 +11,9 @@ export function outOfAnswers(ctx) {
     return ctx.io.answers !== undefined && ctx.io.answers.length === 0;
 }
 /** "Press Enter to go back to the menu." — unless there is nobody to press it. */
-export async function pause(ctx, lang) {
+export async function pause(ctx, lang, enter = "ui.enter") {
     if (!outOfAnswers(ctx))
-        await ctx.ask(ui(lang, "ui.enter"));
+        await ctx.ask(ui(lang, enter));
 }
 /**
  * A submenu: its items (built afresh each time, so what they say is current), numbered in the order shown, 0 back.
@@ -32,7 +32,10 @@ export async function subMenu(ctx, lang, build) {
         const i = await ctx.choose(title ?? "", all.map((it) => ({ key: it.key === "0" ? "0" : String(++n), label: it.label })), all.length - 1);
         if (i === undefined)
             return;
-        if ((await guarded(ctx, lang, all[i].act)) === true)
+        const done = await guarded(ctx, lang, all[i].act);
+        if (done === "quit")
+            return "quit";
+        if (done === true)
             return;
     }
 }

package/dist/cli/menu-research.js

@@ -4,9 +4,13 @@
 // agent takes it up in the next conversation or run.
 import fs from "node:fs";
 import path from "node:path";
-import { agentReady, droppedPaths, pause, pickPerson, subMenu, translator } from "./menu-parts.js";
+import { agentReady, droppedPaths, outOfAnswers, pause, pickPerson, subMenu, translator } from "./menu-parts.js";
 import { Tree } from "../core/tree.js";
-import { displayName } from "../core/people.js";
+import { displayName, lifespan } from "../core/people.js";
+import { DEATH_AFTER_YEARS, unprovenPeople } from "../core/review.js";
+import { planSync, readTreeFile, receivedSince } from "../core/sync.js";
+import { appSendsChanges, stromAppState } from "../core/stromapp.js";
+import { UNPROVEN_BATCH } from "../commands/research.js";
 import { expandHome } from "../core/paths.js";
 import { collectFiles } from "../core/media.js";
 import { BOOK_OF_SCANS, IMAGE_EXT } from "../commands/intake.js";
@@ -17,8 +21,15 @@ export async function addToResearch(ctx, run, lang, root) {
             { key: "1", label: t("ui.more.intake"), act: async () => void (await addMaterial(ctx, run, lang, root)) },
             { key: "2", label: t("ui.more.research"), act: async () => void (await newResearch(ctx, run, lang, root)) },
         ];
-        if (Tree.open(root, ctx.env).count("person") > 0)
+        const tree = Tree.open(root, ctx.env);
+        if (tree.count("person") > 0) {
             items.push({ key: "3", label: t("ui.menu.review"), act: async () => void (await reviewPerson(ctx, run, lang, root)) });
+            items.push({ key: "4", label: t(noApp(ctx) ? "ui.more.sync.noapp" : "ui.more.sync"), act: async () => void (await syncTree(ctx, run, lang, root)) });
+        }
+        // only when there are some: the people no record of their own proves — last, it shows only sometimes
+        const unproven = unprovenPeople(tree).filter((u) => !u.living).length;
+        if (unproven)
+            items.push({ key: "5", label: t("ui.menu.unproven", { n: unproven }), act: async () => void (await reviewUnproven(ctx, run, lang, root)) });
         return { title: t("ui.more.title"), items };
     });
 }
@@ -147,6 +158,14 @@ async function newResearch(ctx, run, lang, root) {
             return;
         who = [`--new-person=${name}`, "--sex", ["M", "F", "U"][sex]];
     }
+    await startDirection(ctx, run, lang, root, direction, who, name, question);
+}
+/**
+ * A new direction for someone chosen (the menu, a link of the Strom app): its title and what the person knows of
+ * it asked, the research made; the same research still going is only named.
+ */
+export async function startDirection(ctx, run, lang, root, direction, who, name, question) {
+    const t = translator(lang);
     // The same research again (this person, this direction, still going): said which one it is, nothing made.
     const focus = who[0] === "--person" ? who[1] : undefined;
     const same = focus && direction !== "question"
@@ -176,6 +195,160 @@ async function newResearch(ctx, run, lang, root) {
     ctx.io.stdout(t("ui.research.done", { name: made.name }) + "\n");
     await offerChat(ctx, run, lang, root, t("ui.research.chat"), t("ui.research.say", { name: made.name }));
 }
+/** The person said no to the Strom app: it is not named. */
+const noApp = (ctx) => stromAppState(ctx.settings) === "no";
+/** A family tree coming back (the Strom app, another program): what changed in it, shown, then written on the person's word. */
+async function syncTree(ctx, run, lang, root) {
+    const t = translator(lang);
+    let file;
+    // straight from the Strom app, where it can send the tree (and the person wants it)
+    if (!noApp(ctx) && appSendsChanges(ctx.settings)) {
+        const from = await ctx.choose(t("ui.sync.from"), [{ label: t("ui.sync.from.app") }, { label: t("ui.sync.from.file") }], 0, { back: t("ui.browse.back") });
+        if (from === undefined)
+            return;
+        if (from === 0)
+            return syncFromApp(ctx, run, lang, root);
+    }
+    for (;;) {
+        if (outOfAnswers(ctx))
+            return;
+        const answer = (await ctx.ask(t(noApp(ctx) ? "ui.sync.path.noapp" : "ui.sync.path"))).trim();
+        if (!answer || answer === "0")
+            return;
+        const resolve = (p) => path.resolve(ctx.cwd, expandHome(p, ctx.env));
+        const dropped = droppedPaths(answer).map(resolve);
+        file = [dropped[0], resolve(answer)].find((p) => !!p && fs.existsSync(p) && fs.statSync(p).isFile());
+        if (file)
+            break;
+        ctx.io.stdout(t("ui.intake.missing", { path: answer }) + "\n");
+    }
+    // what it would take, asked first: nothing to write — nothing asked
+    let count;
+    try {
+        const tree = Tree.open(root, ctx.env);
+        count = planSync(tree, readTreeFile(file), ctx.settings.syncEdits(tree.config)).changes.length;
+    }
+    catch {
+        count = 0;
+    }
+    if ((await run(["sync", file])) !== 0 || !count)
+        return pause(ctx, lang);
+    return confirmSync(ctx, run, lang, root, file, count);
+}
+/** The tree straight from the Strom app (the menu, or a strom-research://send link): shown, then written on the person's word. */
+export async function syncFromApp(ctx, run, lang, root, enter = "ui.enter", back) {
+    const since = Date.now();
+    const code = await run(["sync", "--app"]);
+    // the person is in the app: what came of it is here (a terminal opened for a link brings itself forward)
+    back?.();
+    if (code !== 0)
+        return pause(ctx, lang, enter);
+    const file = receivedSince(root, since);
+    if (!file)
+        return pause(ctx, lang, enter);
+    return confirmSync(ctx, run, lang, root, file, undefined, enter);
+}
+/** What the tree brings is shown: written on the person's word — all, or the ones they pick. */
+async function confirmSync(ctx, run, lang, root, file, known, enter = "ui.enter") {
+    const t = translator(lang);
+    let count = known ?? 0;
+    if (known === undefined)
+        try {
+            const tree = Tree.open(root, ctx.env);
+            count = planSync(tree, readTreeFile(file), ctx.settings.syncEdits(tree.config)).changes.length;
+        }
+        catch {
+            count = 0;
+        }
+    if (!count)
+        return pause(ctx, lang, enter);
+    const how = await ctx.choose(t("ui.sync.how"), [{ label: t("ui.sync.all") }, { label: t("ui.sync.some") }], 0, { back: t("ui.browse.back") });
+    if (how === undefined)
+        return;
+    let only = [];
+    if (how === 1) {
+        const picked = await pickNumbers(ctx, lang, Array.from({ length: count }, (_, i) => String(i + 1)));
+        if (!picked?.length)
+            return;
+        only = ["--only", picked.map((i) => i + 1).join(",")];
+    }
+    if ((await run(["sync", file, "--apply", ...only])) === 0 && !noApp(ctx))
+        ctx.io.stdout(t("ui.sync.app") + "\n");
+    await pause(ctx, lang, enter);
+}
+/** The people no record of their own proves: listed, then all of them a batch at a time, or the ones picked by number. */
+async function reviewUnproven(ctx, run, lang, root) {
+    const t = translator(lang);
+    const out = (line) => ctx.io.stdout(line + "\n");
+    const tree = Tree.open(root, ctx.env);
+    const found = unprovenPeople(tree);
+    const all = found.filter((u) => !u.living);
+    const living = found.filter((u) => u.living);
+    const open = tree.list("task").filter((x) => ["open", "doing", "parked", "waiting"].includes(x.state));
+    out(t("ui.unproven.title"));
+    all.forEach((u, i) => {
+        const busy = open.some((x) => x.subject.includes(u.person.id));
+        const life = lifespan(u.person);
+        out(`  ${String(i + 1).padStart(2)}. ${u.person.id} ${displayName(u.person)}${life ? ` (${life})` : ""} — ${t(`ui.unproven.${u.kind}`)}${busy ? ` · ${t("ui.unproven.tasks")}` : ""}`);
+    });
+    if (living.length)
+        out(t("ui.unproven.living", { years: DEATH_AFTER_YEARS, names: living.map((u) => `${u.person.id} ${displayName(u.person)}`).join(", ") }));
+    const how = await ctx.choose(t("ui.unproven.how"), [{ label: t("ui.unproven.all", { n: UNPROVEN_BATCH }) }, { label: t("ui.unproven.pick") }], 0, { back: t("ui.browse.back") });
+    if (how === undefined)
+        return;
+    let argv;
+    if (how === 0)
+        argv = ["review", "--unproven"];
+    else {
+        const picked = await pickNumbers(ctx, lang, all.map((u) => u.person.id));
+        if (!picked?.length)
+            return;
+        argv = ["review", ...picked.map((i) => all[i].person.id)];
+    }
+    if ((await run(argv)) !== 0)
+        return pause(ctx, lang);
+    const after = Tree.open(root, ctx.env);
+    const ids = argv.slice(1).filter((a) => a.startsWith("P"));
+    const research = after
+        .list("research")
+        .find((r) => r.direction === "person" && r.state === "active" && (ids.length ? r.review?.people?.length === ids.length && ids.every((id) => r.review.people.includes(id)) : r.review?.unproven));
+    const waiting = research ? after.list("task").filter((x) => x.research === research.id && x.state === "open").length : 0;
+    if (research && waiting && (await ctx.confirm(t("ui.review.run", { n: waiting }), false)))
+        await run(["run", "--research", research.id, "--max", String(waiting)]);
+    await pause(ctx, lang);
+}
+/** Numbers of a list as a person types them: "1 3 5-7", "2,4", or the IDs shown ("P0012"); each once, in their order. Undefined: back. */
+async function pickNumbers(ctx, lang, ids) {
+    const count = ids.length;
+    const t = translator(lang);
+    for (;;) {
+        const answer = (await ctx.ask(t("ui.unproven.numbers"))).trim();
+        if (!answer || answer === "0")
+            return undefined;
+        const out = [];
+        const bad = [];
+        for (const part of answer.split(/[\s,;]+/u).filter(Boolean)) {
+            const id = ids.indexOf(part.toUpperCase());
+            if (id >= 0) {
+                if (!out.includes(id))
+                    out.push(id);
+                continue;
+            }
+            const m = /^(\d+)(?:\s*[-–]\s*(\d+))?$/u.exec(part);
+            const from = m ? Number(m[1]) : NaN;
+            const to = m?.[2] ? Number(m[2]) : from;
+            if (!m || from < 1 || to > count || to < from)
+                bad.push(part);
+            else
+                for (let i = from; i <= to; i++)
+                    if (!out.includes(i - 1))
+                        out.push(i - 1);
+        }
+        if (!bad.length)
+            return out;
+        ctx.io.stdout(t("ui.unproven.bad", { x: bad.join(", ") }) + "\n");
+    }
+}
 /** One person, looked at again: what the tree says of them elsewhere, what to read whole, what to check. */
 async function reviewPerson(ctx, run, lang, root) {
     const t = translator(lang);
@@ -183,12 +356,17 @@ async function reviewPerson(ctx, run, lang, root) {
     if (!person)
         return;
     const family = await ctx.confirm(t("ui.review.family"), false);
-    if ((await run(["review", person.id, ...(family ? ["--scope", "family"] : [])])) !== 0)
-        return pause(ctx, lang);
+    await reviewOne(ctx, run, lang, root, person.id, family ? "family" : "person");
+    await pause(ctx, lang);
+}
+/** One person's review (the menu, a link of the Strom app), then the agent offered for its tasks — the person's choice, no suggested. */
+export async function reviewOne(ctx, run, lang, root, person, scope) {
+    const t = translator(lang);
+    if ((await run(["review", person, ...(scope !== "person" ? ["--scope", scope] : [])])) !== 0)
+        return;
     const tree = Tree.open(root, ctx.env);
-    const research = tree.list("research").find((r) => r.direction === "person" && r.focus === person.id && r.review);
+    const research = tree.list("research").find((r) => r.direction === "person" && r.focus === person && r.review && !r.review.people);
     const open = research ? tree.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(ctx, lang);
 }

package/dist/cli/menu-settings.js

@@ -5,7 +5,9 @@
 // the person at the terminal does, through the ordinary commands.
 import path from "node:path";
 import { claudeHere, pause, subMenu, translator } from "./menu-parts.js";
-import { Tree } from "../core/tree.js";
+import { Tree, VERSION } from "../core/tree.js";
+import { replacedOnDisk } from "../core/self.js";
+import { shortcutName } from "./wizard.js";
 import { DEFAULT_RUN_MINUTES } from "../core/config.js";
 import { askGate, ensureGatesDir, listGates, loadGate } from "../core/gate.js";
 import { ensureHooksDir, hooksDir, listHooks } from "../core/hooks.js";
@@ -16,7 +18,7 @@ import { loadLogins } from "../core/logins.js";
 import { claudeRemoteAtStartup } from "../agents/global.js";
 export async function settingsMenu(ctx, run, lang, root, newer) {
     const t = translator(lang);
-    await subMenu(ctx, lang, () => {
+    return subMenu(ctx, lang, () => {
         ctx.settings.reload();
         const shared = ctx.settings.shared()?.value;
         const tree = root ? Tree.open(root, ctx.env).config : undefined;
@@ -62,7 +64,19 @@ export async function settingsMenu(ctx, run, lang, root, newer) {
             });
         }
         if (newer)
-            items.push({ key: "7", label: t("ui.menu.update", { version: newer }), act: async () => void (await run(["update"])) });
+            items.push({
+                key: "7",
+                label: t("ui.menu.update", { version: newer }),
+                act: async () => {
+                    if ((await run(["update"])) !== 0)
+                        return;
+                    // this menu is still the old strom: the new one starts with the next strom
+                    if (!replacedOnDisk(VERSION))
+                        return;
+                    ctx.io.stdout(t("ui.update.restart", { shortcut: shortcutName(lang) }) + "\n");
+                    return "quit";
+                },
+            });
         return { title: t("ui.settings.title"), items };
     });
 }