strom-research 1.15.0-beta.2 → 1.15.0-beta.3

package/assets/lang/cs.json

@@ -1537,6 +1537,9 @@
   "ui.intake.done": "✓ Přidáno do výzkumu: {n}. Agent to projde při další práci.",
   "ui.intake.done.archive": "✓ Uloženo do archivu: {n}. Projde se, až se zapne výzkum.",
   "ui.intake.done.waiting": "✓ Uloženo do výzkumu: {n}. Agent to projde, až bude na počítači.",
+  "ui.intake.tree": "{id} rodokmen převzat – osoby: {persons} · rodiny: {families} · údaje: {events}, vše jako vodítka (pramen {source})",
+  "ui.intake.tree.matched": " – už ve výzkumu: {n}",
+  "ui.intake.tree.back": "Je to rodokmen tohoto výzkumu, který se vrací: strom sync \"{file}\" ukáže i to, co se v něm změnilo.",
   "ui.intake.same": "Už tu bylo dřív: {n}.",
   "ui.intake.chat": "Projít to s agentem hned?",
   "ui.intake.say": "Do výzkumu jsem přidal(a) nové podklady – pojďme je projít.",
@@ -1912,6 +1915,17 @@
   "ui.error.pack.no-manifest.hint": "zadat ZIP soubor, který přišel",
   "ui.error.fs.no-permission": "chybí oprávnění{where}",
   "ui.error.fs.no-permission.hint": "vybrat složku, do které lze zapisovat",
+  "ui.task.none": "Žádné úkoly.",
+  "ui.research.none": "Žádné směry výzkumu.",
+  "ui.person.none": "Žádné osoby.",
+  "ui.person.nomatch": "Žádná osoba neodpovídá.",
+  "ui.person.leadsonly": "jen vodítka",
+  "ui.person.events": "údaje: {n}",
+  "ui.list.more": "… dalších {n}: {command}",
+  "ui.error.archive": "Tento výzkum je archiv: data přicházejí z aplikace Strom a nic se nezkoumá. Výzkum se zapíná v menu, první položka.",
+  "ui.error.archive.hint": "nebo v terminálu: strom mode research",
+  "ui.error.agent.missing": "Výzkum čeká na AI agenta ({name}), který na tomto počítači není: do té doby drží data z aplikace Strom jako archiv. Agenta nainstalovat nebo vybrat jiného: menu, první položka.",
+  "ui.error.agent.missing.hint": "nebo v terminálu: strom setup",
   "ui.error.fs.missing": "nenalezeno: {path}",
   "ui.error.fs.missing.hint": "zkontrolovat cestu (relativní cesta začíná v aktuální složce)",
   "ui.error.grep.in.missing": "--in {where}: ve výzkumu nenalezeno",

package/assets/lang/de.json

@@ -1537,6 +1537,9 @@
   "ui.intake.done": "✓ Zur Forschung hinzugefügt: {n}. Der Agent sieht es bei der nächsten Arbeit durch.",
   "ui.intake.done.archive": "✓ Im Archiv aufbewahrt: {n}. Es wird durchgesehen, sobald die Forschung eingeschaltet ist.",
   "ui.intake.done.waiting": "✓ In der Forschung aufbewahrt: {n}. Der Agent sieht es durch, sobald er auf diesem Computer ist.",
+  "ui.intake.tree": "{id} Stammbaum übernommen – Personen: {persons} · Familien: {families} · Angaben: {events}, alle als Hinweise (Quelle {source})",
+  "ui.intake.tree.matched": " – schon in der Forschung: {n}",
+  "ui.intake.tree.back": "Es ist der Stammbaum dieser Forschung, der zurückkommt: strom sync \"{file}\" zeigt auch, was darin geändert wurde.",
   "ui.intake.same": "Schon vorher hier: {n}.",
   "ui.intake.chat": "Jetzt mit dem Agenten durchgehen?",
   "ui.intake.say": "Ich habe der Forschung neue Unterlagen hinzugefügt – gehen wir sie durch.",
@@ -1912,6 +1915,17 @@
   "ui.error.pack.no-manifest.hint": "die ZIP-Datei angeben, die gekommen ist",
   "ui.error.fs.no-permission": "keine Berechtigung{where}",
   "ui.error.fs.no-permission.hint": "einen Ordner wählen, in den geschrieben werden darf",
+  "ui.task.none": "Keine Aufgaben.",
+  "ui.research.none": "Keine Forschungsrichtungen.",
+  "ui.person.none": "Keine Personen.",
+  "ui.person.nomatch": "Keine Person passt.",
+  "ui.person.leadsonly": "nur Hinweise",
+  "ui.person.events": "Angaben: {n}",
+  "ui.list.more": "… {n} weitere: {command}",
+  "ui.error.archive": "Diese Forschung ist ein Archiv: die Daten kommen aus der Strom-App, und nichts wird erforscht. Die Forschung wird im Menü eingeschaltet, erster Punkt.",
+  "ui.error.archive.hint": "oder im Terminal: strom mode research",
+  "ui.error.agent.missing": "Die Forschung wartet auf ihren KI-Agenten ({name}), der auf diesem Computer nicht ist: bis dahin bewahrt sie die Daten aus der Strom-App als Archiv. Den Agenten installieren oder einen anderen wählen: das Menü, erster Punkt.",
+  "ui.error.agent.missing.hint": "oder im Terminal: strom setup",
   "ui.error.fs.missing": "nicht gefunden: {path}",
   "ui.error.fs.missing.hint": "den Pfad prüfen (ein relativer Pfad beginnt im aktuellen Ordner)",
   "ui.error.grep.in.missing": "--in {where}: in der Forschung nicht gefunden",

package/dist/cli/format.js

@@ -1,5 +1,6 @@
 // Compact, token-efficient text output: aligned columns, one row per record,
 // no box drawing, IDs first.
