strom-research 1.5.0 → 1.6.1

package/dist/cli/menu-research.js

@@ -158,6 +158,14 @@ async function newResearch(ctx, run, lang, root) {
             return;
         who = [`--new-person=${name}`, "--sex", ["M", "F", "U"][sex]];
     }
+    await startDirection(ctx, run, lang, root, direction, who, name, question);
+}
+/**
+ * A new direction for someone chosen (the menu, a link of the Strom app): its title and what the person knows of
+ * it asked, the research made; the same research still going is only named.
+ */
+export async function startDirection(ctx, run, lang, root, direction, who, name, question) {
+    const t = translator(lang);
     // The same research again (this person, this direction, still going): said which one it is, nothing made.
     const focus = who[0] === "--person" ? who[1] : undefined;
     const same = focus && direction !== "question"
@@ -198,15 +206,8 @@ async function syncTree(ctx, run, lang, root) {
         const from = await ctx.choose(t("ui.sync.from"), [{ label: t("ui.sync.from.app") }, { label: t("ui.sync.from.file") }], 0, { back: t("ui.browse.back") });
         if (from === undefined)
             return;
-        if (from === 0) {
-            const since = Date.now();
-            if ((await run(["sync", "--app"])) !== 0)
-                return pause(ctx, lang);
-            file = receivedSince(root, since);
-            if (!file)
-                return pause(ctx, lang);
-            return confirmSync(ctx, run, lang, root, file);
-        }
+        if (from === 0)
+            return syncFromApp(ctx, run, lang, root);
     }
     for (;;) {
         if (outOfAnswers(ctx))
@@ -234,8 +235,21 @@ async function syncTree(ctx, run, lang, root) {
         return pause(ctx, lang);
     return confirmSync(ctx, run, lang, root, file, count);
 }
+/** The tree straight from the Strom app (the menu, or a strom-research://send link): shown, then written on the person's word. */
+export async function syncFromApp(ctx, run, lang, root, enter = "ui.enter", back) {
+    const since = Date.now();
+    const code = await run(["sync", "--app"]);
+    // the person is in the app: what came of it is here (a terminal opened for a link brings itself forward)
+    back?.();
+    if (code !== 0)
+        return pause(ctx, lang, enter);
+    const file = receivedSince(root, since);
+    if (!file)
+        return pause(ctx, lang, enter);
+    return confirmSync(ctx, run, lang, root, file, undefined, enter);
+}
 /** What the tree brings is shown: written on the person's word — all, or the ones they pick. */
-async function confirmSync(ctx, run, lang, root, file, known) {
+async function confirmSync(ctx, run, lang, root, file, known, enter = "ui.enter") {
     const t = translator(lang);
     let count = known ?? 0;
     if (known === undefined)
@@ -247,7 +261,7 @@ async function confirmSync(ctx, run, lang, root, file, known) {
             count = 0;
         }
     if (!count)
-        return pause(ctx, lang);
+        return pause(ctx, lang, enter);
     const how = await ctx.choose(t("ui.sync.how"), [{ label: t("ui.sync.all") }, { label: t("ui.sync.some") }], 0, { back: t("ui.browse.back") });
     if (how === undefined)
         return;
@@ -260,7 +274,7 @@ async function confirmSync(ctx, run, lang, root, file, known) {
     }
     if ((await run(["sync", file, "--apply", ...only])) === 0 && !noApp(ctx))
         ctx.io.stdout(t("ui.sync.app") + "\n");
-    await pause(ctx, lang);
+    await pause(ctx, lang, enter);
 }
 /** The people no record of their own proves: listed, then all of them a batch at a time, or the ones picked by number. */
 async function reviewUnproven(ctx, run, lang, root) {
@@ -342,12 +356,17 @@ async function reviewPerson(ctx, run, lang, root) {
     if (!person)
         return;
     const family = await ctx.confirm(t("ui.review.family"), false);
-    if ((await run(["review", person.id, ...(family ? ["--scope", "family"] : [])])) !== 0)
-        return pause(ctx, lang);
+    await reviewOne(ctx, run, lang, root, person.id, family ? "family" : "person");
+    await pause(ctx, lang);
+}
+/** One person's review (the menu, a link of the Strom app), then the agent offered for its tasks — the person's choice, no suggested. */
+export async function reviewOne(ctx, run, lang, root, person, scope) {
+    const t = translator(lang);
+    if ((await run(["review", person, ...(scope !== "person" ? ["--scope", scope] : [])])) !== 0)
+        return;
     const tree = Tree.open(root, ctx.env);
-    const research = tree.list("research").find((r) => r.direction === "person" && r.focus === person.id && r.review && !r.review.people);
+    const research = tree.list("research").find((r) => r.direction === "person" && r.focus === person && r.review && !r.review.people);
     const open = research ? tree.list("task").filter((x) => x.research === research.id && x.state === "open").length : 0;
     if (research && open && (await ctx.confirm(t("ui.review.run", { n: open }), false)))
         await run(["run", "--research", research.id, "--max", String(open)]);
-    await pause(ctx, lang);
 }

package/dist/cli/menu-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/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}",
@@ -266,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",
@@ -412,10 +420,13 @@ export const UI = {
     "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.place.coords": "{n}. {place}: on the map {from} → {at}",
+    "ui.sync.place.located": "{n}. {place}: on the map at {at}",
     "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.set": "the research takes your position (no record proves one)",
     "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)",
@@ -430,6 +441,7 @@ export const UI = {
     "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.",
@@ -512,6 +524,79 @@ export const UI = {
     "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)",

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,6 +10,8 @@ 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. */
@@ -64,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)} [${r.id}]`;
-        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;
 }

package/dist/commands/guide.js

@@ -145,13 +145,18 @@ THE STROM APP'S EDITS, ANOTHER FAMILY TREE (the user changed the tree in the Str
   --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

@@ -21,5 +21,6 @@ import "./output.js";
 import "./session.js";
 import "./gates.js";
 import "./hooks.js";
+import "./links.js";
 import "./checks.js";
 import "./setup.js";