strom-research 1.8.0 → 1.10.0

package/assets/lang/cs.json

@@ -164,6 +164,7 @@
   "ui.why.session": "ve frontě je úkolů: {n}",
   "ui.why.frontier": "žádné otevřené úkoly – podívej se, co výzkumu ještě chybí",
   "ui.wait.title": "čeká na vás ({n})",
+  "ui.wait.stories": "nové verze vyprávění, která jste schválili – přečíst a rozhodnout: {ids} (menu: Co čeká na vás · strom story show <ID>)",
   "ui.wait.images": "snímky {images} z {book}",
   "ui.wait.save": "uložte je do {dir}",
   "ui.wait.how1": "snímky patří do schránky (inbox), pro každou knihu vlastní složka, každý pojmenovaný číslem snímku, jak ho počítá prohlížeč",
@@ -266,6 +267,10 @@
   "story.where": "zapsané údaje (strom person show {id})",
   "story.why": "{count} údaje ze zápisů vyprávějí život (generace {generation} výzkumu {research}); rodina si ho přečte v rodinné knize aplikace Strom",
   "story.done": "strom story set {id} se všemi údaji, o které se opírá (--fact) – koncept, dokud ho uživatel neschválí",
+  "story.sources.what": "Mimo matriky, pro vyprávění: {name} – noviny, adresáře, vojenské, pozemkové a soudní záznamy, hroby, dějiny místa",
+  "story.sources.where": "digitalizované noviny, knihy a archivy země a doby; web (rejstříky a rodokmeny jsou jen vodítko)",
+  "story.sources.why": "vyprávění má říct víc než matriky – a každé slovo pořád na záznamu; potom strom navrhne vyprávění",
+  "story.sources.done": "každý nález zapsaný jako pramen a údaj s citací (osoba doložená víc než jménem), dějiny místa jako pramen, každé hledání zapsané – i marné",
   "review.research": "Revize: {name}",
   "review.unproven.research": "Osoby bez vlastního záznamu",
   "review.more": " (a po nich dalších {count})",
@@ -483,6 +488,9 @@
   "ui.sync.fact.changed": "{n}. {who}: {kind} změněno — {was} → {now}",
   "ui.sync.fact.differs": "{n}. {who}: {kind} se liší — výzkum {was}, soubor {now}",
   "ui.sync.fact.gone": "{n}. {who}: už v něm není — {fact}",
+  "ui.sync.fact.detail": "{n}. {who}: {kind} {when} — {was} → {now}",
+  "ui.sync.house": "čp. {x}",
+  "ui.sync.cause": "příčina {x}",
   "ui.sync.name.new": "{n}. {who}: další jméno — {text}",
   "ui.sync.sex.changed": "{n}. {who}: pohlaví {text}",
   "ui.sync.note.new": "{n}. {who}: poznámka — „{text}“",
@@ -494,6 +502,7 @@
   "ui.sync.place.located": "{n}. {place}: poloha na mapě {at}",
   "ui.sync.do.add": "přidá se jako vodítko",
   "ui.sync.do.correct": "opraví vodítko výzkumu",
+  "ui.sync.do.detail": "doplní se k údaji s odkazem na váš strom",
   "ui.sync.do.conflict": "rozpor k rozhodnutí (výzkum to má ze záznamu)",
   "ui.sync.do.user": "platí vaše úprava (údaj ze záznamu se stáhne s důvodem)",
   "ui.sync.do.set": "výzkum převezme vaši polohu (žádný zápis ji nedokládá)",
@@ -666,8 +675,8 @@
   "ui.link.conflict.by": "{why} (rozhodnutí uživatele)",
   "ui.link.conflict.done": "✓ Rozpor je rozhodnutý.",
   "ui.link.conflict.say": "Podívej se na rozpor {id} ({title}): zvaž prameny, rozhodni ho přes strom conflict resolve a pak mi řekni, k čemu jsi došel a proč.",