+import { ui } from "./ui.js";
 export function table(rows, opts = {}) {
     const all = opts.header ? [opts.header, ...rows] : rows;
     if (all.length === 0)
@@ -25,12 +26,13 @@ export function paginate(items, limit, page) {
  * — an agent's tool keeps a longer output in a file and shows only its start (N0280, N0281: the filters never seen).
  */
 export const LIST_PAGE_MAX = 100;
-/** Footer telling the caller how to see more. */
-export function moreLine(page, command) {
+/** Footer telling the caller how to see more — in the research's language where the listing is (lang), else English. */
+export function moreLine(page, command, lang) {
     if (page.page >= page.pages)
         return "";
     const left = page.total - page.page * page.limit;
-    return `… ${left} more: ${command} --page ${page.page + 1}`;
+    const next = `${command} --page ${page.page + 1}`;
+    return lang ? ui(lang, "ui.list.more", { n: String(left), command: next }) : `… ${left} more: ${next}`;
 }
 export function truncate(text, max) {
     const one = text.replace(/\s+/g, " ").trim();

package/dist/cli/menu-mode.js

@@ -20,18 +20,10 @@ export async function switchTo(ctx, run, lang, root, to) {
         return;
     let asked = false;
     if (to === "research" && !agentReady(ctx, tree.config)) {
-        out(t("ui.mode.agent.get"));
-        if (agentsHere(ctx.env).length) {
-            await run(["setup", "--research"]);
-            asked = true;
-        }
-        else
-            await offerAgent(ctx, out);
-        ctx.settings.reload();
-        if (!agentReady(ctx, Tree.open(root, ctx.env).config)) {
-            out(t("ui.mode.later"));
+        const got = await agentFirst(ctx, run, lang, root);
+        if (!got.ready)
             return pause(ctx, lang);
-        }
+        asked = got.asked;
     }
     if (!(await ctx.confirm(t(to === "archive" ? "ui.consent.mode.archive" : "ui.consent.mode.research", { name: tree.config.name }), false)))
         return;
@@ -48,8 +40,30 @@ export async function switchTo(ctx, run, lang, root, to) {
     }
     await pause(ctx, lang);
 }
+/**
+ * Research switched on where the research's agent is not here: the agent first — the wizard when another one is here,
+ * else the one offered. None got: a sentence says the archive stays as it was (the caller writes nothing). `asked`: the
+ * wizard's agent steps were asked just now.
+ */
+export async function agentFirst(ctx, run, lang, root) {
+    const t = translator(lang);
+    const out = (line) => ctx.io.stdout(line + "\n");
+    out(t("ui.mode.agent.get"));
+    let asked = false;
+    if (agentsHere(ctx.env).length) {
+        await run(["setup", "--research"]);
+        asked = true;
+    }
+    else
+        await offerAgent(ctx, out);
+    ctx.settings.reload();
+    if (agentReady(ctx, Tree.open(root, ctx.env).config))
+        return { ready: true, asked };
+    out(t("ui.mode.later"));
+    return { ready: false, asked };
+}
 /** The setup's steps of an agent never asked on this computer (stories: asked with them by every wizard before these). */
-function agentStepsSkipped(ctx) {
+export function agentStepsSkipped(ctx) {
     ctx.settings.reload();
     const c = ctx.settings.config;
     return !c.agentAsked && c.stories === undefined;

package/dist/cli/ui.js

@@ -1450,6 +1450,9 @@ export const UI = {
     "ui.intake.done": "✓ Added to the research: {n}. The agent goes through it in its next work.",
     "ui.intake.done.archive": "✓ Kept in the archive: {n}. It is gone through once research is switched on.",
     "ui.intake.done.waiting": "✓ Kept in the research: {n}. The agent goes through it once it is on this computer.",
+    "ui.intake.tree": "{id} family tree taken in – people: {persons} · families: {families} · facts: {events}, all as leads (source {source})",
+    "ui.intake.tree.matched": " – already in the research: {n}",
+    "ui.intake.tree.back": "It is this research's own family tree coming back: strom sync \"{file}\" shows what was changed in it too.",
     "ui.intake.same": "Already here before: {n}.",
     "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.",
@@ -1716,6 +1719,17 @@ export const UI = {
     "ui.error.pack.no-manifest.hint": "the ZIP file that came",
     "ui.error.fs.no-permission": "no permission to use{where}",
     "ui.error.fs.no-permission.hint": "a folder with the right to write in it",
+    "ui.task.none": "No tasks.",
+    "ui.research.none": "No research directions.",
+    "ui.person.none": "No people.",
+    "ui.person.nomatch": "No people match.",
+    "ui.person.leadsonly": "leads only",
+    "ui.person.events": "{n} ev",
+    "ui.list.more": "… {n} more: {command}",
+    "ui.error.archive": "This research is an archive: its data come from the Strom app and nothing is researched. Research is switched on in the menu, its first item.",
+    "ui.error.archive.hint": "or in a terminal: strom mode research",
+    "ui.error.agent.missing": "The research waits for its AI agent ({name}), which is not on this computer: until then it keeps the data from the Strom app as an archive. Installing the agent or choosing another: the menu, its first item.",
+    "ui.error.agent.missing.hint": "or in a terminal: strom setup",
     "ui.error.fs.missing": "no such file or folder: {path}",
     "ui.error.fs.missing.hint": "check the path (relative paths start in the current folder)",
     "ui.error.grep.in.missing": "--in {where}: no such file or folder in the research",

package/dist/commands/intake.js

@@ -14,7 +14,7 @@ import { collectFiles, fileSha256, inputPath, MAX_IN_TREE, mimeOf, storeShared }
 import { create, normId, requireRecord, update } from "../core/records.js";
 import { phrase } from "../core/phrases.js";
 import { importGedcom, importStromJson, isStromJson } from "../core/import.js";
-import { safeFolderName } from "../core/text.js";
+import { decodeText, safeFolderName } from "../core/text.js";
 import { amendInput, checkOriginalMeta } from "../core/originals.js";
 import { batchStatus, closeBatch, listBatches, readBatch } from "../core/batches.js";
 import { SORT_KINDS } from "../core/model.js";
@@ -134,6 +134,9 @@ register({
                 });
             return { folder: folder ? path.basename(p) : undefined, files };
         });
+        // where nobody researches (an archive, a research waiting for its agent): said to the person, in the research's
+        // language — kept, no task to take next (an archive's waits put aside until research is switched on)
+        const quiet = actsAsArchive(tree);
         const known = new Map(tree.list("input").filter((i) => i.sha).map((i) => [i.sha, i.id]));
         const report = [];
         const added = [];
@@ -154,7 +157,8 @@ register({
                     }
                     const size = fs.statSync(file).size;
                     const isText = size < 50 * 1024 * 1024 && [".ged", ".json", ".txt", ".md", ".csv"].includes(path.extname(file).toLowerCase());
-                    const text = isText ? fs.readFileSync(file, "utf8") : undefined;
+                    // as whatever saved it: a BOM (Notepad, PowerShell 5) or UTF-16 is still the same family tree
+                    const text = isText ? decodeText(fs.readFileSync(file)) : undefined;
                     const kind = kindOf(file, text);
                     const id = tree.peekId("I");
                     let stored;
@@ -179,16 +183,25 @@ register({
                             op: "input.imported",
                             summary: `${input.id} imported: ${imported.persons} persons, ${imported.families} families${imported.matched ? `, ${imported.matched} matched` : ""}`,
                         });
-                        report.push(`  ${input.id} tree: ${imported.persons} persons, ${imported.families} families, ${imported.events} facts as leads${imported.matched ? `, ${imported.matched} matched to existing` : ""}${imported.problems.length ? ` (${imported.problems.length} unreadable lines)` : ""}`);
-                        if (imported.extended.length)
-                            report.push(`  added to what we have (leads — check them): ${imported.extended.slice(0, 6).join(" · ")}${imported.extended.length > 6 ? " …" : ""}`);
-                        // the research's own tree coming back: sync sees what was changed in it too, not only what was added
-                        if (imported.matched && imported.matched >= imported.persons)
-                            report.push(`  it is this research's tree coming back: strom sync "${ctx.display(file)}" shows what was changed in it too`);
-                        const system = `gedcom:${sha.slice(0, 12)}`;
-                        const dupes = likelyDuplicates(tree, tree.list("person").filter((p) => p.refs?.some((r) => r.system === system)).map((p) => p.id));
-                        if (dupes.length)
-                            report.push(`  probably already in the tree: ${dupes.map((d) => `${d.person.id}≈${d.same.id}`).join(", ")} (the review task lists them)`);
+                        const back = imported.matched && imported.matched >= imported.persons;
+                        if (quiet) {
+                            // where nobody researches the person reads it, in the research's language: the tree is in it (no review talk)
+                            report.push(`  ${ui(tree.lang, "ui.intake.tree", { id: input.id, persons: imported.persons, families: imported.families, events: imported.events, source: imported.source })}${imported.matched ? ui(tree.lang, "ui.intake.tree.matched", { n: imported.matched }) : ""}`);
+                            if (back)
+                                report.push(`  ${ui(tree.lang, "ui.intake.tree.back", { file: ctx.display(file) })}`);
+                        }
+                        else {
+                            report.push(`  ${input.id} tree: ${imported.persons} persons, ${imported.families} families, ${imported.events} facts as leads${imported.matched ? `, ${imported.matched} matched to existing` : ""}${imported.problems.length ? ` (${imported.problems.length} unreadable lines)` : ""}`);
+                            if (imported.extended.length)
+                                report.push(`  added to what we have (leads — check them): ${imported.extended.slice(0, 6).join(" · ")}${imported.extended.length > 6 ? " …" : ""}`);
+                            // the research's own tree coming back: sync sees what was changed in it too, not only what was added
+                            if (back)
+                                report.push(`  it is this research's tree coming back: strom sync "${ctx.display(file)}" shows what was changed in it too`);
+                            const system = `gedcom:${sha.slice(0, 12)}`;
+                            const dupes = likelyDuplicates(tree, tree.list("person").filter((p) => p.refs?.some((r) => r.system === system)).map((p) => p.id));
+                            if (dupes.length)
+                                report.push(`  probably already in the tree: ${dupes.map((d) => `${d.person.id}≈${d.same.id}`).join(", ")} (the review task lists them)`);
+                        }
                     }
                     // A family tree gets its own review task; the other files of a folder share one — files for a task: none
                     if (forTask)
@@ -215,9 +228,6 @@ register({
                 added.push(input);
             }
         });
-        // where nobody researches (an archive, a research waiting for its agent): said to the person, in the research's
-        // language — kept, no task to take next (an archive's waits put aside until research is switched on)
-        const quiet = actsAsArchive(tree);
         const text = lines(quiet
             ? added.length
                 ? `${ui(tree.lang, isArchive(tree) ? "ui.intake.done.archive" : "ui.intake.done.waiting", { n: added.length })}${skipped ? ` ${ui(tree.lang, "ui.intake.same", { n: skipped })}` : ""}`

package/dist/commands/people.js

@@ -211,10 +211,12 @@ register({
             displayName(p),
             lifespan(p),
             gens ? `G${gens.get(p.id)}` : "",
-            `${p.events.length} ev`,
-            p.events.some((e) => e.status === "proven" || e.status === "probable") ? "" : "leads only",
+            ui(tree.lang, "ui.person.events", { n: String(p.events.length) }),
+            p.events.some((e) => e.status === "proven" || e.status === "probable") ? "" : ui(tree.lang, "ui.person.leadsonly"),
         ]);
-        const text = people.length === 0 ? "no people match" : lines(table(rows), moreLine(page, "strom person list"));
+        // in the research's language (the person follows it in the agent's session too)
+        const filtered = !!args[0] || !!opts.research;
+        const text = people.length === 0 ? ui(tree.lang, filtered ? "ui.person.nomatch" : "ui.person.none") : lines(table(rows), moreLine(page, "strom person list", tree.lang));
         return {
             text,
             data: {

package/dist/commands/research.js

@@ -6,7 +6,7 @@ import { applyFrontier, researchProposals } from "./session.js";
 import { frontier } from "../core/frontier.js";
 import { DEATH_AFTER_YEARS, livingBorn, unprovenPeople } from "../core/review.js";
 import { parkedWhy } from "./tasks.js";
-import { ui } from "../cli/ui.js";
+import { placeholders, ui } from "../cli/ui.js";
 import { phrase } from "../core/phrases.js";
 import { UsageError } from "../core/errors.js";
 import { REVIEW_SCOPES } from "../core/model.js";
@@ -15,7 +15,8 @@ import { foldText } from "../core/text.js";
 import { now } from "../core/tree.js";
 import { directionOf, scopes } from "../core/directions.js";
 import { otherKind, otherKindHint, update } from "../core/records.js";
-import { isAgent } from "../core/which.js";
+import { detectAgent, isAgent } from "../core/which.js";
+import { actsAsArchive, refuseInArchive } from "../core/state.js";
 import { costPartial, sessionCost } from "../core/session.js";
 function int(v, name) {
     if (v === undefined)
@@ -73,6 +74,8 @@ register({
     ],
     run(ctx, { args, opts }) {
         const tree = ctx.tree();
+        // a direction is the agent's work: refused where nobody researches (an archive, a research waiting for its agent)
+        refuseInArchive(tree, "strom research new", detectAgent(ctx.env) ?? ctx.settings.agent(tree.config).value);
         if (!opts.person === !opts["new-person"])
             throw new UsageError("give exactly one of --person <who> or --new-person <name>");
         let focus;
@@ -110,8 +113,12 @@ register({
     run(ctx, { opts }) {
         const tree = ctx.tree();
         const all = tree.list("research").filter((r) => !opts.state || r.state === opts.state);
+        // in the research's language; an archive (or one waiting for its agent) is told of no direction it would refuse
         if (all.length === 0)
-            return { text: 'no researches yet → strom research new "<name>" --new-person "<Given /Surname/>"', data: { researches: [] } };
+            return {
+                text: `${ui(tree.lang, "ui.research.none")}${actsAsArchive(tree) ? "" : ` → ${placeholders(tree.lang, 'strom research new "<research name>" --new-person "<Given /Surname/>"')}`}`,
+                data: { researches: [] },
+            };
         return { text: table(all.map((r) => researchLine(tree, r))), data: { researches: all } };
     },
 }, ...["pause", "resume", "done"].map((act) => ({
@@ -230,6 +237,8 @@ register({
     ],
     async run(ctx, { args, opts }) {
         const tree = ctx.tree();
+        // its tasks are the agent's work: refused where nobody researches, before anything is asked or written
+        refuseInArchive(tree, "strom review", detectAgent(ctx.env) ?? ctx.settings.agent(tree.config).value);
         const unproven = !!opts.unproven;
         if (unproven && args.length)
             throw new UsageError("--unproven reviews the people without a record — no person with it", { hint: "strom review --unproven · or strom review <person>" });

package/dist/commands/sync.js

@@ -12,7 +12,7 @@ import { eventName, humanDate, humanDay, humanPlace } from "../cli/human.js";
 import { EXIT, StromError, UsageError } from "../core/errors.js";
 import { fileSha256, MAX_IN_TREE, mimeOf } from "../core/media.js";
 import { create, update } from "../core/records.js";
-import { safeFolderName } from "../core/text.js";
+import { decodeText, safeFolderName } from "../core/text.js";
 import { humanAge } from "../core/age.js";
 import { now, Tree } from "../core/tree.js";
 import { actsAsArchive } from "../core/state.js";
@@ -363,7 +363,7 @@ register({
                 fs.mkdirSync(path.join(tree.root, "inputs"), { recursive: true });
                 // kept as the document the source cites — without the images in it (the research's own excerpts, back from
                 // the app: megabytes in the history for nothing)
-                fs.writeFileSync(path.join(tree.root, stored), withoutImages(fs.readFileSync(file, "utf8")));
+                fs.writeFileSync(path.join(tree.root, stored), withoutImages(decodeText(fs.readFileSync(file))));
             }
             const made = create(tree, "input", { name: path.basename(file), ...(stored ? { file: stored } : {}), sha, size, mime: mimeOf(file), from: ctx.display(file), kind: "tree", state: "processed" }, (iid) => `+${iid} input tree "${truncate(path.basename(file), 50)}" (sync)`);
             const day = humanDay(now(), lang);

package/dist/commands/tasks.js

@@ -212,7 +212,9 @@ function taskDetail(tree, t) {
     });
     const searches = tree.list("search").filter((s) => s.task === t.id || s.recordsets.some((b) => t.where.includes(b)));
     const lessons = tree.list("lesson").filter((l) => !l.retracted && l.target && t.where.includes(l.target));
-    return lines(`${t.id} ${t.what}`, `level ${t.level} · priority ${t.priority} · ${t.state}${t.research ? ` · research ${t.research}` : ""}${t.parkedUntil ? ` · parked until ${t.parkedUntil}` : ""}${t.waitingOn ? ` · waiting on ${t.waitingOn}` : ""}`, t.state === "parked" ? `parked ${parkedWhy(tree, t) ?? "(no reason recorded)"} — strom task wake ${t.id} to go on` : undefined, `where  ${where.join("\n       ")}`, `why    ${t.why}`, `done   ${t.doneWhen}`, t.subject.length ? `about  ${t.subject.join(" ")}` : undefined, t.result ? `result ${t.result}${t.produced?.length ? ` → ${t.produced.join(" ")}` : ""}` : undefined, searches.length ? "\nalready searched there\n" + table(searches.map((s) => [`  ${s.id}`, s.result, truncate(s.question, 60), s.scope.years ?? ""])) : undefined, lessons.length ? "\nlessons for these record sets\n" + lessons.map((l) => `  ${l.id} ${l.rule}`).join("\n") : undefined, ...t.notes.map((n) => `note   ${n.text}`), t.awaitsCheck ? `check  the person checks ${t.awaitsCheck.url}: ${t.awaitsCheck.ask}` : undefined, t.state === "waiting" ? `waits  ${waitSaid(tree, t)}` : undefined, t.state === "waiting" && t.wait?.to ? `to     ${t.wait.to}` : undefined, request ? `text   ${request}` : undefined, t.state === "waiting" && t.wait?.url ? `url    ${t.wait.url}` : undefined, 
+    return lines(`${t.id} ${t.what}`, `level ${t.level} · priority ${t.priority} · ${t.state}${t.research ? ` · research ${t.research}` : ""}${t.parkedUntil ? ` · parked until ${t.parkedUntil}` : ""}${t.waitingOn ? ` · waiting on ${t.waitingOn}` : ""}`, 
+    // put aside by the archive: its own sentence in the research's language (back when research is switched on, no wake)
+    t.state === "parked" ? (t.heldBy === "archive" && t.parkedReason ? t.parkedReason : `parked ${parkedWhy(tree, t) ?? "(no reason recorded)"} — strom task wake ${t.id} to go on`) : undefined, `where  ${where.join("\n       ")}`, `why    ${t.why}`, `done   ${t.doneWhen}`, t.subject.length ? `about  ${t.subject.join(" ")}` : undefined, t.result ? `result ${t.result}${t.produced?.length ? ` → ${t.produced.join(" ")}` : ""}` : undefined, searches.length ? "\nalready searched there\n" + table(searches.map((s) => [`  ${s.id}`, s.result, truncate(s.question, 60), s.scope.years ?? ""])) : undefined, lessons.length ? "\nlessons for these record sets\n" + lessons.map((l) => `  ${l.id} ${l.rule}`).join("\n") : undefined, ...t.notes.map((n) => `note   ${n.text}`), t.awaitsCheck ? `check  the person checks ${t.awaitsCheck.url}: ${t.awaitsCheck.ask}` : undefined, t.state === "waiting" ? `waits  ${waitSaid(tree, t)}` : undefined, t.state === "waiting" && t.wait?.to ? `to     ${t.wait.to}` : undefined, request ? `text   ${request}` : undefined, t.state === "waiting" && t.wait?.url ? `url    ${t.wait.url}` : undefined, 
     // the person's own answers (only theirs: strom task wake --answer/--check), apart from the notes
     ...(t.answers ?? []).map((a) => `person ${a.at.slice(0, 10)} answered${a.check ? ` ${a.check}` : ""}${a.answer ? `: ${a.answer}` : ""} (asked: ${truncate(a.asked, 80)})`), 
     // the files that came for what it waited for: only that they came (strom intake --answers, the Strom app)
@@ -600,7 +602,7 @@ register({
         // the queue says what waits out of it for a link to the tree
         const held = !opts.state && !opts["off-tree"] && !opts.about ? tree.list("task").filter((t) => t.state === "open" && off(t)).length : 0;
         return {
-            text: lines(all.length ? lines(table(page.items.map(taskLine)), moreLine(page, "strom task list")) : "no tasks", held ? `${held} more wait out of the queue: about people nothing links to the tree yet (strom task list --off-tree)` : undefined, !opts.state && !opts["off-tree"] && !opts.about ? decisionLines(tree, (t) => (!opts.level || t.level === opts.level) && (!research || t.research === research)) : undefined),
+            text: lines(all.length ? lines(table(page.items.map(taskLine)), moreLine(page, "strom task list")) : ui(tree.lang, "ui.task.none"), held ? `${held} more wait out of the queue: about people nothing links to the tree yet (strom task list --off-tree)` : undefined, !opts.state && !opts["off-tree"] && !opts.about ? decisionLines(tree, (t) => (!opts.level || t.level === opts.level) && (!research || t.research === research)) : undefined),
             data: {
                 total: page.total,
                 tasks: page.items.map((t) => ({

package/dist/commands/trees.js

@@ -30,7 +30,9 @@ import { humanWhen } from "../cli/human.js";
 import { onlyItsFiles, packPlan } from "../core/pack.js";
 import { defaultPackFile, packTree } from "./pack.js";
 import { archiveWaitingItems } from "../core/archiveasks.js";
-import { claudeHere } from "../cli/menu-parts.js";
+import { agentReady, claudeHere } from "../cli/menu-parts.js";
+import { agentFirst, agentStepsSkipped } from "../cli/menu-mode.js";
+import { isAgent } from "../core/which.js";
 register({
     path: ["init"],
     summary: "Create a family tree (a folder with its own history) to hold researches",
@@ -80,7 +82,10 @@ register({
         ctx.adopt(tree);
         // in the research's language, also when an agent runs it (found on Mac: English to a Czech research)
         const t = (k, v = {}) => ui(lang, k, v);
-        const text = lines(t("ui.init.created", { name, path: ctx.display(root) }), t(langR.source === "detected" ? "ui.init.lang.detected" : "ui.init.lang", { lang: langName(lang, lang), code: lang }), mode === "archive" ? t("ui.init.archive") : undefined, "", t("ui.init.next", { command: mode === "archive" ? "strom app" : placeholders(lang, `strom research new "<research name>" --new-person "<Given /Surname/>" --born "<date>" --born-place "<place>"`) }));
+        const waiting = mode !== "archive" && stateOf(tree) === "waiting";
+        const text = lines(t("ui.init.created", { name, path: ctx.display(root) }), t(langR.source === "detected" ? "ui.init.lang.detected" : "ui.init.lang", { lang: langName(lang, lang), code: lang }), mode === "archive" ? t("ui.init.archive") : waiting ? t("ui.why.waitagent.human") : undefined, "", 
+        // waiting for its agent: no direction to start (it would be refused) — the menu installs the agent
+        t("ui.init.next", { command: mode === "archive" ? "strom app" : waiting ? "strom" : placeholders(lang, `strom research new "<research name>" --new-person "<Given /Surname/>" --born "<date>" --born-place "<place>"`) }));
         return { text, data: { name, root, lang, mode } };
     },
 });
@@ -305,7 +310,7 @@ register({
         "put aside (never while somebody works on it); back, they come back to the queue. Nothing is deleted.",
     args: [{ name: "mode", description: "research or archive (none: say which it is)" }],
     examples: ["strom mode", "strom mode research"],
-    run(ctx, { args }) {
+    async run(ctx, { args }) {
         const tree = ctx.tree();
         const lang = tree.lang;
         const now = modeOf(tree);
@@ -322,6 +327,20 @@ register({
         // nobody's work is cut short: a session at work finishes first
         if (to === "archive" && (liveWorkers(tree.root).length > 0 || runsAtWork(tree.root).length > 0))
             throw new UsageError("somebody is at work on this research: an archive only once they finished", { hint: "strom session finish (the agent writes down what it found and closes), then strom mode archive" });
+        // research on with no agent here, as the menu's "switch research on": the agent first — a person at the terminal
+        // gets one offered; none got (or nobody here to get one), the archive stays as it was, nothing written, said why
+        let asked;
+        if (to === "research" && !agentReady(ctx, tree.config)) {
+            const later = { text: ui(lang, "ui.mode.later"), data: { mode: now, state, changed: false, agentHere: false } };
+            if (!ctx.interactive || isAgent(ctx.env) || tree.dryRun)
+                return later;
+            const { main } = await import("../cli/main.js");
+            const run = (argv, quiet) => main(argv, quiet ? { ...ctx.io, stdout: () => undefined } : ctx.io, ctx.env, tree.root);
+            const got = await agentFirst(ctx, run, lang, tree.root);
+            if (!got.ready)
+                return { ...later, text: "" };
+            asked = got.asked;
+        }
         ctx.requireHuman(to === "archive" ? "Make this research an archive (its tasks put aside)?" : "Switch research on (the tasks put aside back in the queue)?", `strom mode ${to}`, "mode", ui(lang, to === "archive" ? "ui.consent.mode.archive" : "ui.consent.mode.research", { name: tree.config.name }));
         let moved = [];
         tree.withTreeLock(() => {
@@ -335,6 +354,15 @@ register({
                 installGlobal(t);
         if (files.length && !tree.dryRun)
             tree.withTreeLock(() => tree.commit(`Agent instructions: ${files.join(", ")}`, files));
+        // the agent got here just now, its steps of the setup never asked: offered, as the menu does
+        if (asked === false && agentStepsSkipped(ctx)) {
+            ctx.io.stdout(ui(lang, "ui.mode.now.research", { n: moved.length }) + "\n");
+            if (await ctx.confirm(ui(lang, "ui.mode.setup"), true)) {
+                const { main } = await import("../cli/main.js");
+                await main(["setup", "--research"], ctx.io, ctx.env, tree.root);
+            }
+            return { text: "", data: { mode: to, changed: true, tasks: moved } };
+        }
         return {
             // the sentence in the research's language (found on Windows: "T0001 put aside: the research is an archive")
             text: ui(lang, to === "archive" ? "ui.mode.now.archive" : "ui.mode.now.research", { n: moved.length }),

package/dist/core/import.js

@@ -3,7 +3,8 @@
 // A family tree is somebody's conclusions, not a record: everything becomes
 // status "lead", citing one source "family tree <file>", and every person
 // keeps a reference to where it came from. Persons whose REFN is one of our
-// IDs (a tree coming back from the Strom app) are matched, not duplicated.
+// IDs in a tree of this research coming back from the Strom app are matched,
+// not duplicated — another research's IDs never (oursByRefn).
 import { eventKind, FAMILY_EVENT_KINDS, NOTE_MAX } from "./model.js";
 import { normalizeAge } from "./age.js";
 import { foldText } from "./text.js";
@@ -198,13 +199,11 @@ export function importGedcom(tree, text, opts) {
         const individuals = records.filter((x) => x.tag === "INDI" && x.xref);
         // IDs first, so that associations (a godparent's ASSO) point at the right person.
         const fresh = new Set();
-        for (const r of individuals) {
-            const refn = val(r, "REFN");
-            // one of ours — merged into another since the export: that one
-            let ours = refn && /^P\d{4,}$/.test(refn) ? tree.get(refn) : undefined;
-            for (let hops = 0; ours?.mergedInto && hops < 10; hops++)
-                ours = tree.get(ours.mergedInto);
-            if (ours && !ours.retracted) {
+        const treeId = val(records.find((x) => x.tag === "HEAD"), "_STROM_TREE")?.trim();
+        const ourPeople = oursByRefn(tree, treeId, individuals.map((r) => ({ refn: val(r, "REFN"), names: r.children.filter((c) => c.tag === "NAME").map((c) => c.value) })));
+        for (const [i, r] of individuals.entries()) {
+            const ours = ourPeople[i];
+            if (ours) {
                 xrefToId.set(r.xref, ours.id);
                 result.matched++;
             }
@@ -497,6 +496,38 @@ export function importGedcom(tree, text, opts) {
     });
     return result;
 }
+/**
+ * Our people by the REFNs a family tree carries (a tree of this research coming back from the Strom app), in the order
+ * of its people. A file of this research (its _STROM_TREE) is ours by the IDs alone, whatever the names; another
+ * research's never — its P0001 is somebody else (found: the app's file of another tree matched by its IDs, "this
+ * research's tree coming back"); a file that names no research (the standard file, another program) only where most
+ * of the people its IDs name are alike by name — and then each by its name too. Merged since: the one it went into.
+ */
+function oursByRefn(tree, treeId, people) {
+    if (treeId && treeId !== tree.config.id)
+        return people.map(() => undefined);
+    const found = people.map(({ refn }) => {
+        if (!refn || !/^P\d{4,}$/.test(refn.trim()))
+            return undefined;
+        let ours = tree.get(refn.trim());
+        for (let hops = 0; ours?.mergedInto && hops < 10; hops++)
+            ours = tree.get(ours.mergedInto);
+        return ours && ours.type === "person" && !ours.retracted ? ours : undefined;
+    });
+    if (treeId)
+        return found;
+    // a word of the name in common, or the same name of a single letter or digit ("1", "J.")
+    const norm = (s) => foldText(s.replace(/\//g, " "));
+    const words = (s) => new Set(norm(s).split(" ").filter((w) => w.length > 1));
+    const alike = (ours, names) => ours.names.some((n) => {
+        const mine = `${n.given} ${n.surname}`;
+        const w = words(mine);
+        return names.some((t) => (!!norm(t) && norm(t) === norm(mine)) || [...words(t)].some((x) => w.has(x)));
+    });
+    const named = found.map((ours, i) => (ours && alike(ours, people[i].names) ? ours : undefined));
+    const resolved = found.filter(Boolean).length;
+    return named.filter(Boolean).length * 2 > resolved ? named : people.map(() => undefined);
+}
 /** The title of the source an imported tree becomes, in the research language. */
 function importLabel(lang) {
     return { cs: "Rodokmen", de: "Stammbaum", pl: "Drzewo genealogiczne", sk: "Rodokmeň" }[lang] ?? "Family tree";
@@ -530,9 +561,12 @@ export function importStromJson(tree, data, opts) {
         result.source = source.id;
         const idMap = new Map();
         const cite = (sp, what) => [{ source: source.id, locator: `${sp.id} ${what}` }];
-        for (const sp of Object.values(data.persons)) {
-            if (sp.refn && /^P\d{4,}$/.test(sp.refn) && tree.get(sp.refn)) {
-                idMap.set(sp.id, sp.refn);
+        const all = Object.values(data.persons);
+        const ourPeople = oursByRefn(tree, data.research?.id, all.map((sp) => ({ refn: sp.refn, names: [[sp.firstName, sp.lastName].filter(Boolean).join(" "), ...(sp.nameVariants ?? [])] })));
+        for (const [i, sp] of all.entries()) {
+            const ours = ourPeople[i];
+            if (ours) {
+                idMap.set(sp.id, ours.id);
                 result.matched++;
                 continue;
             }

package/dist/core/live.js

@@ -14,7 +14,9 @@
 //                          text: its lines as the user reads them, kinds: what each is about)
 //   GET <token>/recent     what the research added in the last hours (?hours=1…168, 24 when not given): the people and
 //                          sources added, the commits — the same as /status recent (core/recent.ts)
-//   GET <token>/events     server-sent events: hello, change, working
+//   GET <token>/events     server-sent events: hello, change, working; end before the bridge ends ({reason: stopped |
+//                          restart | idle | gone | signal, back: another bridge at this address at once — absent: not
+//                          known, at}): strom live stop asks it through .strom/live-stop.json, the same on every system
 //   POST <token>/sync      the Strom app sends the user's edited tree back (?send=, or on its own): kept in the
 //                          inbox to be shown and written on the user's word (strom sync) — nothing of the
 //                          research changes; /status says what waits there (inbox) and how each send went (sends)
@@ -376,7 +378,7 @@ export function startLive(root, env, opts = {}) {
 }
 function startNow(root, env, running) {
     if (running)
-        stopLive(root, `a bridge of strom ${VERSION} is wanted (this one: ${running.version ?? "older"})`);
+        stopLive(root, `a bridge of strom ${VERSION} is wanted (this one: ${running.version ?? "older"})`, { back: true });
     fs.rmSync(liveFile(root), { force: true });
     const before = readLast(root);
     spawnBridge(root, env);
@@ -434,10 +436,10 @@ export function forgetLive(root) {
     noteLive(root, "its address forgotten (strom live stop --forget): the next bridge gets a new one");
 }
 /** Whether a process is a bridge of strom (its command says "live serve"): a number taken by another program is never stopped. */
-function isBridge(pid) {
+function isBridge(pid, platform = process.platform) {
     if (!alive(pid))
         return false;
-    if (process.platform === "win32")
+    if (platform === "win32")
         return true;
     const r = spawnSync("ps", ["-o", "stat=,command=", "-p", String(pid)], { encoding: "utf8", timeout: 10_000 });
     // ps not to be asked: the bridge's own note is what there is
@@ -446,12 +448,29 @@ function isBridge(pid) {
     const out = (r.stdout ?? "").trim();
     return !out.startsWith("Z") && /\blive\s+serve\b/.test(out);
 }
+/** Where a bridge is asked to end: the same way on every system (a signal on Windows ends a process without a word). */
+export function liveStopFile(root) {
+    return path.join(root, ".strom", "live-stop.json");
+}
+function readStopAsk(root) {
+    try {
+        const ask = JSON.parse(fs.readFileSync(liveStopFile(root), "utf8"));
+        return Number.isInteger(ask.pid) && typeof ask.why === "string" ? ask : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
- * End a bridge's process: asked to (SIGTERM — it closes as it should), and when it does not end within a while
- * (a bridge stuck on something) ended for good (SIGKILL). How it ended; "alive" when even that did not end it.
+ * End a bridge's process: asked to through its stop file (it says the end to the app, closes its streams and ends — the
+ * same on every system), else (a bridge of an older strom, or one stuck) by a signal: SIGTERM where a process hears it,
+ * and when it does not end within a while ended for good (SIGKILL; on Windows a signal is that at once). How it ended:
+ * "stopped" as it should, "killed" for good, "alive" when even that did not end it, "gone" when no bridge ran.
  */
-function endBridge(pid, root, waitMs = 3000) {
-    if (!isBridge(pid))
+export function endBridge(pid, root, opts = {}) {
+    const platform = opts.platform ?? process.platform;
+    const waitMs = opts.waitMs ?? 3000;
+    if (!isBridge(pid, platform))
         return "gone";
     // a bridge of another folder (a note copied with the research) is never ended for this tree
     if (bridgeElsewhere(pid, root))
@@ -460,37 +479,70 @@ function endBridge(pid, root, waitMs = 3000) {
     const ended = () => {
         if (!alive(pid))
             return true;
-        if (process.platform === "win32")
+        if (platform === "win32")
             return false;
         const r = spawnSync("ps", ["-o", "stat=", "-p", String(pid)], { encoding: "utf8", timeout: 5000 });
         return !r.error && (!(r.stdout ?? "").trim() || (r.stdout ?? "").trim().startsWith("Z"));
     };
-    const gone = (ms) => {
+    const gone = (ms, also = () => false) => {
         for (let t = 0; t < ms; t += 100) {
-            if (ended())
+            if (ended() || also())
                 return true;
             sleep(100);
         }
-        return ended();
+        return ended() || also();
     };
+    const file = liveStopFile(root);
+    const taken = () => readStopAsk(root)?.pid !== pid;
     try {
-        process.kill(pid, "SIGTERM");
-    }
-    catch {
-        return "gone";
-    }
-    if (gone(waitMs))
-        return "stopped";
-    try {
-        process.kill(pid, "SIGKILL");
+        let asked = false;
+        try {
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.writeFileSync(`${file}.${process.pid}`, JSON.stringify({ pid, why: opts.why ?? "asked to end", ...(opts.back === undefined ? {} : { back: opts.back }) }));
+            fs.renameSync(`${file}.${process.pid}`, file);
+            asked = true;
+        }
+        catch {
+            // its folder cannot be written: a signal is what there is
+        }
+        // heard: it takes the ask within a moment, then ends (its last streams closed)
+        if (asked && gone(opts.askMs ?? 1000, taken)) {
+            if (gone(waitMs + 1000))
+                return "stopped";
+        }
+        else {
+            // not heard (a bridge of an older strom, one stuck): asked by a signal — on Windows that ends it at once, unheard
+            const signal = platform === "win32" ? "SIGKILL" : "SIGTERM";
+            try {
+                process.kill(pid, signal);
+            }
+            catch (e) {
+                return e.code === "ESRCH" ? "stopped" : "alive";
+            }
+            if (gone(platform === "win32" ? 2000 : waitMs))
+                return platform === "win32" ? "killed" : "stopped";
+            if (platform === "win32")
+                return "alive";
+        }
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch (e) {
+            return e.code === "ESRCH" ? "stopped" : "alive";
+        }
+        return gone(2000) ? "killed" : "alive";
     }
-    catch {
-        return "stopped";
+    finally {
+        // an ask nobody took is not left for a bridge that comes later with that number
+        if (readStopAsk(root)?.pid === pid)
+            fs.rmSync(file, { force: true });
     }
-    return gone(2000) ? "killed" : "alive";
 }
-/** Stop the bridge of a tree (why: into its log): how it went — "none" when none ran, "alive" when it could not be ended. */
-export function stopLive(root, why = "strom live stop") {
+/**
+ * Stop the bridge of a tree (why: into its log; back: another bridge comes at its address at once — the app following it
+ * goes on): how it went — "none" when none ran, "alive" when it could not be ended.
+ */
+export function stopLive(root, why = "strom live stop", opts = {}) {
     const info = liveRunning(root);
     if (!info)
         return "none";
@@ -498,7 +550,7 @@ export function stopLive(root, why = "strom live stop") {
     const last = readLast(root);
     if (last?.pid === info.pid)
         writeLast(root, { ...last, ended: { at: new Date().toISOString(), reason: why } });
-    const how = endBridge(info.pid, root);
+    const how = endBridge(info.pid, root, { why, back: opts.back ?? false });
     if (how === "elsewhere") {
         noteLive(root, `a bridge of another folder (${info.pid}) is named in live.json: not ended, not this tree's`);
         fs.rmSync(liveFile(root), { force: true });
@@ -511,7 +563,8 @@ export function stopLive(root, why = "strom live stop") {
         return "alive";
     }
     fs.rmSync(liveFile(root), { force: true });
-    return how === "gone" ? "stopped" : how;
+    // no bridge of that number ran (it ended meanwhile, the number another program's): none was stopped
+    return how === "gone" ? "none" : how;
 }
 /**
  * The bridge of a tree that ended without a word (a crash, killed) is started again — on its address, so the
@@ -623,7 +676,7 @@ function idsOf(applied, known) {
     return Object.keys(ids.persons).length || Object.keys(ids.sources).length ? { ids } : {};
 }
 /** What the bridge does that an app may ask about (each added once, never taken away). */
-export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes", "hypothesis.links", "status.recent", "spend.readers", "hypothesis.intree", "archive.permission", "task.check", "waiting.groups", "waiting.sent", "waiting.note", "batch.kept"];
+export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes", "hypothesis.links", "status.recent", "spend.readers", "hypothesis.intree", "archive.permission", "task.check", "waiting.groups", "waiting.sent", "waiting.note", "batch.kept", "live.end"];
 /** /status recent, when it is ready. */
 function recentOf(root, env, head) {
     const recent = head ? recentNow(root, env, head) : undefined;
@@ -2330,7 +2383,7 @@ export function serveLive(root, env) {
                 // the bridge before this one still holds it (stuck, or ending just now): ended, its port taken again — the
                 // app following the address goes on; a port another program holds: another one (the app needs ?live= again)
                 const before = last && last.pid !== process.pid ? last.pid : undefined;
-                const ended = before && tries === 0 ? endBridge(before, root) : "gone";
+                const ended = before && tries === 0 ? endBridge(before, root, { why: `a new bridge (${process.pid}) takes port ${wanted}`, back: true }) : "gone";
                 if (ended === "elsewhere") {
                     // a bridge of another folder (its note copied with the research): never ended, never its address — a new one
                     noteLive(root, `a bridge of another folder (${before}) holds port ${wanted}: not ended`);
@@ -2441,6 +2494,7 @@ export function serveLive(root, env) {
                     return noteLive(root, `strom ${disk.version} is on disk but does not start (exit ${probe.status ?? probe.signal ?? "?"}${probe.stderr ? `: ${String(probe.stderr).trim().split("\n").pop()?.slice(0, 200)}` : ""}): this bridge (${runs}) goes on`);
                 }
                 noteLive(root, `strom ${disk.version} on disk: the bridge starts again with it (port ${port}, its token kept)`);
+                send("end", { reason: "restart", back: true, at: new Date().toISOString() });
                 for (const st of streams)
                     st.end();
                 streams.clear();
@@ -2485,6 +2539,7 @@ export function serveLive(root, env) {
                                 noteLive(root, `handed over to the bridge of strom ${disk.version} (${child.pid})`);
                                 clearInterval(timer);
                                 clearInterval(keepAlive);
+                                clearInterval(stopAsked);
                                 return resolve();
                             }
                             if (Date.now() < until && child.exitCode === null)
@@ -2509,7 +2564,7 @@ export function serveLive(root, env) {
                 // its research gone (taken off the computer, a test's folder): nothing to follow — even while handing over
                 // (found: bridges of a folder removed in the middle of it left running for hours)
                 if (!fs.existsSync(path.join(root, "strom.json")))
-                    return stop("the research is no longer there");
+                    return stop("the research is no longer there", "gone", false);
                 if (renewing)
                     return;
                 if (Date.now() - renewChecked > RENEW_MS) {
@@ -2539,10 +2594,10 @@ export function serveLive(root, env) {
                 if (streams.size)
                     lastAsked = Date.now();
                 if (Date.now() - lastAsked > idleMs)
-                    return stop("idle: nobody asked for a while");
+                    return stop("idle: nobody asked for a while", "idle", false);
                 // its research gone (taken off the computer, a test's folder): nothing to follow
                 if (!fs.existsSync(path.join(root, "strom.json")))
-                    return stop("the research is no longer there");
+                    return stop("the research is no longer there", "gone", false);
                 if (!streams.size)
                     return;
                 safe("a tick", () => {
@@ -2565,9 +2620,22 @@ export function serveLive(root, env) {
                 for (const s of streams)
                     s.write(": still here\n\n");
             }, 20_000);
-            const stop = (why) => {
+            // asked to end (strom live stop, a newer bridge wanted): the same on every system — a signal on Windows ends the
+            // process unheard, and the app following it would learn the end only when it gives up asking
+            const stopAsked = setInterval(() => {
+                const ask = readStopAsk(root);
+                if (ask?.pid !== process.pid)
+                    return;
+                fs.rmSync(liveStopFile(root), { force: true });
+                stop(ask.why, ask.back ? "restart" : "stopped", ask.back ?? false);
+            }, Number(env.STROM_LIVE_STOP_MS ?? 200));
+            // the end said to the app on its streams before they close: whether another bridge comes at this address (it goes
+            // on following) or none (following ends now); a signal from outside: not known (the app asks /status)
+            const stop = (why, reason = "stopped", back) => {
                 clearInterval(timer);
                 clearInterval(keepAlive);
+                clearInterval(stopAsked);
+                send("end", { reason, ...(back === undefined ? {} : { back }), at: new Date().toISOString() });
                 for (const s of streams)
                     s.end();
                 server.close();
@@ -2585,8 +2653,8 @@ export function serveLive(root, env) {
                 noteLive(root, `ended: ${why}`);
                 resolve();
             };
-            process.once("SIGTERM", () => stop("SIGTERM"));
-            process.once("SIGINT", () => stop("SIGINT"));
+            process.once("SIGTERM", () => stop("SIGTERM", "signal"));
+            process.once("SIGINT", () => stop("SIGINT", "signal"));
         });
     });
 }

package/dist/core/state.js

@@ -41,16 +41,18 @@ export function actsAsArchive(tree) {
 /**
  * Work of an agent refused where nobody researches: an archive (nothing of an agent said: where research is switched
  * on), or a research waiting for its agent when the agent asked for is not here either (`strom run --agent` of another
- * one here goes on). One sentence in the research's language, a code for a program (the Strom app says it in its own).
+ * one here goes on). One sentence in the research's language (ui.error.archive, ui.error.agent.missing), the command for a
+ * terminal after it; the English and a code for a program and an agent (the Strom app says it in its own).
  */
 export function refuseInArchive(tree, what, agent) {
     const state = stateOf(tree);
     if (state === "research")
         return;
     if (state === "archive")
-        throw new UsageError(ui(tree.lang, "ui.archive.refuse"), { code: "archive", params: { what }, hint: "strom mode research (the person: strom's menu, its first item)" });
+        throw new UsageError(ui("en", "ui.archive.refuse"), { code: "archive", params: { what }, hint: "strom mode research (the person: strom's menu, its first item)" });
     const named = agent ?? new Settings(tree.env, {}).agent(tree.config).value;
     if (agentHere(named, tree.env))
         return;
-    throw new UsageError(ui(tree.lang, "ui.waiting.refuse", { agent: PROFILES[named]?.name ?? named }), { code: "agent.missing", params: { what, agent: named }, hint: "strom setup (the person installs or chooses the agent: strom's menu, its first item)" });
+    const name = PROFILES[named]?.name ?? named;
+    throw new UsageError(ui("en", "ui.waiting.refuse", { agent: name }), { code: "agent.missing", params: { what, agent: named, name }, hint: "strom setup (the person installs or chooses the agent: strom's menu, its first item)" });
 }

package/dist/core/sync.js

@@ -31,7 +31,7 @@ import { fromFlexDate, houseOf, importDate, readGedName, readGedSex, stromAppFil
 import { humanAge, normalizeAge } from "./age.js";
 import { dateYears } from "./gdate.js";
 import { create, update } from "./records.js";
-import { foldText, safeFolderName } from "./text.js";
+import { decodeText, foldText, safeFolderName } from "./text.js";
 import { roleWord } from "./roles.js";
 import { labels } from "../gedcom/labels.js";
 import { eventName, humanDate } from "../cli/human.js";
@@ -936,7 +936,7 @@ export function readStromJson(data) {
 }
 /** A file coming back: GEDCOM or the Strom app's JSON; empty or unreadable throws. */
 export function readTreeFile(file) {
-    const text = fs.readFileSync(file, "utf8");
+    const text = decodeText(fs.readFileSync(file));
     if (!text.trim())
         throw new UsageError(`${path.basename(file)} is empty`, { code: "tree.empty", params: { file: path.basename(file) } });
     let snap;

package/dist/core/text.js

@@ -133,3 +133,25 @@ export function safeFolderName(name) {
         return `${cleaned || "tree"}-1`;
     return cleaned;
 }
+/**
+ * A text file's bytes as text, whatever saved it: UTF-8 with or without a BOM (Notepad, PowerShell 5's
+ * `-Encoding UTF8`), UTF-16 LE or BE by its BOM (PowerShell's `-Encoding Unicode`), or without one when it opens with
+ * two characters of ASCII (a GEDCOM's "0 ", a JSON's "{"). The BOM is never part of the text.
+ */
+export function decodeText(buf) {
+    const b = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+    const le = (from) => b.subarray(from, from + ((b.length - from) & ~1)).toString("utf16le");
+    const be = (from) => Buffer.from(b.subarray(from, from + ((b.length - from) & ~1))).swap16().toString("utf16le");
+    if (b[0] === 0xef && b[1] === 0xbb && b[2] === 0xbf)
+        return b.subarray(3).toString("utf8");
+    if (b[0] === 0xff && b[1] === 0xfe)
+        return le(2);
+    if (b[0] === 0xfe && b[1] === 0xff)
+        return be(2);
+    const ascii = (x) => x !== undefined && x > 0 && x < 0x80;
+    if (b.length >= 4 && ascii(b[0]) && b[1] === 0 && ascii(b[2]) && b[3] === 0)
+        return le(0);
+    if (b.length >= 4 && b[0] === 0 && ascii(b[1]) && b[2] === 0 && ascii(b[3]))
+        return be(0);
+    return b.toString("utf8").replace(/^/, "");
+}

package/dist/core/tree.js

@@ -27,7 +27,7 @@ import { lastBackup } from "./backup.js";
 export const TREE_FILE = "strom.json";
 // between releases the candidate being made (a bridge run from the sources says what it is: the Strom app goes by it);
 // at a release the release's own (package.json)
-export const VERSION = "1.15.0-beta.2";
+export const VERSION = "1.15.0-beta.3";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.15.0-beta.2",
+  "version": "1.15.0-beta.3",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {