strom-research 1.4.1 → 1.6.0

package/dist/commands/research.js

@@ -4,6 +4,7 @@ import { lines, table } from "../cli/format.js";
 import { addPerson, addResearch } from "../core/actions.js";
 import { applyFrontier, researchProposals } from "./session.js";
 import { frontier } from "../core/frontier.js";
+import { DEATH_AFTER_YEARS, livingBorn, unprovenPeople } from "../core/review.js";
 import { parkedWhy } from "./tasks.js";
 import { ui } from "../cli/ui.js";
 import { phrase } from "../core/phrases.js";
@@ -145,31 +146,57 @@ register({
         };
     },
 });
+/** People without a record in one review at a time. */
+export const UNPROVEN_BATCH = 10;
 register({
     path: ["review"],
-    summary: "Review one person: what the tree already says of them elsewhere, entries to read whole, facts to check — as tasks",
+    summary: "Review a person, several, or those no record proves: what the tree says of them elsewhere, entries to read, facts to check — as tasks",
     group: "research",
     tree: true,
     writes: true,
-    description: "Sends the research straight to one person. strom looks at what is recorded and proposes the work, at\n" +
-        "most one task of each kind: what records, notes and the diary say of them outside their data; entries whose\n" +
-        "images are here but were not read whole (transcript, godparents, witnesses, house); facts resting on one\n" +
-        "reading; conflicts left open; with --reread, a second reading of what only another model read — after the\n" +
-        "agent or the model changed. Birth, parents and the story come as in any research. Run again later: what a\n" +
-        "task took up is not proposed again. Nothing is deleted; corrections go through strom with their reasons.",
-    args: [{ name: "person", description: "whom (ID or name)", required: true }],
+    description: "Sends the research straight to one person — or to several named at once (one review for them all), or with\n" +
+        "--unproven to the people no record of their own proves (strom person list --unproven), a batch at a time: run\n" +
+        "it again for the next batch; who is proved leaves the review. strom looks at what is recorded and proposes\n" +
+        "the work, at most one task of each kind for a person: what records, notes and the diary say of them outside\n" +
+        "their data; entries whose images are here but were not read whole (transcript, godparents, witnesses,\n" +
+        "house); facts resting on one reading; conflicts left open; with --reread, a second reading of what only\n" +
+        "another model read — after the agent or the model changed. Birth, parents and the story come as in any\n" +
+        "research. Run again later: what a task took up, or a task open elsewhere covers, is not proposed again.\n" +
+        "Nothing is deleted; corrections go through strom with their reasons.",
+    args: [{ name: "person", description: "whom (ID or name); several: one review for them all; none with --unproven", variadic: true }],
     options: [
-        { name: "scope", type: "string", value: "<scope>", description: "person (default), family (with partners and children), line (with the ancestors)" },
+        { name: "scope", type: "string", value: "<scope>", description: "one person: person (default), family (with partners and children), line (with the ancestors)" },
+        { name: "unproven", type: "boolean", description: "the people no record of their own proves (strom person list --unproven), a batch at a time" },
+        { name: "max", type: "string", value: "<n>", description: `with --unproven: at most so many people in the batch (default ${UNPROVEN_BATCH})` },
+        { name: "living", type: "boolean", description: "review someone most likely alive (born less than 100 years ago) all the same — the user asked for it" },
         { name: "reread", type: "boolean", description: "also a second reading of what only another model read (the model you read with now: model.vision)" },
         { name: "model", type: "string", value: "<model>", description: "with --reread: this model instead of model.vision" },
     ],
-    examples: ["strom review P0001", 'strom review "Josef Novák" --scope family', "strom review P0001 --reread", "strom review P0001 --dry-run"],
-    run(ctx, { args, opts }) {
+    examples: [
+        "strom review P0001",
+        'strom review "Josef Novák" --scope family',
+        "strom review P0001 P0002",
+        "strom review --unproven",
+        "strom review P0001 --reread",
+        "strom review P0001 --dry-run",
+    ],
+    async run(ctx, { args, opts }) {
         const tree = ctx.tree();
-        const p = resolvePerson(tree, args[0]);
+        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>" });
+        if (!unproven && !args.length)
+            throw new UsageError("whom? a person, several, or --unproven", { hint: "strom review P0001 · strom review P0001 P0002 · strom review --unproven" });
+        if (!unproven && opts.max !== undefined)
+            throw new UsageError("--max goes with --unproven");
+        if ((unproven || args.length > 1) && opts.scope !== undefined)
+            throw new UsageError("--scope is for one person's review");
         const scope = opts.scope ?? "person";
         if (!REVIEW_SCOPES.includes(scope))
             throw new UsageError(`--scope must be one of ${REVIEW_SCOPES.join(", ")}`);
+        const max = int(opts.max, "max") ?? UNPROVEN_BATCH;
+        if (max < 1)
+            throw new UsageError("--max must be 1 or more");
         let reread;
         if (opts.reread) {
             reread = opts.model ?? ctx.settings.models(ctx.settings.agent(tree.config).value, tree.config).vision;
@@ -178,26 +205,61 @@ register({
         }
         else if (opts.model)
             throw new UsageError("--model goes with --reread");
-        const review = { scope: scope, ...(reread ? { reread } : {}) };
         const lang = tree.lang;
-        // one review research per person: again later, it goes on where it was
-        const existing = tree.list("research").find((r) => r.direction === "person" && r.focus === p.id && r.review);
+        const chosen = [...new Map(args.map((a) => resolvePerson(tree, a)).map((x) => [x.id, x])).values()];
+        // the living are the family's to tell: reviewed only when the person says so
+        const living = chosen.map((x) => ({ x, born: livingBorn(tree, x) })).filter((l) => l.born !== undefined);
+        if (living.length && !opts.living && !ctx.yes && !tree.dryRun) {
+            const who = living.map((l) => `${label(l.x)}`).join(", ");
+            if (ctx.interactive && !isAgent(ctx.env)) {
+                if (!(await ctx.confirm(ui(lang, "ui.review.living", { who, years: DEATH_AFTER_YEARS }), false)))
+                    return { text: ui(lang, "ui.review.living.no"), data: { research: null, created: [], planned: [], open: [], living: living.map((l) => l.x.id) } };
+            }
+            else
+                throw new UsageError(`most likely alive (born less than ${DEATH_AFTER_YEARS} years ago, no death recorded): ${who}`, {
+                    hint: `ask the user whether to review them all the same; if yes: strom review ${args.join(" ")} --living`,
+                });
+        }
+        const p = chosen.length === 1 ? chosen[0] : undefined;
+        const several = chosen.length > 1;
+        const sameSet = (ids) => !!ids && ids.length === chosen.length && chosen.every((x) => ids.includes(x.id));
+        // one review research per person, per set of people, one of the people without a record: again later, it goes on where it was
+        const existing = tree
+            .list("research")
+            .find((r) => r.direction === "person" &&
+            r.review &&
+            (unproven ? !!r.review.unproven : several ? !r.review.unproven && sameSet(r.review.people) : !r.review.people && r.focus === p.id));
+        let review = { scope: scope, ...(reread ? { reread } : {}) };
+        let left = 0;
+        if (unproven) {
+            const batch = unprovenBatch(tree, existing, max, review);
+            if (!batch.people.length)
+                return { text: ui(lang, "ui.review.unproven.none"), data: { research: existing ?? null, created: [], planned: [], open: [] } };
+            review = { ...review, people: batch.people, unproven: true };
+            left = batch.left;
+        }
+        else if (several)
+            review = { ...review, people: chosen.map((x) => x.id) };
+        const names = chosen.map((x) => displayName(x));
+        const name = unproven ? phrase(lang, "review.unproven.research") : names.length > 3 ? `${names.slice(0, 3).join(", ")} +${names.length - 3}` : names.join(", ");
+        const focus = p?.id ?? review.people[0];
         // What it would propose, asked before anything is written: with nothing to do, no research is made for it.
         const draft = existing
-            ? { ...existing, state: "active", review }
-            : { id: "G?", type: "research", name: phrase(lang, "review.research", { name: displayName(p) }), focus: p.id, direction: "person", state: "active", review, notes: [] };
+            ? { ...existing, focus, state: "active", review }
+            : { id: "G?", type: "research", name: unproven ? name : phrase(lang, "review.research", { name }), focus, direction: "person", state: "active", review, notes: [] };
         const planned = researchProposals(tree, draft).map((x) => x.proposal);
         let research = draft;
         let tasks = [];
+        const what = unproven ? `${review.people.length} without a record of their own` : several ? review.people.join(" ") : scope;
         if (planned.length && !tree.dryRun) {
             if (existing)
-                research = update(tree, existing.id, "research", (r) => ({ ...r, state: "active", review }), {
+                research = update(tree, existing.id, "research", (r) => ({ ...r, focus, state: "active", review }), {
                     op: "research.edit",
-                    summary: `${existing.id} review again: ${scope}${reread ? `, second reading with ${reread}` : ""}`,
+                    summary: `${existing.id} review again: ${what}${reread ? `, second reading with ${reread}` : ""}`,
                 });
             else {
-                const r = addResearch(tree, { name: draft.name, focus: p.id, direction: "person" });
-                research = update(tree, r.id, "research", (x) => ({ ...x, review }), { op: "research.edit", summary: `${r.id} review: ${scope}${reread ? `, second reading with ${reread}` : ""}` });
+                const r = addResearch(tree, { name: draft.name, focus, direction: "person" });
+                research = update(tree, r.id, "research", (x) => ({ ...x, review }), { op: "research.edit", summary: `${r.id} review: ${what}${reread ? `, second reading with ${reread}` : ""}` });
             }
             tasks = applyFrontier(tree, research)
                 .map((id) => tree.get(id))
@@ -219,12 +281,39 @@ register({
         // Nothing new: why — the work that covers them already (a parked task says how to go on), a search done in vain.
         const why = list.length ? [] : coveredLines(tree, draft, lang, human);
         const inReview = existing ?? (planned.length && !tree.dryRun ? research : undefined);
-        const text = lines(...(human ? [] : tree.written.map((o) => o.summary)), tree.dryRun ? ui(lang, "ui.review.dry") : undefined, (tree.written.length && !human) || tree.dryRun ? "" : undefined, list.length ? ui(lang, "ui.review.new", { name: label(p), n: list.length }) : ui(lang, "ui.review.nothing", { name: label(p) }), ...list, ...why, open.length || tasks.length
+        const text = lines(...(human ? [] : tree.written.map((o) => o.summary)), tree.dryRun ? ui(lang, "ui.review.dry") : undefined, (tree.written.length && !human) || tree.dryRun ? "" : undefined, list.length ? ui(lang, "ui.review.new", { name: p ? label(p) : name, n: list.length }) : ui(lang, "ui.review.nothing", { name: p ? label(p) : name }), ...list, ...why, open.length || tasks.length
             ? ui(lang, "ui.review.open", { n: open.length || tasks.length, research: inReview.id }) + (avg !== undefined ? ui(lang, "ui.review.cost", { cost: avg.toFixed(2) }) : "")
-            : undefined, (open.length || tasks.length) && inReview ? ui(lang, human ? "ui.review.next.human" : "ui.review.next", { research: inReview.id }) : undefined);
-        return { text, data: { research: inReview ?? null, created: tasks, planned, open: open.map((t) => t.id), ...(why.length ? { why } : {}), ...(avg !== undefined ? { avgCostUsd: avg } : {}) } };
+            : undefined, (open.length || tasks.length) && inReview ? ui(lang, human ? "ui.review.next.human" : "ui.review.next", { research: inReview.id }) : undefined, left ? ui(lang, human ? "ui.review.unproven.left.human" : "ui.review.unproven.left", { n: left }) : undefined);
+        return {
+            text,
+            data: { research: inReview ?? null, created: tasks, planned, open: open.map((t) => t.id), ...(unproven ? { people: review.people, left } : {}), ...(why.length ? { why } : {}), ...(avg !== undefined ? { avgCostUsd: avg } : {}) },
+        };
     },
 });
+const OPEN_TASK = new Set(["open", "doing", "parked", "waiting"]);
+/**
+ * The next batch of people without a record of their own: those whose tasks of the review are still open stay;
+ * then the ones strom has work for — a record naming them first (the quickest to prove), then leads, then
+ * nothing — those never in a batch before those tried already. How many more wait besides.
+ */
+function unprovenBatch(tree, existing, max, review) {
+    // the living are the family's to tell: no research of the registers for them
+    const all = unprovenPeople(tree).filter((u) => !u.living);
+    const tasks = existing ? tree.list("task").filter((t) => t.research === existing.id) : [];
+    const busy = (id) => tasks.some((t) => t.subject.includes(id) && OPEN_TASK.has(t.state));
+    const keep = all.filter((u) => busy(u.person.id)).map((u) => u.person.id);
+    const before = new Set(existing?.review?.people ?? []);
+    const order = { named: 0, leads: 1, none: 2 };
+    const rest = all
+        .filter((u) => !keep.includes(u.person.id))
+        .sort((a, b) => Number(before.has(a.person.id)) - Number(before.has(b.person.id)) || order[a.kind] - order[b.kind] || a.person.id.localeCompare(b.person.id));
+    // only those strom has work for: what it would propose for all of them, asked once
+    const draft = { ...(existing ?? { id: "G?", type: "research", name: "", direction: "person", state: "active", notes: [] }), review: { ...review, people: rest.map((u) => u.person.id), unproven: true } };
+    const planned = researchProposals(tree, { ...draft, focus: rest[0]?.person.id ?? "" }).map((x) => x.proposal);
+    const workable = rest.filter((u) => planned.some((x) => x.subject.includes(u.person.id))).map((u) => u.person.id);
+    const people = [...keep, ...workable].slice(0, Math.max(max, keep.length));
+    return { people, left: all.length - people.length };
+}
 /** Why a review found nothing new, person by person: the work that covers them already, or a search done in vain. */
 function coveredLines(tree, research, lang, human = false) {
     const out = [];

package/dist/commands/setup.js

@@ -20,9 +20,10 @@ import { VERSION } from "../core/tree.js";
 import { installUpdate, isNewer, knownNewerVersion, latestVersion, newerNode, newerVersion } from "../core/update.js";
 import { desktopDir } from "../core/paths.js";
 import { planMove } from "../core/relocate.js";
-import { researchUrl, stromAppUrl, stromAppState } from "../core/stromapp.js";
+import { appOpensLinks, researchUrl, stromAppUrl, stromAppState } from "../core/stromapp.js";
 import { isInstalled } from "../agents/global.js";
-import { shortcutName } from "../cli/wizard.js";
+import { offerLinks, shortcutName } from "../cli/wizard.js";
+import { linkHandlerState } from "../core/links.js";
 import { globalTargets, installGlobal } from "../agents/global.js";
 import { ui } from "../cli/ui.js";
 import { PERMISSION_LEVELS } from "../core/config.js";
@@ -225,6 +226,14 @@ function diagnose(ctx) {
         add("shortcut", "warn", t("ui.doc.none"), FIX, "shortcut");
     const app = stromAppState(ctx.settings);
     add("app", "ok", t(`ui.doc.app.${app}`), app === "unknown" ? FIX : undefined, app === "unknown" ? "app" : undefined);
+    // …and whether it may start the research here (strom-research:// links): only while the app is wanted
+    if (app !== "no" && appOpensLinks(ctx.settings)) {
+        const links = linkHandlerState(ctx.env);
+        if (links === "ours")
+            add("links", "ok", t("ui.doc.links.ours"));
+        else
+            add("links", "warn", t(`ui.doc.links.${links}`), FIX, "links");
+    }
     if (ctx.hasTree()) {
         const tr = ctx.tree();
         const errs = check(tr).filter((f) => f.level === "error").length + verifyFull(tr).findings.filter((f) => f.level === "error").length;
@@ -257,6 +266,8 @@ async function repair(ctx, checks, out) {
         for (const f of createShortcut(shortcutName(lang), ctx.env))
             out(ui(lang, "ui.setup.shortcut.done", { file: ctx.display(f) }));
     }
+    if (todo.has("links") && person)
+        await offerLinks(ctx, lang);
     if (todo.has("app") && person && (await ctx.confirm(ui(lang, "ui.fix.app"), false))) {
         openForUser(stromAppUrl(ctx.settings), ctx.env);
         out(ui(lang, "ui.app.install"));

package/dist/commands/start.js

@@ -18,7 +18,8 @@ import { DESKTOP_APPS, agentsHere, whereToTalk } from "../core/apps.js";
 import { assertIntact } from "../core/integrity.js";
 import { treeBrowserConnectors } from "../core/connector.js";
 import { browserNote } from "./connectors.js";
-import { appOpensResearch, importAppUrl, installedStromApp, liveAppUrl, noticeStromApp, STROM_APP_URL, stromAppUrl } from "../core/stromapp.js";
+import { offerLinks } from "../cli/wizard.js";
+import { appOpensLinks, appOpensResearch, importAppUrl, installedStromApp, liveAppUrl, noticeStromApp, STROM_APP_URL, stromAppUrl } from "../core/stromapp.js";
 import { liveRunning, serveLive, startLive, stopLive } from "../core/live.js";
 import { openForUser } from "../core/open.js";
 import { createShortcut, openInNewTerminal } from "../core/shortcut.js";
@@ -193,7 +194,7 @@ register({
         { name: "images", type: "boolean", description: "each entry with its image (the default; kept for older scripts)" },
     ],
     examples: ["strom app", "strom app --live", "strom app install"],
-    run(ctx, { opts }) {
+    async run(ctx, { opts }) {
         const lang = ctx.uiLang();
         const root = appOpensResearch(ctx.settings) ? ctx.locateTree() : undefined;
         if (root) {
@@ -217,6 +218,9 @@ register({
             const webApp = installed?.appId && installed.browser ? { browser: installed.browser, appId: installed.appId, ...(installed.profile ? { profile: installed.profile } : {}) } : undefined;
             const browser = chromiumBrowser(ctx.env);
             if (webApp || browser) {
+                // The first time a person opens the research in an app that opens links: may it start the research here? (once)
+                if (ctx.interactive && !isAgent(ctx.env) && appOpensLinks(ctx.settings, ctx.settings.stromVersion(tree.config)) && ctx.settings.config.links === undefined)
+                    await offerLinks(ctx, lang, { ask: false });
                 // The bridge serves the tree's GEDCOM to the app; it ends by itself when nobody asks it anything.
                 const info = startLive(root, ctx.env, { current: true });
                 if (!info)

package/dist/commands/story.js

@@ -4,7 +4,7 @@
 import fs from "node:fs";
 import { register } from "../cli/registry.js";
 import { lines } from "../cli/format.js";
-import { setStory, findEventOwner } from "../core/actions.js";
+import { approveStory, setStory, findEventOwner } from "../core/actions.js";
 import { UsageError } from "../core/errors.js";
 import { csvOpt, normId, textOpt } from "../core/records.js";
 import { resolvePerson } from "../core/people.js";
@@ -43,6 +43,22 @@ register({
         const missing = rec.story.facts.length === 0 ? "note: no --fact given — say which facts the story rests on" : undefined;
         return { text: lines(...tree.written.map((o) => o.summary), tree.dryRun ? "(dry run — nothing written)" : undefined, missing), data: { story: rec.story } };
     },
+}, {
+    path: ["story", "approve"],
+    summary: "The user approved the story as it is: no longer a draft",
+    group: "people",
+    tree: true,
+    writes: true,
+    description: "Only on the user's word (they read it and said it is right): the text stays, the draft becomes the story of the family book.",
+    args: [{ name: "who", description: "person (ID or name) or family (F…)", required: true }],
+    examples: ["strom story approve P0001"],
+    run(ctx, { args }) {
+        const tree = ctx.tree();
+        const id = owner(tree, args[0]);
+        const was = tree.get(id)?.story?.status;
+        const rec = approveStory(tree, id);
+        return { text: was === "final" ? `${id} story was approved already` : lines(...tree.written.map((o) => o.summary)), data: { story: rec.story } };
+    },
 }, {
     path: ["story", "show"],
     summary: "The story of a person or a couple, with the facts it rests on",

package/dist/commands/sync.js

@@ -0,0 +1,243 @@
+// sync · sync undo — a family tree coming back from the Strom app (or another
+// program), compared with the research: what the user changed, taken in on
+// their yes (core/sync.ts).
+import fs from "node:fs";
+import path from "node:path";
+import { register } from "../cli/registry.js";
+import { lines, truncate } from "../cli/format.js";
+import { ui } from "../cli/ui.js";
+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 { now } from "../core/tree.js";
+import { applySync, nothingSince, planSync, readTreeFile, receivedSince, undoSync } from "../core/sync.js";
+import { startLive } from "../core/live.js";
+import { appSendsChanges, installedStromApp, sendAppUrl, stromAppUrl } from "../core/stromapp.js";
+import { chromiumBrowser, openInBrowser, openWebApp } from "../core/chromium.js";
+function factText(f, lang) {
+    if (!f)
+        return "—";
+    return [f.value, humanDate(f.date, lang), humanPlace(f.place, undefined, lang)].filter(Boolean).join(", ") || "—";
+}
+/** One change as the user reads it, with what strom does with it. */
+function changeLine(tree, c, incoming, lang) {
+    const name = (key) => {
+        if (!key)
+            return "?";
+        if (key.startsWith("x:"))
+            return (incoming.persons.get(key)?.names[0] ?? key).replace(/\//g, "").replace(/\s+/g, " ").trim();
+        const p = tree.get(key);
+        return p ? `${(p.names[0] ? `${p.names[0].given} ${p.names[0].surname}` : key).trim()} [${key}]` : key;
+    };
+    const who = c.partners ? c.partners.map(name).join(" & ") || c.family || "?" : name(c.person);
+    const kind = (f) => (f ? eventName(f.kind, lang, f.label) : "");
+    const v = {
+        n: c.n,
+        who,
+        name: name(c.person),
+        kind: kind(c.fact ?? c.was),
+        fact: `${kind(c.fact ?? c.was)} ${factText(c.fact ?? c.was, lang)}`,
+        was: factText(c.was, lang),
+        now: factText(c.fact, lang),
+        text: truncate(c.text ?? "", 120),
+        child: name(c.child),
+        kids: c.kind === "family.new" && c.text ? ` + ${c.text.split(" ").filter(Boolean).map(name).join(", ")}` : "",
+    };
+    return `${ui(lang, `ui.sync.${c.kind}`, v)} → ${ui(lang, `ui.sync.do.${c.action}`)}`;
+}
+function planText(tree, plan, incoming, file, lang, edits) {
+    const shown = file.includes(" ") ? `"${file}"` : file;
+    if (!plan.changes.length)
+        return ui(lang, "ui.sync.nothing", { file: path.basename(file) });
+    return lines(ui(lang, "ui.sync.title", { file: path.basename(file), n: plan.changes.length }), plan.base ? ui(lang, "ui.sync.base", { head: plan.head.slice(0, 8) }) : ui(lang, plan.head ? "ui.sync.headmissing" : "ui.sync.nobase", { head: plan.head?.slice(0, 8) ?? "" }), plan.partial ? ui(lang, "ui.sync.partial") : undefined, plan.identity.strangers.length ? ui(lang, "ui.sync.strangers", { ids: plan.identity.strangers.join(", ") }) : undefined, "", ...plan.changes.map((c) => `  ${changeLine(tree, c, incoming, lang)}`), "", ui(lang, "ui.sync.edits", { mode: ui(lang, edits === "user" ? "ui.sync.mode.user" : "ui.sync.mode.conflict") }), ui(lang, "ui.sync.next", { file: shown }));
+}
+/** The Strom app at this address: installed from a Chromium browser first, else in such a browser's tab (never Safari: it cannot reach the bridge). */
+export function openAppAt(ctx, url) {
+    const installed = installedStromApp(ctx.env, process.platform, stromAppUrl(ctx.settings));
+    const webApp = installed?.appId && installed.browser ? { browser: installed.browser, appId: installed.appId, ...(installed.profile ? { profile: installed.profile } : {}) } : undefined;
+    const browser = chromiumBrowser(ctx.env);
+    return Boolean((webApp && openWebApp(webApp, url, ctx.env)) || (browser && openInBrowser(browser, url, ctx.env)));
+}
+/**
+ * The Strom app sends the tree itself: the bridge started, the app opened with ?send= (installed from a Chromium
+ * browser first, else in such a browser's tab), and the tree waited for. The file it came as, or what to do instead.
+ */
+async function fromApp(ctx, root, lang) {
+    if (!appSendsChanges(ctx.settings))
+        return { text: ui(lang, "ui.sync.nosend") };
+    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 = sendAppUrl(info.url, ctx.settings);
+    const since = Date.now();
+    const opened = openAppAt(ctx, url);
+    const minutes = Math.max(1, Math.round(Number(ctx.env.STROM_SYNC_WAIT_MS ?? 10 * 60_000) / 60_000));
+    ctx.io.stderr(`${opened ? `${ui(lang, "ui.sync.wait", { min: minutes })}\n${ui(lang, "ui.sync.wait.open", { url })}` : ui(lang, "ui.app.url", { url })}\n`);
+    const until = since + Number(ctx.env.STROM_SYNC_WAIT_MS ?? 10 * 60_000);
+    while (Date.now() < until) {
+        const file = receivedSince(root, since);
+        if (file)
+            return { file, text: "" };
+        // the app sends nothing: said at once, not after the whole wait
+        const why = nothingSince(root, since);
+        if (why)
+            return { text: ui(lang, `ui.sync.nothing.${why}`), settled: why !== "no-tree" };
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    return { text: ui(lang, "ui.sync.waited", { min: minutes }) };
+}
+/** A family tree file without the images written into it (data: URLs): a GEDCOM's FILE with its CONC lines, a JSON's strings. */
+export function withoutImages(text) {
+    const left = (bytes) => `[image left out, ${Math.round(bytes / 1024)} kB]`;
+    // GEDCOM: n FILE data:… and the n+1 CONC/CONT lines that go on with it
+    const ged = text.replace(/^(\d+) FILE data:[^\r\n]*(?:\r?\n(?:\d+) CON[CT] [^\r\n]*)*/gm, (m, level) => `${level} FILE ${left(m.length)}`);
+    // JSON: "data:image/…;base64,…"
+    return ged.replace(/"data:image\/[^"]*"/g, (m) => `"${left(m.length)}"`);
+}
+function numbers(v, max) {
+    if (v === undefined)
+        return undefined;
+    const out = new Set();
+    for (const part of String(v).split(/[\s,;]+/).filter(Boolean)) {
+        const m = /^(\d+)(?:-(\d+))?$/.exec(part);
+        if (!m)
+            throw new UsageError(`--only takes numbers of the list, e.g. 1,3,5-7 — not "${part}"`);
+        for (let i = Number(m[1]); i <= Number(m[2] ?? m[1]); i++) {
+            if (i < 1 || i > max)
+                throw new UsageError(`--only: there is no change ${i} (1–${max})`);
+            out.add(i);
+        }
+    }
+    return out;
+}
+register({
+    path: ["sync"],
+    summary: "A family tree coming back (the Strom app, another program): what you changed, into the research — shown first",
+    group: "research",
+    tree: true,
+    writes: true,
+    // the Strom app may take minutes to send the tree: the tree is locked only while a sync is written
+    lock: "sections",
+    description: "Compares the file with the research and shows what it would take: people, facts, names, notes, families and\n" +
+        "children the file has and the research not; facts changed in it; what is no longer in it. A file of the Strom app\n" +
+        "names the state of the research it was given (_STROM_HEAD): only what was changed since then counts as your edit;\n" +
+        "without it (another program, an older export) only additions are taken, differences wait to be picked (--only).\n" +
+        "Nothing is deleted or overwritten: additions are leads citing one source (this sync), a lead is corrected with the\n" +
+        "reason, a change to a fact a record proves is a conflict for you to decide — or, with sync.edits user, your edit\n" +
+        "wins and the record's fact is withdrawn with the reason. A file of another research, or one where few people are\n" +
+        "the research's, is refused. Writes only with --apply; one sync is one commit: strom sync undo I… takes it back.\n" +
+        "--app: the Strom app sends the tree itself — strom opens it (the bridge), the user picks the tree and confirms\n" +
+        "there, strom waits for it and shows what it brings; then strom sync <the file it names> --apply.",
+    args: [{ name: "file", description: "the tree: GEDCOM (.ged) or the Strom app's JSON (none with --app)" }],
+    options: [
+        { name: "app", type: "boolean", description: "straight from the Strom app: it opens, the user sends the tree from it, strom waits for it" },
+        { name: "apply", type: "boolean", description: "write it (without: only show)" },
+        { name: "only", type: "string", value: "<numbers>", description: "with --apply: only these changes of the list (1,3,5-7) — a difference is taken only this way" },
+        { name: "edits", type: "string", value: "<conflict|user>", description: "this once: a change to a fact a record proves is a conflict (default) or your edit wins (setting sync.edits)" },
+        { name: "force", type: "boolean", description: "the file is the research's though few of its people match" },
+        { name: "again", type: "boolean", description: "a file taken in before, once more" },
+    ],
+    examples: ["strom sync ~/Downloads/rodina.ged", "strom sync rodina.ged --apply", "strom sync rodina.json --apply --only 1,4"],
+    async run(ctx, { args, opts }) {
+        const tree = ctx.tree();
+        const lang = tree.lang;
+        if (opts.app && args[0])
+            throw new UsageError("--app takes the tree from the Strom app — no file with it");
+        if (!opts.app && !args[0])
+            throw new UsageError("which tree? a file, or --app (straight from the Strom app)", { hint: "strom sync ~/Downloads/rodina.ged · strom sync --app" });
+        if (opts.app && opts.apply)
+            throw new UsageError("--app shows what the tree brings; write it then with the file it names", { hint: "strom sync --app, then strom sync <file> --apply" });
+        let got;
+        if (opts.app) {
+            const r = await fromApp(ctx, tree.root, lang);
+            // nothing to show: the app said so (nothing changed, cancelled) — or never answered, or has no tree of this research
+            if (!r.file)
+                return { text: r.text, data: { received: null }, exitCode: r.settled ? EXIT.ok : EXIT.needsInput };
+            got = r.file;
+        }
+        const shownAs = got ? ctx.display(got) : args[0];
+        const file = got ?? ctx.resolvePath(args[0]);
+        if (!fs.existsSync(file) || !fs.statSync(file).isFile())
+            throw new UsageError(`no such file: ${args[0]}`);
+        const edits = opts.edits === undefined ? ctx.settings.syncEdits(tree.config) : String(opts.edits);
+        if (edits !== "conflict" && edits !== "user")
+            throw new UsageError("--edits is conflict or user");
+        const sha = fileSha256(file);
+        const before = tree.list("input").find((i) => i.sha === sha && i.sync && !i.sync.undone);
+        if (before && !opts.again)
+            return { text: ui(lang, "ui.sync.again", { input: before.id }), data: { input: before.id, changes: [] } };
+        const incoming = readTreeFile(file);
+        const plan = planSync(tree, incoming, edits, { force: !!opts.force });
+        if (!opts.apply || !plan.changes.length || tree.dryRun) {
+            if (opts.only !== undefined && !opts.apply)
+                throw new UsageError("--only goes with --apply");
+            return {
+                text: lines(got ? ui(lang, "ui.sync.got") : undefined, planText(tree, plan, incoming, shownAs, lang, edits)),
+                data: { ...(got ? { received: got } : {}), base: plan.base, head: plan.head ?? null, partial: plan.partial, changes: plan.changes, strangers: plan.identity.strangers },
+            };
+        }
+        const only = numbers(opts.only, plan.changes.length);
+        let input;
+        let applied = 0;
+        tree.withTreeLock(() => {
+            // what another process wrote meanwhile counts: the changes again, now that the tree is ours
+            const fresh = planSync(tree, readTreeFile(file), edits, { force: !!opts.force });
+            if (fresh.changes.length !== plan.changes.length || fresh.changes.some((c, i) => c.kind !== plan.changes[i].kind || c.person !== plan.changes[i].person))
+                throw new UsageError("the research changed while this was shown — look again", { hint: `strom sync ${args[0] ?? file}` });
+            const id = tree.peekId("I");
+            const size = fs.statSync(file).size;
+            const stored = size <= MAX_IN_TREE ? `inputs/${id}-${safeFolderName(path.basename(file))}` : undefined;
+            if (stored) {
+                tree.remember(path.join(tree.root, stored));
+                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")));
+            }
+            input = 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);
+            const source = create(tree, "source", {
+                kind: "family-tree",
+                title: ui(lang, incoming.treeId || plan.identity.matched ? "ui.sync.source.app" : "ui.sync.source.file", { file: path.basename(file), day }),
+                input: input.id,
+                information: "secondary",
+                form: "authored",
+            }, (sid) => `+${sid} source "${path.basename(file)}" (sync)`);
+            const { applied: done, changes } = applySync(tree, plan, incoming, source, only);
+            applied = changes;
+            input = update(tree, input.id, "input", (i) => ({ ...i, source: source.id, sync: { ...(plan.head ? { head: plan.head } : {}), edits: edits, applied: done } }), {
+                op: "input.sync",
+                summary: `${input.id} synced: ${changes} change(s)${plan.head ? ` against ${plan.head.slice(0, 8)}` : ""}`,
+            });
+        });
+        return {
+            text: lines(...tree.written.map((o) => o.summary), "", ui(lang, "ui.sync.done", { n: applied, file: path.basename(file), input: input.id })),
+            data: { input: input.id, applied: input.sync?.applied ?? [], changes: plan.changes },
+        };
+    },
+}, {
+    path: ["sync", "undo"],
+    summary: "Take a sync back: what it added withdrawn, what it corrected put back, its conflicts closed",
+    group: "research",
+    tree: true,
+    writes: true,
+    args: [{ name: "input", description: "the sync's input (I…), as strom sync said", required: true }],
+    examples: ["strom sync undo I0002"],
+    run(ctx, { args }) {
+        const tree = ctx.tree();
+        const id = args[0].toUpperCase().replace(/^I?(\d+)$/, (_, n) => `I${n.padStart(4, "0")}`);
+        const input = tree.get(id);
+        if (!input || input.type !== "input" || !input.sync)
+            throw new UsageError(`${args[0]} is not a sync`, { hint: "strom input list — a sync's input says so" });
+        if (input.sync.undone)
+            return { text: ui(tree.lang, "ui.sync.wasundone", { input: id }), data: { input: id, undone: 0 } };
+        let n = 0;
+        tree.withTreeLock(() => {
+            n = undoSync(tree, input);
+            update(tree, id, "input", (i) => ({ ...i, sync: { ...i.sync, undone: now() } }), { op: "input.sync.undo", summary: `${id} sync undone: ${n} step(s)` });
+        });
+        return { text: lines(...tree.written.map((o) => o.summary), "", ui(tree.lang, "ui.sync.undone", { input: id, n })), data: { input: id, undone: n } };
+    },
+});

package/dist/core/actions.js

@@ -850,3 +850,18 @@ export function setStory(tree, id, input) {
         return updated;
     });
 }
+/** The user approved the story as it is: no longer a draft (the text stays). */
+export function approveStory(tree, id) {
+    return tree.withTreeLock(() => {
+        const rec = tree.get(id);
+        if (!rec || (rec.type !== "person" && rec.type !== "family"))
+            throw new UsageError(`no person or family ${id}`);
+        if (!rec.story)
+            throw new UsageError(`${id} has no story yet`, { hint: `strom story set ${id} --text @file --fact E…` });
+        if (rec.story.status === "final")
+            return rec;
+        const updated = { ...rec, story: { ...rec.story, status: "final" }, updated: now() };
+        tree.put(updated, { op: "story.approve", targets: [id], summary: `${id} story approved` });
+        return updated;
+    });
+}

package/dist/core/config.js

@@ -44,6 +44,7 @@ export const SETTINGS = [
     { key: "queue.strategy", env: "STROM_QUEUE_STRATEGY", tree: true, kind: "choice", choices: STRATEGIES, description: "order of the task queue: balanced (default — nearest ancestors first, spread over the lines, nothing taken forever), depth (stay on one line), priority (strict priority)" },
     { key: "gedcom.for", env: "STROM_GEDCOM_FOR", tree: true, kind: "choice", choices: ["both", "standard", "strom"], description: "GEDCOM files written: both (default), standard (any program), strom (the Strom app)" },
     { key: "stories", env: "STROM_STORIES", tree: true, kind: "choice", choices: ["yes", "no"], description: "stories of the ancestors for the family, written from the facts: yes (default — strom proposes one once a person's life is told by records), no — the user is told when the research starts and may say no" },
+    { key: "sync.edits", env: "STROM_SYNC_EDITS", tree: true, kind: "choice", choices: ["conflict", "user"], description: "your edits in the Strom app (or another program's file) to a fact a record proves, taken by strom sync: conflict (default — the research keeps the record's, a conflict for you to decide) or user (your edit wins, the record's fact is withdrawn with the reason)" },
     { key: "main.person", env: "STROM_MAIN_PERSON", tree: true, kind: "person", description: "the main person of the tree (P…): first in the GEDCOM files — the Strom app opens on them (default: the nearest person descended from every research's focus, else the first research's focus)" },
     { key: "excerpts.quality", env: "STROM_EXCERPTS_QUALITY", tree: true, kind: "choice", choices: EXCERPT_QUALITIES, description: "the entries cut out of their scans in the file for the Strom app (output/tree-strom.ged): small (1000 px, grey — half the size), normal (default, 1200 px), sharp (1600 px)" },
     { key: "excerpts.for", env: "STROM_EXCERPTS_FOR", tree: true, kind: "choice", choices: EXCERPT_SCOPES, description: "whose entries get their image in the Strom app: none (the file without images), line (the ancestors), family (default: the ancestors and their families), connected (anyone linked to them), all" },
@@ -359,6 +360,10 @@ export class Settings {
         const v = this.resolve("stories", tree)?.value;
         return { on: v !== "no", said: v === "yes" || v === "no" };
     }
+    /** strom sync: whether the user's edit to a fact a record proves wins, or becomes a conflict. */
+    syncEdits(tree) {
+        return this.resolve("sync.edits", tree)?.value === "user" ? "user" : "conflict";
+    }
     /** The images for the Strom app: how sharp, whose, and the limit of all together (MB). */
     excerpts(tree) {
         return {

package/dist/core/dialog.js

@@ -59,3 +59,28 @@ export function systemDialog(text, env, platform = process.platform) {
     }
     return undefined;
 }
+/**
+ * Say something in a window (one button): what a link from the Strom app could not do, with no terminal to say it
+ * in. False when this computer cannot show one.
+ */
+export function systemNotice(title, message, ok, env, platform = process.platform) {
+    if (env.STROM_NO_DIALOG === "1")
+        return false;
+    const run = (cmd, args) => spawnSync(cmd, args, { encoding: "utf8", timeout: (WAIT_SECONDS + 10) * 1000, windowsHide: false, env: env });
+    if (platform === "darwin") {
+        const script = `display dialog ${appleString(message)} with title ${appleString(title)} buttons {${appleString(ok)}} default button ${appleString(ok)} with icon note giving up after ${WAIT_SECONDS}`;
+        return !run("osascript", ["-e", script]).error;
+    }
+    if (platform === "win32") {
+        const ps = `Add-Type -AssemblyName PresentationFramework; [void][System.Windows.MessageBox]::Show(${psString(message)}, ${psString(title)}, 'OK', 'Information', 'OK', 'DefaultDesktopOnly')`;
+        const r = run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", ps]);
+        return !r.error && r.status === 0;
+    }
+    if (!env.DISPLAY && !env.WAYLAND_DISPLAY)
+        return false;
+    if (which("zenity", env))
+        return !run("zenity", ["--info", "--title", title, "--text", message, "--timeout", String(WAIT_SECONDS)]).error;
+    if (which("kdialog", env))
+        return !run("kdialog", ["--title", title, "--msgbox", message]).error;
+    return false;
+}