-  "ui.link.story.none": "Osoba {person} zatím nemá vyprávění. Nic se nestalo.",
-  "ui.link.story.final": "Vyprávění osoby {person} už je schválené.",
+  "ui.link.story.none": "Vyprávění o {person} zatím není. Nic se nestalo.",
+  "ui.link.story.final": "Vyprávění o {person} už je schválené.",
   "ui.link.what.story": "schválit vyprávění osoby {person}, jak je (už nebude návrh).",
   "ui.link.story.done": "✓ Vyprávění je schválené. Až výzkum v aplikaci Strom otevřete znovu, bude tam bez štítku Návrh.",
   "ui.link.sync.none": "{input} není v tomto výzkumu poslání z aplikace Strom. Nic se nestalo.",
@@ -820,6 +829,7 @@
   "log.repository.edit": "Upravený archiv: {name}",
   "log.story.set": "Vyprávění: {who}",
   "log.story.approve": "Vyprávění schváleno: {who}",
+  "log.story.discard": "Nová verze vyprávění nechtěná, zůstává schválená: {who}",
   "log.note.add": "Poznámka: {name}",
   "log.input.add": "Materiál od rodiny: {name}",
   "log.input.sync": "Převzatý rodokmen: {name}",
@@ -902,6 +912,17 @@
   "ui.review.next.human": "Agent se do nich pustí v rozhovoru nebo při samostatné práci.",
   "ui.review.wake.human": "    pokud v něm chcete pokračovat, řekněte to agentovi v rozhovoru",
   "ui.waiting.gone": "Tohle už na vás nečeká – agent se toho mezitím ujal.",
+  "ui.link.story.nonew": "Žádná nová verze vyprávění o {person} nečeká. Nic se nestalo.",
+  "ui.link.story.nocouple": "{couple} nejsou ve výzkumu pár. Nic se nestalo.",
+  "ui.story.new.title": "Nová verze vyprávění o {who} ({day}) – schválené zůstává, dokud nerozhodnete:",
+  "ui.story.new.pick": "Které vyprávění má mít rodinná kniha?",
+  "ui.story.new.take": "novou verzi, místo staré",
+  "ui.story.new.keep": "nechat staré (nová verze se zahodí)",
+  "ui.story.new.taken": "✓ Vyprávěním je teď nová verze, schválená. Otevřete výzkum v aplikaci Strom znovu a je tam.",
+  "ui.story.new.kept": "✓ Schválené vyprávění zůstává, nová verze je pryč (historie výzkumu ji drží).",
+  "ui.waiting.story": "Nová verze vyprávění o {who} – schválené zůstává, dokud nerozhodnete",
+  "ui.waiting.story.read": "Přečíst nové vyprávění o {who} a rozhodnout",
+  "ui.waiting.pick.story": "Vyberte číslo:",
   "ui.trees.pack": "zabalit „{name}“ a poslat někomu (soubor ZIP)",
   "ui.trees.unpack": "rodokmen, který vám někdo poslal (soubor ZIP)",
   "ui.pack.which": "Které snímky přibalit?",

package/assets/lang/de.json

@@ -164,6 +164,7 @@
   "ui.why.session": "Aufgaben in der Warteschlange: {n}",
   "ui.why.frontier": "keine offenen Aufgaben – sieh nach, was der Forschung noch fehlt",
   "ui.wait.title": "wartet auf Sie ({n})",
+  "ui.wait.stories": "neue Fassungen von Erzählungen, die Sie freigegeben haben – lesen und entscheiden: {ids} (das Menü: Was auf Sie wartet · strom story show <ID>)",
   "ui.wait.images": "Scans {images} aus {book}",
   "ui.wait.save": "speichern Sie sie in {dir}",
   "ui.wait.how1": "Scans kommen in den Eingang (inbox), ein Ordner pro Buch, jeder benannt nach der Bildnummer, wie der Viewer sie zählt",
@@ -266,6 +267,10 @@
   "story.where": "die erfassten Angaben (strom person show {id})",
   "story.why": "{count} Angaben aus Einträgen erzählen das Leben (Generation {generation} der Forschung {research}); die Familie liest es im Familienbuch der Strom-App",
   "story.done": "strom story set {id} mit jeder Angabe, auf der sie beruht (--fact) – ein Entwurf, bis der Benutzer sie freigibt",
