strom-research 1.4.1 → 1.6.0

package/dist/cli/menu-waiting.js

@@ -12,11 +12,63 @@ import { openForUser } from "../core/open.js";
 const SHOWN = 9;
 /** An answer is a note on the task (500 characters, with what it asked). */
 const ANSWER_MAX = 300;
-export async function waitingForYou(ctx, run, lang, root) {
+/** What to do for a task that waits: the images to save and where, or what it asks. */
+function whatToDo(ctx, lang, tree, x) {
     const t = translator(lang);
-    const out = (line) => ctx.io.stdout(line + "\n");
+    if (!x.awaits)
+        return [`    ${t("ui.waiting.do", { what: x.waitingOn || t("ui.waiting.ask") })}`];
+    const b = tree.get(x.awaits.recordset);
+    return [
+        `    ${t("ui.waiting.images", { images: x.awaits.images, book: b?.title ?? x.awaits.recordset })}${b?.url ? ` · ${b.url}` : ""}`,
+        `    ${t("ui.wait.save", { dir: `${ctx.display(inbox(ctx, x) ?? `inbox/${x.awaits.folder}`)}${path.sep}` })}`,
+    ];
+}
+function inbox(ctx, x) {
     const shared = ctx.settings.shared()?.value;
-    const inbox = (x) => (shared && x.awaits ? path.join(shared, "inbox", x.awaits.folder) : undefined);
+    return shared && x.awaits ? path.join(shared, "inbox", x.awaits.folder) : undefined;
+}
+/** One task that waits, taken up: its folder opened for the images, or the person's answer and the task back in the queue. */
+async function takeUp(ctx, run, lang, root, x) {
+    const t = translator(lang);
+    const out = (line) => ctx.io.stdout(line + "\n");
+    if (x.awaits) {
+        const dir = inbox(ctx, x);
+        if (dir)
+            openForUser(dir, ctx.env);
+        return void out(t("ui.waiting.opened", { dir: dir ? ctx.display(dir) : `inbox/${x.awaits.folder}` }));
+    }
+    let answer = "";
+    for (;;) {
+        answer = (await ctx.ask(t("ui.waiting.write"))).trim();
+        if (!answer || answer === "0")
+            return;
+        // kept as a note on the task, with what it asked: short — a longer story is for a conversation
+        if (answer.length <= ANSWER_MAX)
+            break;
+        out(t("ui.waiting.long", { n: ANSWER_MAX }));
+        if (ctx.io.answers !== undefined && ctx.io.answers.length === 0)
+            return;
+    }
+    // meanwhile taken up by an agent (done, dropped, back in the queue): said, nothing written
+    if (Tree.open(root, ctx.env).get(x.id)?.state !== "waiting")
+        return void out(t("ui.waiting.gone"));
+    if ((await run(["task", "wake", x.id, `--answer=${answer}`], true)) !== 0)
+        return;
+    out(t("ui.waiting.back"));
+    await offerChat(ctx, run, lang, root, t("ui.waiting.chat"), t("ui.waiting.say", { what: truncate(x.what, 80) }));
+}
+/** One task that waits, named by a link of the Strom app: what it asks, then taken up as in the menu. False: it waits no more. */
+export async function waitingTask(ctx, run, lang, root, id) {
+    const tree = Tree.open(root, ctx.env);
+    const x = tree.get(id);
+    if (!x || x.state !== "waiting")
+        return false;
+    ctx.io.stdout([` ${x.what}`, ...whatToDo(ctx, lang, tree, x), ...(x.awaits ? ["", translator(lang)("ui.wait.how1"), translator(lang)("ui.wait.how2")] : []), ""].join("\n") + "\n");
+    await takeUp(ctx, run, lang, root, x);
+    return true;
+}
+export async function waitingForYou(ctx, run, lang, root) {
+    const t = translator(lang);
     await subMenu(ctx, lang, () => {
         const tree = Tree.open(root, ctx.env);
         const waiting = tree.list("task").filter((x) => x.state === "waiting");
@@ -25,55 +77,17 @@ export async function waitingForYou(ctx, run, lang, root) {
         const shown = waiting.slice(0, SHOWN);
         const text = [t("ui.waiting.title", { n: waiting.length })];
         for (const [k, x] of shown.entries()) {
-            text.push("", ` ${k + 1}. ${x.what}`);
-            if (x.awaits) {
-                const b = tree.get(x.awaits.recordset);
-                text.push(`    ${t("ui.waiting.images", { images: x.awaits.images, book: b?.title ?? x.awaits.recordset })}${b?.url ? ` · ${b.url}` : ""}`);
-                text.push(`    ${t("ui.wait.save", { dir: `${ctx.display(inbox(x) ?? `inbox/${x.awaits.folder}`)}${path.sep}` })}`);
-            }
-            else
-                text.push(`    ${t("ui.waiting.do", { what: x.waitingOn || t("ui.waiting.ask") })}`);
+            text.push("", ` ${k + 1}. ${x.what}`, ...whatToDo(ctx, lang, tree, x));
         }
         if (shown.some((x) => x.awaits))
             text.push("", t("ui.wait.how1"), t("ui.wait.how2"));
         if (waiting.length > SHOWN)
             text.push("", t("ui.waiting.more", { n: waiting.length - SHOWN }));
-        const items = shown.map((x, k) => x.awaits
-            ? {
-                key: String(k + 1),
-                label: t("ui.waiting.folder", { k: k + 1 }),
-                act: async () => {
-                    const dir = inbox(x);
-                    if (dir)
-                        openForUser(dir, ctx.env);
-                    out(t("ui.waiting.opened", { dir: dir ? ctx.display(dir) : `inbox/${x.awaits.folder}` }));
-                },
-            }
-            : {
-                key: String(k + 1),
-                label: t("ui.waiting.answer", { k: k + 1, what: truncate(x.what, 60) }),
-                act: async () => {
-                    let answer = "";
-                    for (;;) {
-                        answer = (await ctx.ask(t("ui.waiting.write"))).trim();
-                        if (!answer || answer === "0")
-                            return;
-                        // kept as a note on the task, with what it asked: short — a longer story is for a conversation
-                        if (answer.length <= ANSWER_MAX)
-                            break;
-                        out(t("ui.waiting.long", { n: ANSWER_MAX }));
-                        if (ctx.io.answers !== undefined && ctx.io.answers.length === 0)
-                            return;
-                    }
-                    // meanwhile taken up by an agent (done, dropped, back in the queue): said, nothing written
-                    if (Tree.open(root, ctx.env).get(x.id)?.state !== "waiting")
-                        return void out(t("ui.waiting.gone"));
-                    if ((await run(["task", "wake", x.id, `--answer=${answer}`], true)) !== 0)
-                        return;
-                    out(t("ui.waiting.back"));
-                    await offerChat(ctx, run, lang, root, t("ui.waiting.chat"), t("ui.waiting.say", { what: truncate(x.what, 80) }));
-                },
-            });
+        const items = shown.map((x, k) => ({
+            key: String(k + 1),
+            label: x.awaits ? t("ui.waiting.folder", { k: k + 1 }) : t("ui.waiting.answer", { k: k + 1, what: truncate(x.what, 60) }),
+            act: () => takeUp(ctx, run, lang, root, x),
+        }));
         return { title: `${text.join("\n")}\n\n${t("ui.waiting.pick")}`, items };
     });
 }

package/dist/cli/menu.js

@@ -219,7 +219,8 @@ export async function runMenu(ctx, run) {
                 },
             }, {
                 key: "4",
-                label: t("ui.menu.more"),
+                // the Strom app named only for someone who has not said no to it
+                label: t(stromAppState(ctx.settings) === "no" ? "ui.menu.more" : "ui.menu.more.app"),
                 act: async () => addToResearch(ctx, run, lang, root),
             }, {
                 key: "4",
@@ -283,7 +284,7 @@ export async function runMenu(ctx, run) {
         if (i === undefined)
             return;
         const quit = await guarded(ctx, lang, items[i].act);
-        if (quit === true) {
+        if (quit === true || quit === "quit") {
             out(t("ui.menu.bye"));
             return;
         }

package/dist/cli/ui.js

@@ -7,6 +7,7 @@ export const UI = {
     "ui.yes": "y",
     "ui.no": "n",
     "ui.enter": "Press Enter to go back to the menu.",
+    "ui.enter.close": "Press Enter to close this window.",
     "ui.choose": "Choose",
     "ui.bad.choice": "Please type one of the numbers.",
     "ui.dialog.title": "Strom research",
@@ -88,6 +89,8 @@ export const UI = {
     "ui.setup.level.sure": "Really allow everything?",
     "ui.setup.shortcut": "Put a \"Strom research\" shortcut on the desktop?",
     "ui.setup.shortcut.done": "✓ Shortcut: {file}",
+    "ui.setup.links": "Let the Strom app start the research on this computer? (One click sends your edits back, opens an excerpt in full quality, the agent or a person's review — each asked here first.)",
+    "ui.setup.links.done": "✓ Links from the Strom app lead to the research here.",
     "ui.setup.skill": "✓ {agent} now knows strom in any folder.",
     "ui.setup.app": "✓ The Strom app is on this computer — the menu opens the research in it, and while the agent works the app follows it live.",
     "ui.setup.done": "All set.",
@@ -177,6 +180,10 @@ export const UI = {
     "ui.doc.level": "the agent may",
     "ui.doc.model": "model",
     "ui.doc.shortcut": "desktop shortcut",
+    "ui.doc.links": "links from the Strom app",
+    "ui.doc.links.ours": "yes",
+    "ui.doc.links.other": "lead to another program (or where strom was before)",
+    "ui.doc.links.none": "none",
     "ui.doc.app": "Strom app",
     "ui.doc.tree": "this family tree",
     "ui.doc.innode": "strom {version} in Node {node}",
@@ -241,6 +248,18 @@ export const UI = {
     "ui.review.pick": "Which one?",
     "ui.review.family": "With their spouse and children?",
     "ui.review.run": "Let the agent work on it now, on its own? ({n} tasks)",
+    "ui.menu.unproven": "People without a record of their own ({n})",
+    "ui.unproven.title": "No record of their own proves these people yet:",
+    "ui.unproven.named": "named in a record",
+    "ui.unproven.leads": "only leads",
+    "ui.unproven.none": "no record",
+    "ui.unproven.tasks": "work on them is under way",
+    "ui.unproven.living": "Most likely living (born less than {years} years ago) — the family's to tell, no tasks: {names}",
+    "ui.unproven.how": "What should the agent do?",
+    "ui.unproven.all": "All of them, step by step ({n} at a time)",
+    "ui.unproven.pick": "Only the ones I pick",
+    "ui.unproven.numbers": "Their numbers from the list (e.g. 1 3 5-7, or their IDs; Enter or 0 goes back)",
+    "ui.unproven.bad": "Not in the list: {x}",
     "ui.o.reread": "second reading",
     "ui.o.reread.offer": "{n} facts rest only on readings by another model ({models}); the user reads with {model} now — offer it once, in a sentence: strom review <whom> --reread (a task per person; the user decides)",
     "ui.o.stories": "stories",
@@ -254,6 +273,7 @@ export const UI = {
     "ui.setup.stories.no": "No — just the family tree and its sources",
     "ui.uninstall.agent": "what {agent} knows of strom",
     "ui.uninstall.shortcut": "the shortcut",
+    "ui.uninstall.links": "the links from the Strom app",
     "ui.uninstall.git": "strom's own git",
     "ui.uninstall.path": "the installer's PATH entry",
     "ui.uninstall.program": "the program",
@@ -278,6 +298,7 @@ export const UI = {
     "ui.update.downloading": "Downloading strom {version}…",
     "ui.update.failed": "The update did not work: {detail}. strom stays as it was.",
     "ui.update.done": "✓ strom is updated: {previous} → {version}.",
+    "ui.update.restart": "strom is updated — this menu still runs the old version. Start strom again (or the shortcut \"{shortcut}\"), and the new version is at work.",
     "ui.o.update": "update",
     "ui.o.update.new": "{version} is out (this is {current}) — tell the user; strom update installs it with their yes",
     "ui.app.where.installed": "the installed app",
@@ -380,6 +401,61 @@ export const UI = {
     "ui.browse.plan": "What the agent will do next",
     "ui.review.new": "{name} — {n} new task(s):",
     "ui.review.nothing": "{name} — nothing new to review",
+    "ui.sync.title": "{file}: {n} change(s) against the research",
+    "ui.sync.base": "Compared with what the research gave the Strom app ({head}): only what was changed since counts as your edit.",
+    "ui.sync.nobase": "The file does not say which state of the research it came from: additions are taken, differences only shown (pick them with --only).",
+    "ui.sync.headmissing": "The research's history does not have the state {head} the file names: additions are taken, differences only shown (pick them with --only).",
+    "ui.sync.partial": "The file has far fewer people than it was given: nothing is taken as removed.",
+    "ui.sync.strangers": "These IDs are not the research's people of that name — taken as new people: {ids}",
+    "ui.sync.nothing": "{file}: nothing new — the research has everything in it.",
+    "ui.sync.person.new": "{n}. new person: {name}",
+    "ui.sync.fact.new": "{n}. {who}: new — {fact}",
+    "ui.sync.fact.changed": "{n}. {who}: {kind} changed — {was} → {now}",
+    "ui.sync.fact.differs": "{n}. {who}: {kind} differs — the research {was}, the file {now}",
+    "ui.sync.fact.gone": "{n}. {who}: no longer in it — {fact}",
+    "ui.sync.name.new": "{n}. {who}: another name — {text}",
+    "ui.sync.sex.changed": "{n}. {who}: sex {text}",
+    "ui.sync.note.new": "{n}. {who}: a note — “{text}”",
+    "ui.sync.family.new": "{n}. a new family: {who}{kids}",
+    "ui.sync.child.new": "{n}. {who}: a child — {child}",
+    "ui.sync.child.gone": "{n}. {who}: no longer their child — {child}",
+    "ui.sync.person.gone": "{n}. no longer in it: {name}",
+    "ui.sync.do.add": "added as a lead",
+    "ui.sync.do.correct": "corrects the research's lead",
+    "ui.sync.do.conflict": "a conflict for you to decide (the research has it from a record)",
+    "ui.sync.do.user": "your edit wins (the record's fact withdrawn with the reason)",
+    "ui.sync.do.pick": "only when you pick it (--only)",
+    "ui.sync.do.report": "nothing changes — tell the agent what you meant",
+    "ui.sync.edits": "Your edits to facts a record proves: {mode} (strom config set sync.edits conflict|user)",
+    "ui.sync.mode.conflict": "a conflict for you to decide",
+    "ui.sync.mode.user": "your edit wins",
+    "ui.sync.next": "To write it: strom sync {file} --apply · only some: --apply --only 1,3",
+    "ui.sync.done": "{n} change(s) from {file} written ({input}) — to take them back: strom sync undo {input}",
+    "ui.sync.undone": "Sync {input} taken back: {n} step(s).",
+    "ui.sync.wasundone": "Sync {input} was taken back already.",
+    "ui.sync.bridge.large": "the tree is too large to send — export it as GEDCOM and load it in the research (strom sync <file>)",
+    "ui.sync.bridge.other": "this tree is of another research",
+    "ui.sync.bridge.foreign": "this does not look like the research's family tree — export it and load it in the research as another family tree",
+    "ui.sync.bridge.empty": "the tree came empty or unreadable",
+    "ui.sync.wait": "The Strom app opens with this research — choose which tree to send, and confirm there. Waiting for it (at most {min} min; Ctrl+C stops) …",
+    "ui.sync.wait.open": "Nothing shows in the app (it was open already)? Open this address in its window's browser: {url}",
+    "ui.sync.waited": "The Strom app did not send the tree within {min} min — try again: strom sync --app, or export it as GEDCOM: strom sync <file>",
+    "ui.sync.got": "The Strom app sent the tree.",
+    "ui.sync.nothing.unchanged": "The Strom app sends nothing: the tree has not changed since it was last loaded from the research.",
+    "ui.sync.nothing.cancelled": "Nothing was sent from the Strom app (cancelled there).",
+    "ui.sync.nothing.no-tree": "The Strom app has no tree of this research — open it there first (the Strom app item of the menu), or export the tree and load the file.",
+    "ui.sync.nosend": "This copy of the Strom app cannot send the tree yet (it comes with a newer version) — export it in the app as GEDCOM and load it: strom sync <file>",
+    "ui.sync.from": "From where?",
+    "ui.sync.from.app": "Straight from the Strom app (it sends the tree itself)",
+    "ui.sync.from.file": "From a file (.ged, .json)",
+    "ui.sync.again": "The research took this file in already ({input}) — once more: --again",
+    "ui.sync.source.app": "Edits in the Strom app ({file}, {day})",
+    "ui.sync.source.file": "Family tree {file} ({day})",
+    "ui.review.living": "{who}: most likely alive (born less than {years} years ago, no death recorded). The family knows more than the registers, and those of recent years are mostly closed. Review all the same?",
+    "ui.review.living.no": "Nothing added.",
+    "ui.review.unproven.none": "Everyone in the tree rests on a record of their own — or strom has nothing more to propose for those who do not (strom person list --unproven).",
+    "ui.review.unproven.left": "{n} more without a record of their own: strom review --unproven again takes the next ones once these are done",
+    "ui.review.unproven.left.human": "{n} more people wait without a record of their own — the next ones come when these are done.",
     "ui.review.would": "  would add: {level} · {what}",
     "ui.review.dry": "(dry run — nothing written)",
     "ui.review.covered": "  {name}: already covered by {task} ({state}) — {what}",
@@ -439,10 +515,92 @@ export const UI = {
     "ui.consent.remote": "Start the Claude Code sessions strom opens with Remote Control, so that you can follow and steer them from claude.ai or the Claude app on your phone?",
     "ui.consent.hook.on": "Let the hook “{name}” be told of everything saved into your researches? It is a program on this computer and does with it what it was written to do.",
     "ui.consent.hook.off": "Stop telling the hook “{name}” what is saved?",
-    "ui.menu.more": "Add to the research: material, a new direction, one person reviewed",
+    "ui.menu.more": "Add to the research: material, a new direction, one person reviewed, another family tree",
+    "ui.menu.more.app": "Add to the research: material, a new direction, one person reviewed, edits from the Strom app",
     "ui.more.title": "Add to the research",
     "ui.more.intake": "Material from the family: documents, photos, a family tree from another program, what you know",
     "ui.more.research": "A new direction: the ancestors or descendants of someone else, or one question",
+    "ui.more.sync": "Take in edits from the Strom app or another family tree (.ged, .json)",
+    "ui.link.ok": "OK",
+    "ui.link.bad": "This link from the Strom app could not be used ({why}). Nothing was done.",
+    "ui.link.notree": "The research this link is for is not on this computer (or strom does not know its folder). Nothing was done.",
+    "ui.link.which": "This research is here more than once. Which one should take the edits?",
+    "ui.link.noclip": "This excerpt of {source} is no longer in the research (it was made again or taken away). Open the Strom app from the research again to get the current ones.",
+    "ui.link.noscan": "The scan of this excerpt of {source} is not on this computer, and the research knows no page of it online.",
+    "ui.link.noterminal": "strom could not open a terminal window. Start strom and choose: {item} — Straight from the Strom app.",
+    "ui.link.on.done": "✓ Links from the Strom app lead to the research here.",
+    "ui.link.on.failed": "The links from the Strom app could not be set up on this computer.",
+    "ui.link.off.done": "Links from the Strom app no longer lead to the research here.",
+    "ui.link.off.failed": "The links from the Strom app could not be taken off this computer.",
+    "ui.link.which.one": "This research is here more than once. Which one?",
+    "ui.link.noterminal.any": "strom could not open a terminal window. Start strom (the research {name}) and go on from its menu.",
+    "ui.link.noterminal.new": "strom could not open a terminal window. Start strom, then try again from the Strom app.",
+    "ui.link.asks": "The Strom app asks for: {what}\nResearch: {name}",
+    "ui.link.go": "Go on?",
+    "ui.link.cost": "The agent works on your subscription or AI credit.",
+    "ui.link.tasks": "The research writes tasks for the agent — nothing is searched and nothing is paid now.",
+    "ui.link.what.chat": "a conversation with the agent ({agent}) about the research.",
+    "ui.link.what.chat.person": "a conversation with the agent ({agent}) about {person}.",
+    "ui.link.chat.say": "Let us look at {person}: tell me briefly what the research knows of this person, and ask me what I want to find out.",
+    "ui.link.what.review.person": "look at {person} again.",
+    "ui.link.what.review.family": "look at {person} again, with the partners and children.",
+    "ui.link.what.review.line": "look at {person} again, with the ancestors.",
+    "ui.link.what.research.ancestors": "search for the ancestors of {person} (a new direction of the research).",
+    "ui.link.what.research.descendants": "search for the descendants of {person} (a new direction of the research).",
+    "ui.link.noperson": "{person} is not in this research (or was taken out of it). Nothing was done.",
+    "ui.link.notask": "This task no longer waits for you (it was answered, or an agent took it up). Nothing was done.",
+    "ui.link.task.none": "Task {task} is not in this research. Nothing was done.",
+    "ui.link.task.cannot": "This task cannot be changed that way now (it changed meanwhile). Nothing was done.",
+    "ui.link.what.task.park": "put the task aside: {what}",
+    "ui.link.what.task.drop": "give up the task: {what}",
+    "ui.link.what.task.wake": "bring the task back into the queue: {what}",
+    "ui.link.task.why": "Why? (a few words, kept on the task)",
+    "ui.link.task.park.default": "Put aside in the Strom app.",
+    "ui.link.task.drop.default": "Given up in the Strom app.",
+    "ui.link.task.park.done": "✓ The task is put aside.",
+    "ui.link.task.drop.done": "✓ The task is given up (kept, with the reason).",
+    "ui.link.task.wake.done": "✓ The task is back in the agent's queue.",
+    "ui.link.sessions.title": "The agent's sessions — {name}",
+    "ui.link.sessions.none": "The agent has not worked on this research yet.",
+    "ui.link.sessions.month": "This month: {n} sessions, {cost}",
+    "ui.link.sessions.more": "… and {n} earlier",
+    "ui.link.conflict.none": "Conflict {id} is not in this research. Nothing was done.",
+    "ui.link.conflict.decided": "This conflict is decided already: {resolution}",
+    "ui.link.what.conflict.decide": "decide the conflict: {title}",
+    "ui.link.what.conflict.agent": "leave the conflict to the agent ({agent}): {title}",
+    "ui.link.conflict.pick": "Which is right?",
+    "ui.link.conflict.other": "Something else (I write it)",
+    "ui.link.conflict.own": "What is right?",
+    "ui.link.conflict.why": "Why? (what decides it)",
+    "ui.link.conflict.by": "{why} (the user's decision)",
+    "ui.link.conflict.done": "✓ The conflict is decided.",
+    "ui.link.conflict.say": "Look at the conflict {id} ({title}): weigh the records, decide it with strom conflict resolve, then tell me what you concluded and why.",
+    "ui.link.story.none": "{person} has no story yet. Nothing was done.",
+    "ui.link.story.final": "The story of {person} is approved already.",
+    "ui.link.what.story": "approve the story of {person} as it is (it will no longer be a draft).",
+    "ui.link.story.done": "✓ The story is approved. Open the research in the Strom app again and it is there without the draft label.",
+    "ui.link.sync.none": "{input} is not a sending from the Strom app in this research. Nothing was done.",
+    "ui.link.sync.was": "This sending was taken back already.",
+    "ui.link.what.sync": "take back what the research took from the Strom app on {day} ({n} changes).",
+    "ui.link.new.title": "The Strom app asks to start a research with one of its family trees.",
+    "ui.link.new.name": "Name of the research (the family, e.g. Novák)",
+    "ui.link.new.exists": "A research named “{name}” is here already, with people in it. Choose another name.",
+    "ui.link.new.wait": "Waiting for the Strom app to hand the tree over — confirm it there (at most {min} min; Ctrl+C stops).",
+    "ui.link.new.none": "The Strom app handed no tree over. The research “{name}” is here, still empty: start again from the app, or add to it from strom's menu.",
+    "ui.link.new.waited": "No tree came from the Strom app within {min} min. The research “{name}” is here, still empty.",
+    "ui.link.new.empty": "The tree the Strom app sent has no people, so there is nothing to research. The research “{name}” is here, still empty.",
+    "ui.link.new.failed": "The Strom app could not hand the tree over. The research “{name}” is here, still empty: try again from the app.",
+    "ui.link.new.taken": "✓ The family tree is in the research “{name}”: {persons} people, {families} families — as leads; what records prove, the agent finds.",
+    "ui.link.new.back": "The Strom app shows the tree now as the tree of the research.",
+    "ui.link.new.chat": "Start the conversation with the agent now?",
+    "ui.link.new.say": "I handed our family tree over from the Strom app — look at what is in it and suggest where to begin.",
+    "ui.more.sync.noapp": "Take in another family tree's changes (.ged, .json)",
+    "ui.sync.path.noapp": "Drag the family tree file (.ged or .json) here, or type its path (Enter or 0 goes back)",
+    "ui.sync.path": "Drag the file exported from the Strom app (.ged or .json) here, or type its path (Enter or 0 goes back)",
+    "ui.sync.how": "Write it into the research?",
+    "ui.sync.all": "Yes, everything as shown",
+    "ui.sync.some": "Only the ones I pick",
+    "ui.sync.app": "Open the research in the Strom app again (the Strom app item of the menu): it asks whether to update the tree — then it has your edits as the research took them.",
     "ui.intake.what": "What do you bring?",
     "ui.intake.files": "Files or a folder from this computer",
     "ui.intake.text": "What you know — names, dates, places, family memories",

package/dist/cli/wizard.js

@@ -13,9 +13,10 @@ import { agentsHere, DESKTOP_APPS } from "../core/apps.js";
 import { PROFILES } from "../agents/profiles.js";
 import { writeStored, PERMISSION_LEVELS } from "../core/config.js";
 import { globalTargets, installGlobal } from "../agents/global.js";
-import { noticeStromApp, researchUrl, stromAppState, stromAppUrl } from "../core/stromapp.js";
+import { appOpensLinks, noticeStromApp, researchUrl, stromAppState, stromAppUrl } from "../core/stromapp.js";
 import { openForUser } from "../core/open.js";
 import { createShortcut } from "../core/shortcut.js";
+import { linkFiles, linkHandlerState, registerLinks } from "../core/links.js";
 import { desktopDir } from "../core/paths.js";
 import { ensureShared } from "../commands/setup.js";
 import { moveHome, planMove, repointSettings, sameFolder } from "../core/relocate.js";
@@ -152,10 +153,42 @@ export async function setupWizard(ctx) {
         out(ui(lang, "ui.setup.app"));
     else
         await askStromApp(ctx, lang, first ? undefined : ui(lang, "ui.keep"));
+    // 9. The Strom app may start the research here (strom-research:// links): asked while it is wanted; refreshed quietly after.
+    if (stromAppState(s) !== "no" && appOpensLinks(s))
+        await offerLinks(ctx, lang);
     out();
     out(`${ui(lang, "ui.setup.done")}  (${langName(lang, lang)} · ${ctx.display(home)})`);
     return { home, lang, ...(agent ? { agent } : {}), permissions: level };
 }
+/**
+ * strom-research:// links: set up on the person's yes, the answer kept (a no is not asked again unasked:
+ * `ask` — the wizard, doctor --fix — asks all the same, suggesting what they said). Set up before by strom: set up
+ * again quietly.
+ */
+export async function offerLinks(ctx, lang, opts = { ask: true }) {
+    if (linkHandlerState(ctx.env) === "ours")
+        return;
+    const said = ctx.settings.config.links;
+    const made = linkFiles(ctx.env).length > 0;
+    if (!made) {
+        if (said === "no" && !opts.ask)
+            return;
+        const yes = await ctx.confirm(ui(lang, "ui.setup.links"), said !== "no");
+        ctx.settings.reload();
+        ctx.settings.config.links = yes ? "yes" : "no";
+        ctx.settings.save();
+        if (!yes)
+            return;
+    }
+    let done = false;
+    try {
+        done = registerLinks(ctx.env);
+    }
+    catch {
+        done = false;
+    }
+    ctx.io.stdout(ui(lang, done ? "ui.setup.links.done" : "ui.link.on.failed") + "\n");
+}
 /**
  * Does the person want the Strom app (not found on this computer)? Yes and
  * install it now: it opens in the browser and strom says where to click; yes

package/dist/commands/analysis.js

@@ -261,9 +261,10 @@ register({
     options: [
         { name: "about", type: "string", multiple: true, value: "<who>", description: "person/record concerned (repeatable)" },
         { name: "claim", type: "string", multiple: true, value: "<S…: value>", description: 'a claim, e.g. "S0027: aged 27 at marriage 1839" (repeat for each)' },
+        { name: "fact", type: "string", value: "<TAG>", description: "the fact it is about, by its GEDCOM tag: BIRT, DEAT, BAPM, BURI, MARR, NAME, SEX… (the Strom app shows it there)" },
         { name: "note", type: "string", value: "<text>", description: "short note" },
     ],
-    examples: ['strom conflict add "Rok narození Josefa" --about P0002 --claim "S0001: 27 let při sňatku 1839" --claim "S0002: 70 let při úmrtí 1883"'],
+    examples: ['strom conflict add "Rok narození Josefa" --about P0002 --fact BIRT --claim "S0001: 27 let při sňatku 1839" --claim "S0002: 70 let při úmrtí 1883"'],
     run(ctx, { args, opts }) {
         const tree = ctx.tree();
         const claims = listOpt(opts.claim).map((c) => {
@@ -277,7 +278,10 @@ register({
         const subject = anyRefs(tree, listOpt(opts.about));
         if (!subject.length)
             throw new UsageError("--about is required");
-        const x = create(tree, "conflict", { title: args[0].trim(), subject, claims, state: "open", note: opts.note }, (id) => `+${id} conflict "${truncate(args[0], 60)}"`, subject);
+        const fact = typeof opts.fact === "string" ? opts.fact.trim().toUpperCase() : undefined;
+        if (fact !== undefined && !/^(?:[A-Z]{3,4}|_[A-Z]{2,6})$/.test(fact))
+            throw new UsageError(`--fact is a GEDCOM tag (BIRT, DEAT, NAME, SEX…), not "${opts.fact}"`);
+        const x = create(tree, "conflict", { title: args[0].trim(), ...(fact ? { fact } : {}), subject, claims, state: "open", note: opts.note }, (id) => `+${id} conflict "${truncate(args[0], 60)}"`, subject);
         return { text: written(tree), data: { conflict: x } };
     },
 }, {

package/dist/commands/browse.js

@@ -10,12 +10,15 @@ import { mainPerson } from "../core/kin.js";
 import { resolvePerson } from "../core/people.js";
 import { knownGenerations, ownerName, pedigree, personCard, recent, treeStats } from "../core/overview.js";
 import { displayName } from "../core/people.js";
+import { humanTask } from "../cli/human.js";
+export { humanTask };
 import { lacksImages } from "../core/queue.js";
 import { rankedQueue, waitingForUser } from "./tasks.js";
 /** Most rows a section of `recent` lists; the rest is counted. */
 const RECENT_ROWS = 15;
+/** A person as the user reads them, with the ID to name them by later ("strom review P0012", the agent). */
 function whoText(w) {
-    return w.years ? `${w.name} (${w.years})` : w.name;
+    return `${w.years ? `${w.name} (${w.years})` : w.name} [${w.id}]`;
 }
 /** The person asked for, else the main person of the tree. */
 function personOrMain(tree, ref) {
@@ -63,23 +66,6 @@ function drawPedigree(root, lang) {
     walk(root, "");
     return out;
 }
-/** What the agent wrote into a task, for the user: the records it names by ID by their names ("S0001" → its title). */
-export function humanTask(tree, text, lang) {
-    const name = (id) => {
-        const r = tree.get(id);
-        if (!r)
-            return id;
-        if (r.type === "session")
-            return ui(lang, "ui.plan.session", { day: humanDay(r.started, lang) });
-        if (r.type === "person")
-            return displayName(r);
-        if (r.type === "family")
-            return r.partners.map((x) => tree.get(x)).filter((x) => !!x).map(displayName).join(" & ") || id;
-        return r.title;
-    };
-    // A list of IDs as a list of names, each once (two sessions of one day read as one).
-    return text.replace(/\b[PFSBN]\d{4,}\b(?:, [PFSBN]\d{4,}\b)*/g, (ids) => [...new Set(ids.split(", ").map(name))].join(", "));
-}
 function more(n, lang) {
     return n > 0 ? `  ${ui(lang, "ui.recent.more", { n })}` : undefined;
 }
@@ -192,7 +178,7 @@ register({
             `  ${t.state === "doing" ? ui(lang, "ui.plan.now") : `${++n}.`}`,
             `${truncate(humanTask(tree, t.what, lang), 110)}${lacksImages(tree, t) ? ui(lang, "ui.plan.images") : ""}`,
         ]);
-        const storyNames = [...new Set(stories.map((t) => tree.get(t.subject[0] ?? "")).filter((p) => !!p).map(displayName))];
+        const storyNames = [...new Set(stories.map((t) => tree.get(t.subject[0] ?? "")).filter((p) => !!p).map((p) => `${displayName(p)} [${p.id}]`))];
         const out = [ui(lang, "ui.plan.title", { name: tree.config.name })];
         if (!queue.length)
             out.push(`  ${ui(lang, "ui.plan.none")}`);

package/dist/commands/checks.js

@@ -5,6 +5,7 @@ import { register } from "../cli/registry.js";
 import { lines, table } from "../cli/format.js";
 import { check } from "../core/check.js";
 import { guard } from "../core/guard.js";
+import { unprovenPeople } from "../core/review.js";
 import { verifyFast, verifyFull } from "../core/integrity.js";
 import { createKey, verifyCommitSeal } from "../core/seal.js";
 import { NeedsConsentError, StromError } from "../core/errors.js";
@@ -23,7 +24,12 @@ register({
     tree: true,
     run(ctx) {
         const tree = ctx.tree();
-        return report([...verifyFull(tree).findings, ...check(tree), ...guard(tree)], "ok — data consistent, sealed, nothing lost");
+        const out = report([...verifyFull(tree).findings, ...check(tree), ...guard(tree)], "ok — data consistent, sealed, nothing lost");
+        // not an error — research to do: who rests on no record of their own
+        const unproven = unprovenPeople(tree).filter((u) => !u.living).length;
+        if (!unproven)
+            return out;
+        return { ...out, text: lines(out.text, `note: ${unproven} people rest on no record of their own → strom person list --unproven`), data: { ...out.data, unproven } };
     },
 }, {
     path: ["verify"],

package/dist/commands/guide.js

@@ -136,13 +136,27 @@ ONE PERSON, LOOKED AT AGAIN (the user asks you to check or complete someone; a n
   diary say of them outside their data, entries whose images are here but were not read whole, facts
   resting on one reading, conflicts left open (--reread: a second reading with the model the user reads
   with now). Each task's brief lists its items. Tell the user how many and what they cost; they decide.
+  Several at once: strom review P… P… (one review). The people no record of their own proves (strom check
+  counts them): strom person list --unproven (how each stands; the living apart — no tasks for them);
+  strom review --unproven proposes their work a batch at a time — again for the next batch, nothing twice.
+THE STROM APP'S EDITS, ANOTHER FAMILY TREE (the user changed the tree in the Strom app, or brings a .ged/.json)
+  strom sync <file> shows what it would take: what the file adds, what the user changed since the research
+  gave it (_STROM_HEAD), what is no longer in it. Show the user the list; write it on their yes (--apply, some:
+  --only 1,3). Additions become leads; a change to a fact a record proves becomes a conflict (sync.edits: the
+  user's choice). A file of another research, or of few of our people, is refused; strom sync undo I… takes a
+  sync back. After it: the user opens the research in the Strom app again to have the tree updated.
+  Straight from the app: strom sync --app (the user presses Send in the app). With strom-research:// links set
+  up on this computer (the user's yes: strom link on, the setup wizard; strom link status says) the app starts it
+  itself with one click, and opens an excerpt of an entry in full quality; its menus also open the research, a
+  conversation with you (of one person), a task that waits for the user, a person's review, a new direction — each
+  said and asked in a terminal first. Tell the user once when they use the app.
 STORIES OF THE ANCESTORS (the setting stories — on by default; strom shows it)
   Once records tell a person's life (a baptism and more facts from records), strom proposes a narrate
   task: write the story for the family book — plain words, the research language, every statement on a
   recorded fact (strom story set P… --text @notes/story-P….md --fact E… …). More facts later: it
   proposes adding to it. Stories wait behind all the research; working alone
   (strom run), every few sessions one comes first. In a conversation the user leads: write one when they
-  want it, or offer it when the research has a pause. A story is a draft until the user approves it (--final). When strom says to tell
+  want it, or offer it when the research has a pause. A story is a draft until the user approves it (strom story approve P…; the Strom app asks it too). When strom says to tell
   the user (once, not in every conversation): in a sentence, and that they may say no (strom config set
   stories no).
 

package/dist/commands/index.js

@@ -4,6 +4,7 @@ import "./start.js";
 import "./trees.js";
 import "./research.js";
 import "./intake.js";
+import "./sync.js";
 import "./tasks.js";
 import "./people.js";
 import "./batch.js";
@@ -20,5 +21,6 @@ import "./output.js";
 import "./session.js";
 import "./gates.js";
 import "./hooks.js";
+import "./links.js";
 import "./checks.js";
 import "./setup.js";

package/dist/commands/intake.js

@@ -149,6 +149,9 @@ register({
                         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)