+  "story.sources.what": "Über die Kirchenbücher hinaus, für die Geschichte: {name} – Zeitungen, Adressbücher, Militär-, Grund- und Gerichtsakten, Gräber, die Geschichte des Ortes",
+  "story.sources.where": "die digitalisierten Zeitungen, Bücher und Archive des Landes und der Zeit; das Web (Register und Stammbäume nur als Hinweis)",
+  "story.sources.why": "die Geschichte soll mehr erzählen als die Kirchenbücher – jedes Wort weiterhin auf einer Quelle; danach schlägt strom die Geschichte vor",
+  "story.sources.done": "jeder Fund als Quelle und Angabe mit Beleg erfasst (die Person durch mehr als den Namen belegt), die Geschichte des Ortes als Quelle, jede Suche erfasst – auch vergebliche",
   "review.research": "Durchsicht: {name}",
   "review.unproven.research": "Personen ohne eigenen Eintrag",
   "review.more": " (und danach {count} weitere)",
@@ -483,6 +488,9 @@
   "ui.sync.fact.changed": "{n}. {who}: {kind} geändert — {was} → {now}",
   "ui.sync.fact.differs": "{n}. {who}: {kind} weicht ab — Forschung {was}, Datei {now}",
   "ui.sync.fact.gone": "{n}. {who}: nicht mehr darin — {fact}",
+  "ui.sync.fact.detail": "{n}. {who}: {kind} {when} — {was} → {now}",
+  "ui.sync.house": "Haus Nr. {x}",
+  "ui.sync.cause": "Ursache {x}",
   "ui.sync.name.new": "{n}. {who}: ein weiterer Name — {text}",
   "ui.sync.sex.changed": "{n}. {who}: Geschlecht {text}",
   "ui.sync.note.new": "{n}. {who}: eine Notiz — „{text}“",
@@ -494,6 +502,7 @@
   "ui.sync.place.located": "{n}. {place}: Lage auf der Karte {at}",
   "ui.sync.do.add": "als Hinweis übernommen",
   "ui.sync.do.correct": "berichtigt den Hinweis der Forschung",
+  "ui.sync.do.detail": "wird der Angabe hinzugefügt, mit Verweis auf Ihren Stammbaum",
   "ui.sync.do.conflict": "ein Widerspruch zum Entscheiden (die Forschung hat es aus einem Eintrag)",
   "ui.sync.do.user": "Ihre Änderung gilt (die Angabe aus dem Eintrag wird mit Grund zurückgezogen)",
   "ui.sync.do.set": "die Forschung übernimmt Ihre Lage (kein Eintrag belegt sie)",
@@ -820,6 +829,7 @@
   "log.repository.edit": "Archiv geändert: {name}",
   "log.story.set": "Erzählung: {who}",
   "log.story.approve": "Erzählung freigegeben: {who}",
+  "log.story.discard": "Die neue Fassung der Erzählung nicht gewollt, die freigegebene bleibt: {who}",
   "log.note.add": "Notiz: {name}",
   "log.input.add": "Material der Familie: {name}",
   "log.input.sync": "Stammbaum übernommen: {name}",
@@ -902,6 +912,17 @@
   "ui.review.next.human": "Der Agent nimmt sie im Gespräch oder bei der Arbeit allein auf.",
   "ui.review.wake.human": "    wenn es weitergehen soll, sagen Sie es dem Agenten im Gespräch",
   "ui.waiting.gone": "Das wartet nicht mehr auf Sie – der Agent hat es inzwischen übernommen.",
+  "ui.link.story.nonew": "Keine neue Fassung der Erzählung über {person} wartet. Es wurde nichts getan.",
+  "ui.link.story.nocouple": "{couple} sind in der Forschung kein Paar. Es wurde nichts getan.",
+  "ui.story.new.title": "Die neue Fassung der Erzählung über {who} ({day}) – die freigegebene bleibt, bis Sie entscheiden:",
+  "ui.story.new.pick": "Welche Erzählung soll das Familienbuch haben?",
+  "ui.story.new.take": "die neue Fassung, anstelle der alten",
+  "ui.story.new.keep": "die alte behalten (die neue Fassung entfällt)",
+  "ui.story.new.taken": "✓ Die neue Fassung ist jetzt die Erzählung, freigegeben. Öffnen Sie die Forschung in der Strom-App erneut, dann ist sie da.",
+  "ui.story.new.kept": "✓ Die freigegebene Erzählung bleibt; die neue Fassung ist weg (die Geschichte der Forschung bewahrt sie).",
+  "ui.waiting.story": "Eine neue Fassung der Erzählung über {who} – die freigegebene bleibt, bis Sie entscheiden",
+  "ui.waiting.story.read": "Die neue Erzählung über {who} lesen und entscheiden",
+  "ui.waiting.pick.story": "Wählen Sie die Nummer:",
   "ui.trees.pack": "„{name}“ einpacken und jemandem schicken (eine ZIP-Datei)",
   "ui.trees.unpack": "ein Stammbaum, den Ihnen jemand geschickt hat (eine ZIP-Datei)",
   "ui.pack.which": "Welche Bilder kommen mit?",

package/assets/method/core.md

@@ -37,6 +37,14 @@ conclusion so the next researcher can follow it.
 - **Lessons belong where they apply.** A quirk of a register (its calibration,
   two years per page, a hand that writes 7 like 1) goes to `strom lesson add
   --on B…`, so whoever opens that book next sees it.
+- **The tree first, then above it.** A family found in the records that no
+  family link joins to the tree is not researched further — not its parents,
+  not its children — until the link is proven, or the user asks for it. First
+  the hypothesis that would join it (`strom hypothesis add … --about` a person
+  of the tree), then a task that tests it and names it (`--about H…`). The
+  queue holds back every other task about people off the tree
+  (`strom task list --off-tree`); they come back by themselves once the link
+  is recorded.
 - **Stay within the task.** New questions become new tasks (`strom task add`,
   with where and done-when), not detours. A new task whose images are not here
   gets them now: through the archive's connector (built first when it has

package/assets/method/enrich.md

@@ -9,3 +9,34 @@ the village. Each detail is a fact with a citation.
 - Keep the certainty honest: a house number from a baptism of a sibling is
   evidence about the family at that date, not about the person's whole life.
 - Record what you learn about the place and the books as lessons.
+
+## Beyond the registers
+
+Before a story is written (the task says so), look where the registers do
+not: newspapers (notices, obituaries, court reports, auctions, lists of
+donors, soldiers), directories and address books, school and society reports,
+military, land, court and notarial records, graves and death notices, and the
+history of the place. Which of them exist for that country and time, and
+where they are digitised, you find out first — every search recorded, also in
+vain (`strom search add … --method web|catalog|full-text --result negative`).
+
+What you find must hold as evidence:
+
+- **Read the source itself** — the page of the newspaper, the scan of the
+  book or the record. A search snippet, an OCR line, an index, an online tree
+  or someone's summary is a lead: it says where to look, never a fact.
+- **Your person, not a namesake.** A hit is them only when the name, the place
+  and the time agree and at least one more detail does: the house, the
+  occupation, the spouse, the age, a relative named. Otherwise it is a
+  hypothesis (`strom hypothesis add`) with what would decide it.
+- **Cite it exactly**: the source with its kind (newspaper, book, military,
+  land, court, web), `--url`, `--locator "<page, column>"` and its words in
+  `--transcript`; then the fact with `--cite S… --quote "…"`. A newspaper written at the time is
+  a good witness of what it reports, a later book or website a weaker one:
+  say so in the fact's certainty.
+- **The history of the place is not a fact of the person.** A war, an
+  epidemic, a fire, a change of lords, what the village lived from: record
+  the work that says it as a source (`--kind book|web|newspaper`, what it says
+  in `--transcript`) — the story tells it as background, citing it.
+- Images of an archive or a library come through a connector or the user, as
+  everywhere (never your own download).

package/assets/method/narrate.md

@@ -5,6 +5,10 @@ A story is written from the facts, for the family.
 - Every statement rests on a recorded fact; say which ones.
 - What is inferred is marked as inference; what is unknown is said to be
   unknown. Never fill gaps with plausible fiction.
+- The background of place and time (a war, an epidemic, a fire, what the
+  village lived from) only from a source recorded in the research, named with
+  `--source S…`, and told as background: "in 1866 the war passed through the
+  region" — never as the cause of what the person did, unless a record says so.
 - Use the research language and plain words; explain old occupations and
   terms the reader will not know.
 - Format: paragraphs separated by a blank line; within them only "## "
@@ -12,7 +16,11 @@ A story is written from the facts, for the family.
   anything else (links, tables, quotes, numbered lists) as plain text. The
   title goes in --title, not as a "# " line in the text.
 - Write it to a file in notes/, then `strom story set P… --text @notes/story-P….md
-  --title "…" --fact E… --fact E… --note "what is inferred"`: every fact it leans on goes
-  in --fact. A couple's story goes on the family (F…).
+  --title "…" --fact E… --fact E… --source S… --note "what is inferred"`: every fact it leans on goes
+  in --fact, every source of its background in --source. A couple's story goes on the family (F…).
 - It stays a draft; when the user says it is right: `strom story approve P…`
-  (the Strom app asks them too).
+  (the Strom app asks them too). An approved story is locked — the user liked
+  it: written again (more facts, a better reading), the new version waits
+  beside it and the approved one stays until the user decides. Tell them what
+  is new in it; they approve it (`strom story approve P…`) or keep the old one
+  (`strom story discard P…`) — only on their word.

package/dist/cli/menu-links.js

@@ -143,12 +143,21 @@ export async function decideConflict(ctx, run, lang, root, id) {
     out(ctx, t("ui.link.conflict.done"));
     return true;
 }
-/** A story the person read and approves: no longer a draft. */
-export async function approveStory(ctx, run, lang, root, person, who) {
+/**
+ * A story the person read and approves: no longer a draft, locked. Beside an approved one, its new version: read and
+ * approved in its place, or not wanted (keep: the approved one stays) — as the menu's "What waits for you".
+ */
+export async function approveStory(ctx, run, lang, root, person, who, how = "final") {
     const t = translator(lang);
     const st = person.story;
     if (!st)
         return stop(ctx, t("ui.link.story.none", { person: who }));
+    if (st.draft) {
+        const { decideStory } = await import("./menu-waiting.js");
+        return decideStory(ctx, run, lang, root, person.id, who, how);
+    }
+    if (how === "keep")
+        return stop(ctx, t("ui.link.story.nonew", { person: who }));
     if (st.status === "final")
         return stop(ctx, t("ui.link.story.final", { person: who }));
     out(ctx, lines(st.title ? `„${st.title}“` : undefined, "", st.text.replace(/\*\*/g, ""), ""));
@@ -159,6 +168,16 @@ export async function approveStory(ctx, run, lang, root, person, who) {
     out(ctx, t("ui.link.story.done"));
     return true;
 }
+/**
+ * The family whose story a link of the Strom app means by its two partners (the app knows no family IDs): of several,
+ * the one with a new version waiting, then one with a story, then the first.
+ */
+export function coupleStory(tree, a, b) {
+    if (a === b)
+        return undefined;
+    const theirs = tree.list("family").filter((f) => !f.retracted && f.partners.includes(a) && f.partners.includes(b));
+    return theirs.find((f) => f.story?.draft) ?? theirs.find((f) => f.story) ?? theirs[0];
+}
 /** What the research took from the Strom app, taken back on the person's word. */
 export async function undoSending(ctx, run, lang, root, id) {
     const t = translator(lang);

package/dist/cli/menu-waiting.js

@@ -7,6 +7,10 @@ import { subMenu, translator } from "./menu-parts.js";
 import { offerChat } from "./menu-research.js";
 import { truncate } from "./format.js";
 import { Tree } from "../core/tree.js";
+import { storiesToApprove } from "../core/stories.js";
+import { displayName, lifespan } from "../core/people.js";
+/** A person for the person reading: "Jan Novák (*1905) [P0001]". */
+const label = (p) => `${displayName(p)}${lifespan(p) ? ` (${lifespan(p)})` : ""} [${p.id}]`;
 import { openForUser } from "../core/open.js";
 /** At most this many are listed to answer (the menu's nine); the rest after them. */
 const SHOWN = 9;
@@ -67,27 +71,81 @@ export async function waitingTask(ctx, run, lang, root, id) {
     await takeUp(ctx, run, lang, root, x);
     return true;
 }
+/** Whose story it is, for the person: "Jan Novák (*1905) [P0001]", a couple by both. */
+function storyOf(tree, id) {
+    const r = tree.get(id);
+    if (r?.type === "person")
+        return label(r);
+    if (r?.type === "family")
+        return r.partners
+            .map((p) => tree.get(p))
+            .filter((p) => !!p)
+            .map(label)
+            .join(" & ");
+    return id;
+}
+/**
+ * The new version of a story the person approved before (the lock): read, then it takes the old one's place, or the
+ * old one stays. `how` (a link of the Strom app): what was asked for there — still asked here, with the text before it.
+ */
+export async function decideStory(ctx, run, lang, root, id, who, how) {
+    const t = translator(lang);
+    const out = (line) => ctx.io.stdout(line + "\n");
+    const draft = Tree.open(root, ctx.env).get(id)?.story?.draft;
+    if (!draft) {
+        out(t("ui.waiting.gone"));
+        return false;
+    }
+    out("");
+    out(t("ui.story.new.title", { who, day: draft.at.slice(0, 10) }));
+    out("");
+    if (draft.title)
+        out(`„${draft.title}“`);
+    out(draft.text.replace(/\*\*/g, ""));
+    if (draft.note)
+        out(`\n(${draft.note})`);
+    const i = await ctx.choose(t("ui.story.new.pick"), [{ label: t("ui.story.new.take") }, { label: t("ui.story.new.keep") }], how === "keep" ? 1 : 0, { back: t("ui.browse.back") });
+    if (i === undefined)
+        return false;
+    if ((await run(["story", i === 0 ? "approve" : "discard", id], true)) !== 0)
+        return false;
+    out(t(i === 0 ? "ui.story.new.taken" : "ui.story.new.kept"));
+    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");
-        if (!waiting.length)
+        const stories = storiesToApprove(tree);
+        if (!waiting.length && !stories.length)
             return { title: t("ui.waiting.none"), items: [] };
+        // the tasks first, then the stories: at most the menu's nine together
         const shown = waiting.slice(0, SHOWN);
-        const text = [t("ui.waiting.title", { n: waiting.length })];
+        const shownStories = stories.slice(0, SHOWN - shown.length);
+        const text = [t("ui.waiting.title", { n: waiting.length + stories.length })];
         for (const [k, x] of shown.entries()) {
             text.push("", ` ${k + 1}. ${x.what}`, ...whatToDo(ctx, lang, tree, x));
         }
+        for (const [k, s] of shownStories.entries())
+            text.push("", ` ${shown.length + k + 1}. ${t("ui.waiting.story", { who: storyOf(tree, s.id) })}`);
         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) => ({
-            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 };
+        const hidden = waiting.length + stories.length - shown.length - shownStories.length;
+        if (hidden > 0)
+            text.push("", t("ui.waiting.more", { n: hidden }));
+        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),
+            })),
+            ...shownStories.map((s, k) => ({
+                key: String(shown.length + k + 1),
+                label: t("ui.waiting.story.read", { k: shown.length + k + 1, who: storyOf(tree, s.id) }),
+                act: async () => void (await decideStory(ctx, run, lang, root, s.id, storyOf(tree, s.id))),
+            })),
+        ];
+        return { title: `${text.join("\n")}\n\n${t(shown.length ? "ui.waiting.pick" : "ui.waiting.pick.story")}`, items };
     });
 }

package/dist/cli/menu.js

@@ -36,6 +36,7 @@ import { mainPerson } from "../core/kin.js";
 import { AGENTS, findAgent } from "../core/which.js";
 import { agentsHere } from "../core/apps.js";
 import { PROFILES } from "../agents/profiles.js";
+import { forStory, storiesToApprove } from "../core/stories.js";
 /** Create a family tree and say so in the user's words (init itself talks to agents). */
 async function createTree(ctx, run, lang, name) {
     const before = new Set(ctx.knownTrees().map((k) => k.root));
@@ -99,7 +100,8 @@ export async function runMenu(ctx, run) {
         const newer = await newerVersion(ctx.settings, ctx.env);
         if (root) {
             const tree = Tree.open(root, ctx.env);
-            const waiting = waitingForUser(tree).length;
+            // the tasks that wait for the person, and the new versions of the stories they approved
+            const waiting = waitingForUser(tree).length + storiesToApprove(tree).length;
             const started = tree.list("research").length > 0;
             out(t("ui.menu.tree", { name: tree.config.name, persons: tree.count("person") }));
             // No agent yet (none installed, or not the one chosen): the research waits for it, and item 1 gets one.
@@ -157,7 +159,7 @@ export async function runMenu(ctx, run) {
                     if (shown.length) {
                         out(t("ui.run.next"));
                         for (const [k, x] of shown.entries())
-                            out(`  ${String(k + 1).padStart(2)}. ${truncate(humanTask(fresh, x.what, lang), 100)}${x.level === "narrate" ? t("ui.run.story") : ""}${lacksImages(fresh, x) ? t("ui.plan.images") : ""}`);
+                            out(`  ${String(k + 1).padStart(2)}. ${truncate(humanTask(fresh, x.what, lang), 100)}${forStory(x) ? t("ui.run.story") : ""}${lacksImages(fresh, x) ? t("ui.plan.images") : ""}`);
                         if (queue.length > shown.length)
                             out(`      ${t("ui.plan.more", { n: queue.length - shown.length })}`);
                     }

package/dist/cli/ui.js

@@ -148,6 +148,7 @@ export const UI = {
     "ui.why.session": "{n} task(s) in the queue",
     "ui.why.frontier": "no open tasks — see what the research still lacks",
     "ui.wait.title": "waiting for you ({n})",
+    "ui.wait.stories": "new versions of stories you approved, to read and decide: {ids} (the menu: What waits for you · strom story show <ID>)",
     "ui.wait.images": "images {images} of {book}",
     "ui.wait.save": "save them into {dir}",
     "ui.wait.how1": "scans go into the inbox, a folder per book, each named by its image number as the viewer counts it",
@@ -415,6 +416,9 @@ export const UI = {
     "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.fact.detail": "{n}. {who}: {kind} {when} — {was} → {now}",
+    "ui.sync.house": "house {x}",
+    "ui.sync.cause": "cause {x}",
     "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}”",
@@ -426,6 +430,7 @@ export const UI = {
     "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.detail": "added to the fact, citing your tree",
     "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)",
@@ -774,6 +779,17 @@ export const UI = {
     "ui.review.next.human": "The agent takes them up in a conversation or when it works alone.",
     "ui.review.wake.human": "    to go on with it, tell the agent in a conversation",
     "ui.waiting.gone": "This one no longer waits for you — the agent has taken it up meanwhile.",
+    "ui.link.story.nonew": "No new version of the story of {person} waits. Nothing was done.",
+    "ui.link.story.nocouple": "{couple} are no couple of the research. Nothing was done.",
+    "ui.story.new.title": "The new version of the story of {who} ({day}) — the one you approved stays until you decide:",
+    "ui.story.new.pick": "Which story should the family book have?",
+    "ui.story.new.take": "the new version, in place of the old one",
+    "ui.story.new.keep": "keep the old one (the new version goes)",
+    "ui.story.new.taken": "✓ The new version is the story now, approved. Open the research in the Strom app again and it is there.",
+    "ui.story.new.kept": "✓ The story you approved stays; the new version is gone (the history of the research keeps it).",
+    "ui.waiting.story": "A new version of the story of {who} — the one you approved stays until you decide",
+    "ui.waiting.story.read": "Read the new story of {who} and decide",
+    "ui.waiting.pick.story": "Choose the number:",
     "ui.trees.pack": "pack \"{name}\" to send to someone (a ZIP file)",
     "ui.trees.unpack": "a family tree someone sent you (a ZIP file)",
     "ui.pack.which": "Which images go along?",

package/dist/commands/browse.js

@@ -13,6 +13,7 @@ import { displayName } from "../core/people.js";
 import { humanTask } from "../cli/human.js";
 export { humanTask };
 import { lacksImages } from "../core/queue.js";
+import { forStory } from "../core/stories.js";
 import { rankedQueue, waitingForUser } from "./tasks.js";
 /** Most rows a section of `recent` lists; the rest is counted. */
 const RECENT_ROWS = 15;
@@ -169,8 +170,9 @@ register({
         const count = positive(opts.count, "count", 10, 200);
         // The order of a conversation (the story's turn is only for working alone).
         const queue = rankedQueue(tree, { strategy: ctx.settings.strategy(tree.config) }).map((r) => r.task);
-        const work = queue.filter((t) => t.level !== "narrate");
-        const stories = queue.filter((t) => t.level === "narrate");
+        // the stories, with the searches beyond the registers before them
+        const work = queue.filter((t) => !forStory(t));
+        const stories = queue.filter(forStory);
         const waiting = waitingForUser(tree).length;
         const shown = work.slice(0, count);
         let n = 0;

package/dist/commands/links.js

@@ -195,8 +195,17 @@ async function inTerminal(ctx, link) {
             return { text: "", data: { done: (await run(["chat", ...(first ? [`--say=${first}`] : [])])) === 0, action: link.action, tree: root } };
         }
         case "story": {
-            const { approveStory } = await import("../cli/menu-links.js");
-            return end(await approveStory(ctx, run, treeLang, root, person, who(person)));
+            const { approveStory, coupleStory } = await import("../cli/menu-links.js");
+            if (!link.partner)
+                return end(await approveStory(ctx, run, treeLang, root, person, who(person), link.do));
+            const partner = personOf(root, ctx, link.partner);
+            if (!partner)
+                return said("ui.link.noperson", { person: link.partner });
+            const couple = `${who(person)} & ${who(partner)}`;
+            const family = coupleStory(Tree.open(root, ctx.env), person.id, partner.id);
+            if (!family)
+                return said("ui.link.story.nocouple", { couple });
+            return end(await approveStory(ctx, run, treeLang, root, family, couple, link.do));
         }
         case "review": {
             const what = ui(treeLang, `ui.link.what.review.${link.scope}`, { person: who(person) });
@@ -290,7 +299,7 @@ register({
         "strom-research://research?tree=<id>&person=P0012&direction=ancestors|descendants — a new direction (research new).\n" +
         "strom-research://task?…&task=T0007&do=park|drop|wake — the task put aside, given up, back in the queue (the reason asked).\n" +
         "strom-research://conflict?tree=<id>&id=X0007&do=decide|agent — decided by the user (which claim, why) or left to the agent.\n" +
-        "strom-research://story?tree=<id>&person=P0012&do=final — the story approved (strom story approve).\n" +
+        "strom-research://story?tree=<id>&person=P0012[&partner=P0013]&do=final|keep — the story approved (strom story approve), of a couple with partner=.\n" +
         "strom-research://sync-undo?tree=<id>&intake=I0042 — a sending from the app taken back (strom sync undo).\n" +
         "strom-research://direction?tree=<id>&id=G0002&do=pause|done|resume — a direction paused, ended (the reason asked) or\n" +
         "taken up again (strom research pause|done|resume).\n" +

package/dist/commands/output.js

@@ -13,7 +13,7 @@ import { UsageError } from "../core/errors.js";
 import { excerptSettings, planExcerpts } from "../core/excerpt.js";
 import { runGit, tracked } from "../core/git.js";
 import { Settings } from "../core/config.js";
-import { appOpensLinks } from "../core/stromapp.js";
+import { appOpensLinks, appShowsEdges, appShowsStoryDrafts } from "../core/stromapp.js";
 import { EXCERPT_QUALITIES, EXCERPT_SCOPES } from "../core/model.js";
 function findingRows(f) {
     return table(f.slice(0, 30).map((x) => [x.level === "error" ? "ERROR" : "warn", `line ${x.line}`, x.message]));
@@ -73,7 +73,11 @@ export function writeTreeGed(tree, opts) {
     // an app that opens links shows what the research knows of a person too (the same version)
     const research = opts.for === "strom" && appOpensLinks(new Settings(tree.env, {}), opts.stromVersion);
     const clips = research && !!images;
-    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}), ...(clips ? { clips } : {}), ...(research ? { research } : {}) });
+    // …and where the tree ends, for an app that shows it
+    const edges = opts.for === "strom" && appShowsEdges(new Settings(tree.env, {}), opts.stromVersion);
+    // …and the new versions of stories the user approved, for an app that shows them
+    const storyDrafts = opts.for === "strom" && appShowsStoryDrafts(new Settings(tree.env, {}), opts.stromVersion);
+    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}), ...(clips ? { clips } : {}), ...(research ? { research } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}) });
     const findings = validateGedcom(result.text, opts.for === "standard" ? { strict: true } : {});
     const file = opts.out ?? gedFile(tree, opts.for, opts.research);
     if (!hasGedErrors(findings) && !tree.dryRun) {