strom-research 1.9.0 → 1.11.0

package/dist/commands/sync.js

@@ -11,15 +11,23 @@ import { EXIT, StromError, UsageError } from "../core/errors.js";
 import { fileSha256, MAX_IN_TREE, mimeOf } from "../core/media.js";
 import { create, update } from "../core/records.js";
 import { safeFolderName } from "../core/text.js";
+import { humanAge } from "../core/age.js";
 import { now } from "../core/tree.js";
 import { applySync, nothingSince, planSync, readTreeFile, receivedSince, undoSync } from "../core/sync.js";
 import { startLive } from "../core/live.js";
 import { appSendsChanges, installedStromApp, sendAppUrl, stromAppUrl } from "../core/stromapp.js";
 import { chromiumBrowser, openInBrowser, openWebApp } from "../core/chromium.js";
-function factText(f, lang) {
+function factText(f, lang, name = (k) => k) {
     if (!f)
         return "—";
-    return [f.value, humanDate(f.date, lang), humanPlace(f.place, undefined, lang)].filter(Boolean).join(", ") || "—";
+    return [f.value, humanDate(f.date, lang), humanPlace(f.place, undefined, lang), detailText(f, lang, name)].filter(Boolean).join(", ") || "—";
+}
+/** What a fact says besides: its house, age (a couple's: each partner's) and cause. */
+function detailText(f, lang, name = (k) => k) {
+    if (!f)
+        return "";
+    const ages = Object.entries(f.ages ?? {}).map(([who, a]) => `${name(who)} ${humanAge(a, lang)}`);
+    return [f.house && ui(lang, "ui.sync.house", { x: f.house }), f.age && humanAge(f.age, lang), ...ages, f.cause && ui(lang, "ui.sync.cause", { x: f.cause })].filter(Boolean).join(", ");
 }
 /** A position on the map as a map shows it: degrees, six decimals at most. */
 const point = (p) => `${+p.lat.toFixed(6)}, ${+p.lon.toFixed(6)}`;
@@ -34,15 +42,18 @@ function changeLine(tree, c, incoming, lang) {
         return p ? `${(p.names[0] ? `${p.names[0].given} ${p.names[0].surname}` : key).trim()} [${key}]` : key;
     };
     const who = c.partners ? c.partners.map(name).join(" & ") || c.family || "?" : name(c.person);
+    // a partner in their age: the given name
+    const short = (key) => (key.startsWith("x:") ? name(key) : (tree.get(key)?.names[0]?.given ?? key));
     const kind = (f) => (f ? eventName(f.kind, lang, f.label) : "");
     const v = {
         n: c.n,
         who,
         name: name(c.person),
         kind: kind(c.fact ?? c.was),
-        fact: `${kind(c.fact ?? c.was)} ${factText(c.fact ?? c.was, lang)}`,
-        was: factText(c.was, lang),
-        now: factText(c.fact, lang),
+        fact: `${kind(c.fact ?? c.was)} ${factText(c.fact ?? c.was, lang, short)}`,
+        was: c.kind === "fact.detail" ? detailText(c.was, lang, short) || "—" : factText(c.was, lang, short),
+        now: c.kind === "fact.detail" ? detailText(c.fact, lang, short) : factText(c.fact, lang, short),
+        when: [humanDate(c.fact?.date, lang), humanPlace(c.fact?.place, undefined, lang)].filter(Boolean).join(", "),
         text: truncate(c.text ?? "", 120),
         child: name(c.child),
         kids: c.kind === "family.new" && c.text ? ` + ${c.text.split(" ").filter(Boolean).map(name).join(", ")}` : "",
@@ -51,7 +62,8 @@ function changeLine(tree, c, incoming, lang) {
         from: c.place?.was ? point(c.place.was) : "",
     };
     const key = c.kind === "place.coords" && !c.place?.was ? "ui.sync.place.located" : `ui.sync.${c.kind}`;
-    return `${ui(lang, key, v)} → ${ui(lang, `ui.sync.do.${c.action}`)}`;
+    const does = c.kind === "fact.detail" && c.action === "add" ? "ui.sync.do.detail" : `ui.sync.do.${c.action}`;
+    return `${ui(lang, key, v)} → ${ui(lang, does)}`;
 }
 function planText(tree, plan, incoming, file, lang, edits) {
     const shown = file.includes(" ") ? `"${file}"` : file;

package/dist/commands/tasks.js

@@ -22,6 +22,7 @@ import { readJsonLines } from "../core/json.js";
 import { lacksImages, rankTasks } from "../core/queue.js";
 import { joiningHypotheses, offTree } from "../core/kin.js";
 import { aboutPeople } from "../core/directions.js";
+import { storiesToApprove } from "../core/stories.js";
 import { clipNote, inboxFolderFor, parseImageList, transcriptNote } from "../core/media.js";
 function written(tree) {
     return lines(...tree.written.map((o) => o.summary), tree.dryRun ? "(dry run — nothing written)" : undefined);
@@ -63,8 +64,11 @@ export function waitingForUser(tree) {
  */
 export function waitingLines(tree, where = {}, max = 5) {
     const w = tree.list("task").filter((t) => t.state === "waiting");
+    // the new versions of stories the user approved: they decide (the lock)
+    const stories = storiesToApprove(tree).map((s) => s.id);
+    const storyLine = stories.length ? `  ${ui(tree.lang, "ui.wait.stories", { ids: stories.join(" ") })}` : undefined;
     if (!w.length)
-        return undefined;
+        return stories.length ? lines(ui(tree.lang, "ui.wait.title", { n: stories.length }), storyLine) : undefined;
     const show = where.display ?? ((p) => p);
     const lang = tree.lang;
     const images = (t) => {
@@ -77,7 +81,7 @@ export function waitingLines(tree, where = {}, max = 5) {
             `         ${ui(lang, "ui.wait.save", { dir: `${dir}${path.sep}` })}`,
         ];
     };
-    return lines(ui(lang, "ui.wait.title", { n: w.length }), ...w.slice(0, max).flatMap((t) => [`  ${t.id}  ${truncate(t.waitingOn || t.what, 150)}`, ...images(t)]), w.length > max ? `  … strom task list --state waiting` : undefined, `  ${ui(lang, "ui.wait.how1")}`, `  ${ui(lang, "ui.wait.how2")}`);
+    return lines(ui(lang, "ui.wait.title", { n: w.length + stories.length }), ...w.slice(0, max).flatMap((t) => [`  ${t.id}  ${truncate(t.waitingOn || t.what, 150)}`, ...images(t)]), w.length > max ? `  … strom task list --state waiting` : undefined, storyLine, `  ${ui(lang, "ui.wait.how1")}`, `  ${ui(lang, "ui.wait.how2")}`);
 }
 /** The open tasks of the queue in the order to work on them (see core/queue.ts). */
 export function taskQueue(tree, filter = {}) {

package/dist/core/actions.js

@@ -589,8 +589,10 @@ export function editPerson(tree, id, edit, reason) {
  */
 export function editEvent(tree, eventId, edit, reason) {
     const date = edit.date === undefined ? undefined : parseDate(edit.date);
-    const age = edit.age === undefined ? undefined : parseAge(edit.age);
-    const ages = edit.ages ? Object.fromEntries(Object.entries(edit.ages).map(([who, a]) => [who, parseAge(a, who)])) : undefined;
+    // an empty age takes it away
+    const age = edit.age === undefined ? undefined : edit.age.trim() ? parseAge(edit.age) : "";
+    // an empty age of a partner takes it away
+    const ages = edit.ages ? Object.fromEntries(Object.entries(edit.ages).map(([who, a]) => [who, a.trim() ? parseAge(a, who) : ""])) : undefined;
     return replaceEvent(tree, eventId, (e) => {
         const changed = [];
         const set = (k, v) => {
@@ -620,7 +622,11 @@ export function editEvent(tree, eventId, edit, reason) {
             for (const [who, a] of Object.entries(ages))
                 if (e.ages?.[who] !== undefined && e.ages[who] !== a)
                     changed.push(`age of ${who}`);
-            next.ages = { ...e.ages, ...ages };
+            const merged = Object.fromEntries(Object.entries({ ...e.ages, ...ages }).filter(([, a]) => a));
+            if (Object.keys(merged).length)
+                next.ages = merged;
+            else
+                delete next.ages;
         }
         const key = (p) => `${p.role}|${p.person ?? foldText(p.name ?? "")}`;
         if (edit.drop?.length) {
@@ -821,7 +827,11 @@ export function mergeFamilies(tree, keepId, otherId, reason) {
         return { family: merged, repointed };
     });
 }
-/** Write (or rewrite) the story of a person or a couple. The facts it leans on must exist. */
+/**
+ * Write (or rewrite) the story of a person or a couple. The facts it leans on must exist. A story the user approved is
+ * locked: written again, the new version waits beside it for their approval (story.draft) — unless they approve it now
+ * (final).
+ */
 export function setStory(tree, id, input) {
     const text = input.text.replace(/\r\n?/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
     if (!text)
@@ -829,28 +839,55 @@ export function setStory(tree, id, input) {
     const facts = [...new Set((input.facts ?? []).map((f) => f.trim().toUpperCase()))];
     for (const f of facts)
         findEventOwner(tree, f);
+    const sources = [...new Set((input.sources ?? []).map((s) => s.trim().toUpperCase()))];
+    for (const s of sources)
+        if (tree.get(s)?.type !== "source")
+            throw new UsageError(`no source ${s}`, { hint: "the background of place and time is recorded first: strom source add … --kind book|newspaper|web" });
     return tree.withTreeLock(() => {
         const rec = tree.get(id);
         if (!rec || (rec.type !== "person" && rec.type !== "family"))
             throw new UsageError(`no person or family ${id}`);
         if (rec.mergedInto)
             throw new UsageError(`${id} was merged into ${rec.mergedInto}`);
-        const story = {
+        const version = {
             ...(input.title?.trim() ? { title: input.title.trim() } : {}),
-            status: input.final ? "final" : "draft",
             text,
             facts,
+            ...(sources.length ? { sources } : {}),
             ...(input.note?.trim() ? { note: input.note.trim() } : {}),
             at: now(),
             by: tree.actor,
         };
-        const updated = { ...rec, story, updated: now() };
         const words = text.split(/\s+/).length;
+        if (rec.story?.status === "final" && !input.final) {
+            const updated = { ...rec, story: { ...rec.story, draft: version }, updated: now() };
+            tree.put(updated, { op: "story.set", targets: [id], summary: `${id} story: a new version (${words} words) waits for the user's approval; the approved one stays` });
+            return updated;
+        }
+        const story = { ...version, status: input.final ? "final" : "draft" };
+        const updated = { ...rec, story, updated: now() };
         tree.put(updated, { op: "story.set", targets: [id], summary: `${id} story${rec.story ? " rewritten" : ""}: ${words} words, ${story.status}` });
         return updated;
     });
 }
-/** The user approved the story as it is: no longer a draft (the text stays). */
+/** The new version of an approved story is not wanted: it goes, the approved story stays (the history keeps it). */
+export function discardStoryDraft(tree, id) {
+    return tree.withTreeLock(() => {
+        const rec = tree.get(id);
+        if (!rec || (rec.type !== "person" && rec.type !== "family"))
+            throw new UsageError(`no person or family ${id}`);
+        if (!rec.story?.draft)
+            throw new UsageError(`${id} has no new version of its story waiting`, { hint: `strom story show ${id}` });
+        const { draft: _gone, ...story } = rec.story;
+        const updated = { ...rec, story, updated: now() };
+        tree.put(updated, { op: "story.discard", targets: [id], summary: `${id} story: the new version discarded, the approved one stays` });
+        return updated;
+    });
+}
+/**
+ * The user approved the story as it is: no longer a draft (the text stays), locked — or, when a new version waits
+ * beside an approved one, that new version takes its place, approved.
+ */
 export function approveStory(tree, id) {
     return tree.withTreeLock(() => {
         const rec = tree.get(id);
@@ -858,6 +895,11 @@ export function approveStory(tree, id) {
             throw new UsageError(`no person or family ${id}`);
         if (!rec.story)
             throw new UsageError(`${id} has no story yet`, { hint: `strom story set ${id} --text @file --fact E…` });
+        if (rec.story.draft) {
+            const updated = { ...rec, story: { ...rec.story.draft, status: "final" }, updated: now() };
+            tree.put(updated, { op: "story.approve", targets: [id], summary: `${id} story: the new version approved, in place of the old one` });
+            return updated;
+        }
         if (rec.story.status === "final")
             return rec;
         const updated = { ...rec, story: { ...rec.story, status: "final" }, updated: now() };

package/dist/core/changelog.js

@@ -48,6 +48,7 @@ const SAID = {
     "repository.edit": "log.repository.edit",
     "story.set": "log.story.set",
     "story.approve": "log.story.approve",
+    "story.discard": "log.story.discard",
     "note.add": "log.note.add",
     "input.add": "log.input.add",
     "input.sync": "log.input.sync",

package/dist/core/config.js

@@ -44,6 +44,7 @@ export const SETTINGS = [
     { key: "queue.strategy", env: "STROM_QUEUE_STRATEGY", tree: true, kind: "choice", choices: STRATEGIES, description: "order of the task queue: balanced (default — nearest ancestors first, spread over the lines, nothing taken forever), depth (stay on one line), priority (strict priority)" },
     { key: "gedcom.for", env: "STROM_GEDCOM_FOR", tree: true, kind: "choice", choices: ["both", "standard", "strom"], description: "GEDCOM files written: both (default), standard (any program), strom (the Strom app)" },
     { key: "stories", env: "STROM_STORIES", tree: true, kind: "choice", choices: ["yes", "no"], description: "stories of the ancestors for the family, written from the facts: yes (default — strom proposes one once a person's life is told by records), no — the user is told when the research starts and may say no" },
+    { key: "stories.sources", env: "STROM_STORIES_SOURCES", tree: true, kind: "choice", choices: ["yes", "no"], description: "before a story is written, a search beyond the registers — newspapers, directories, military, land and court records, graves, the history of the place — so the story can tell more, every word still on a record: yes (default, while stories are on), no (the story from what the research found)" },
     { key: "sync.edits", env: "STROM_SYNC_EDITS", tree: true, kind: "choice", choices: ["conflict", "user"], description: "your edits in the Strom app (or another program's file) to a fact a record proves, taken by strom sync: conflict (default — the research keeps the record's, a conflict for you to decide) or user (your edit wins, the record's fact is withdrawn with the reason)" },
     { key: "main.person", env: "STROM_MAIN_PERSON", tree: true, kind: "person", description: "the main person of the tree (P…): first in the GEDCOM files — the Strom app opens on them (default: the nearest person descended from every research's focus, else the first research's focus)" },
     { key: "excerpts.quality", env: "STROM_EXCERPTS_QUALITY", tree: true, kind: "choice", choices: EXCERPT_QUALITIES, description: "the entries cut out of their scans in the file for the Strom app (output/tree-strom.ged): small (1000 px, grey — half the size), normal (default, 1200 px), sharp (1600 px)" },
@@ -362,6 +363,10 @@ export class Settings {
         const v = this.resolve("stories", tree)?.value;
         return { on: v !== "no", said: v === "yes" || v === "no" };
     }
+    /** Before a story, the sources beyond the registers (core/stories.ts): on unless the user said no. */
+    storySources(tree) {
+        return this.resolve("stories.sources", tree)?.value !== "no";
+    }
     /** strom sync: whether the user's edit to a fact a record proves wins, or becomes a conflict. */
     syncEdits(tree) {
         return this.resolve("sync.edits", tree)?.value === "user" ? "user" : "conflict";

package/dist/core/import.js

@@ -40,7 +40,47 @@ export function importDate(raw) {
         .replace(/^(AFTER|>)\s*/, "AFT ")
         .replace(/\?$/, "")
         .trim();
-    return normalizeDate(cleaned);
+    return normalizeDate(cleaned) ?? localDate(raw);
+}
+// Words other programs write in place of GEDCOM's ("Po 1919", "kolem 1850", "zwischen 1811 und 1812",
+// "около 1870"), folded: Czech, Slovak, German, Polish, Russian, Ukrainian, English.
+const DATE_QUALIFIER = {
+    ...Object.fromEntries(["after", "po", "nach", "после", "після"].map((w) => [w, "AFT"])),
+    ...Object.fromEntries(["before", "pred", "vor", "przed", "do", "bis", "до"].map((w) => [w, "BEF"])),
+    ...Object.fromEntries(["about", "circa", "ca", "c", "cca", "kolem", "okolo", "asi", "zhruba", "priblizne", "um", "etwa", "ungefahr", "ok", "около", "близько", "приблизно"].map((w) => [w, "ABT"])),
+};
+const DATE_RANGE = {
+    ...Object.fromEntries(["between", "mezi", "medzi", "miedzy", "pomiedzy", "zwischen", "между", "між"].map((w) => [w, "BET"])),
+    ...Object.fromEntries(["from", "od", "von", "ab", "с", "з", "від"].map((w) => [w, "FROM"])),
+};
+const DATE_JOIN = new Set(["and", "a", "i", "und", "и", "і", "та", "to", "do", "bis", "по", "до"]);
+/** "po roce 1919", "im Jahr 1850", "1870 г.": words around the year that say nothing. */
+const DATE_FILLER = new Set(["r", "roku", "roce", "rokem", "rok", "im", "jahr", "jahre", "year", "the", "г", "года", "году", "року", "рік"]);
+/** A date written in words of a language ("Po 1919" → "AFT 1919"); undefined when it is not one. */
+function localDate(raw) {
+    const words = foldText(raw)
+        .split(" ")
+        .map((w) => w.replace(/[.,]+$/u, ""))
+        .filter((w) => w && !DATE_FILLER.has(w));
+    const plain = (part) => {
+        const d = part.length ? normalizeDate(part.join(" ")) : undefined;
+        return d && !/^(ABT|CAL|EST|BEF|AFT|BET|FROM|TO) /.test(d) ? d : undefined;
+    };
+    const first = words[0] ?? "";
+    const range = DATE_RANGE[first];
+    if (range) {
+        const j = words.findIndex((w, i) => i > 1 && DATE_JOIN.has(w));
+        const a = plain(j > 0 ? words.slice(1, j) : words.slice(1));
+        const b = j > 0 ? plain(words.slice(j + 1)) : undefined;
+        if (!a)
+            return undefined;
+        if (range === "BET")
+            return b ? `BET ${a} AND ${b}` : undefined;
+        return j > 0 ? (b ? `FROM ${a} TO ${b}` : undefined) : `FROM ${a}`;
+    }
+    const q = DATE_QUALIFIER[first];
+    const d = q ? plain(words.slice(1)) : undefined;
+    return q && d ? `${q} ${d}` : undefined;
 }
 function makeSource(tree, title, input) {
     const t = now();
@@ -405,6 +445,12 @@ export function isStromJson(data) {
 export function fromFlexDate(flex) {
     if (!flex)
         return undefined;
+    // a range ("1785..1804"): between the two
+    const range = /^(.+?)\.\.(.+)$/.exec(flex.trim());
+    if (range) {
+        const [a, b] = [fromFlexDate(range[1]), fromFlexDate(range[2])];
+        return a && b && !/^(ABT|BEF|AFT|BET|FROM|TO) /.test(a) && !/^(ABT|BEF|AFT|BET|FROM|TO) /.test(b) ? normalizeDate(`BET ${a} AND ${b}`) : undefined;
+    }
     const m = /^([~<>])?(\d{3,4})(?:-(\d{2}))?(?:-(\d{2}))?$/.exec(flex.trim());
     if (!m)
         return importDate(flex);
@@ -496,7 +542,7 @@ export function importStromJson(tree, data, opts) {
     return result;
 }
 /** "čp. 13", "č. p. 13", "Nr. 13", "House No. 13" → "13": the house, without the word for it. */
-function houseOf(address) {
+export function houseOf(address) {
     return address
         .replace(/\s+/g, " ")
         .trim()

package/dist/core/links.js

@@ -33,6 +33,8 @@ export const LINK_SCHEME = "strom-research";
  * and (the app's 3.5.0) the research followed live in the app's window; a direction of the research paused, ended or
  * taken up again, a conversation about one direction, a session at work asked to finish.
  */
+/** A story: approved (or, beside an approved one, its new version approved in its place), or that new version not wanted. */
+export const LINK_STORY_DOS = ["final", "keep"];
 export const LINK_ACTIONS = ["send", "excerpt", "app", "open", "chat", "task", "review", "research", "new", "update", "sessions", "conflict", "story", "sync-undo", "setup", "live", "direction", "finish"];
 /** A person's review: the person, with the family, with the ancestors (strom review --scope). */
 export const LINK_SCOPES = ["person", "family", "line"];
@@ -139,7 +141,9 @@ export function parseLink(text) {
                 return { action, tree: id, person, scope: oneOf(q, "scope", LINK_SCOPES, "person") };
             if (action === "research")
                 return { action, tree: id, person, direction: oneOf(q, "direction", LINK_DIRECTIONS, "ancestors") };
-            return { action, tree: id, person, do: oneOf(q, "do", ["final"]) };
+            // a couple's story: the app knows no family IDs, so the family of the two partners
+            const partner = idOf(q, "partner", PERSON, false);
+            return { action, tree: id, person, ...(partner ? { partner } : {}), do: oneOf(q, "do", LINK_STORY_DOS) };
         }
         case "conflict":
             return { action, tree: id, id: idOf(q, "id", CONFLICT, true), do: oneOf(q, "do", LINK_CONFLICT_DOS, "decide") };

package/dist/core/live.js

@@ -35,7 +35,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { Tree, VERSION } from "./tree.js";
 import { changeLines } from "./changelog.js";
 import { directionOf, scopes } from "./directions.js";
-import { ancestorGenerations } from "./people.js";
+import { ancestorGenerations, displayName } from "./people.js";
 import { phrase } from "./phrases.js";
 import { exportGedcom } from "../gedcom/export.js";
 import { excerptSettings, planExcerpts } from "./excerpt.js";
@@ -49,10 +49,11 @@ import { rankTasks } from "./queue.js";
 import { humanTask } from "../cli/human.js";
 import { knownNewerVersion } from "./update.js";
 import { gitProgram, runGit } from "./git.js";
-import { appOpensLinks, appShowsEdges, isStromAppOrigin } from "./stromapp.js";
+import { appOpensLinks, appShowsCoupleEvents, appShowsEdges, appShowsStoryDrafts, isStromAppOrigin } from "./stromapp.js";
 import { Settings } from "./config.js";
 import { linkActions, linkHandlerState } from "./links.js";
 import { stromLauncher } from "./self.js";
+import { storiesToApprove } from "./stories.js";
 /** Where a running bridge of a tree is noted. */
 export function liveFile(root) {
     return path.join(root, ".strom", "live.json");
@@ -300,6 +301,30 @@ function personOf(t) {
     const people = (t?.subject ?? []).filter((id) => /^P\d{1,7}$/.test(id));
     return people.length === 1 ? { person: people[0] } : {};
 }
+/** The new versions of approved stories, as items of `waiting`: whose (a couple's: person and partner), since when. */
+function storiesWaiting(tree) {
+    return storiesToApprove(tree).flatMap((s) => {
+        const rec = tree.get(s.id);
+        if (!rec)
+            return [];
+        const people = rec.type === "family" ? rec.partners : [rec.id];
+        const name = (id) => {
+            const p = tree.get(id);
+            return p ? displayName(p) : id;
+        };
+        return [
+            {
+                kind: "story",
+                id: rec.id,
+                what: ui(tree.lang, "ui.waiting.story", { who: people.map(name).join(" & ") }),
+                on: "",
+                at: s.at,
+                ...(people[0] ? { person: people[0] } : {}),
+                ...(people[1] ? { partner: people[1] } : {}),
+            },
+        ];
+    });
+}
 /** Who works, as the user reads it: "Claude Code on its own", "Codex conversation" in the research language. */
 function whoAtWork(label, lang) {
     const run = /^(.+) on its own$/.exec(label);
@@ -459,7 +484,11 @@ function status(root, env) {
         working: atWork,
         open: openSessions(tree).map((s) => ({ id: s.id, task: s.task, started: s.started })),
         // since when it waits: its last change is the one that made it wait
-        waiting: waiting.map((t) => ({ id: t.id, what: t.what, on: t.waitingOn ?? "", at: t.updated, ...personOf(t), ...researchOf(tree, t, all) })),
+        waiting: [
+            ...waiting.map((t) => ({ id: t.id, what: t.what, on: t.waitingOn ?? "", at: t.updated, ...personOf(t), ...researchOf(tree, t, all) })),
+            // a new version of an approved story, as the menu counts it — for an app that shows it (the _DRAFT gate)
+            ...(appShowsStoryDrafts(settings) ? storiesWaiting(tree) : []),
+        ],
         links: links(env),
         ...queue(tree, next, all),
         ...(newer ? { update: { version: newer } } : {}),
@@ -566,11 +595,13 @@ export function serveLive(root, env) {
                     const opens = appOpensLinks(new Settings(env, {}));
                     // …and where the tree ends, for an app that shows it
                     const edges = appShowsEdges(new Settings(env, {}));
+                    const storyDrafts = appShowsStoryDrafts(new Settings(env, {}));
+                    const coupleResi = appShowsCoupleEvents(new Settings(env, {}));
                     const offered = opens ? links(env) : [];
                     ged = {
                         head: h,
                         links: offered.join(" "),
-                        text: exportGedcom(tree, { for: "strom", ...(h ? { head: h } : {}), ...(images ? { excerpts: images.of } : {}), ...(opens ? { clips: true, research: true } : {}), ...(edges ? { edges } : {}), ...(offered.length ? { links: offered } : {}) }).text,
+                        text: exportGedcom(tree, { for: "strom", ...(h ? { head: h } : {}), ...(images ? { excerpts: images.of } : {}), ...(opens ? { clips: true, research: true } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(offered.length ? { links: offered } : {}) }).text,
                     };
                 }
                 res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store", "X-Strom-Head": h }).end(ged.text);

package/dist/core/phrases.js

@@ -31,6 +31,10 @@ export const PHRASES = {
     "story.where": "the facts recorded (strom person show {id})",
     "story.why": "{count} facts from records tell the life (generation {generation} of {research}); the family reads it in the Strom app's family book",
     "story.done": "strom story set {id} with every fact it rests on (--fact) — a draft until the user approves it",
+    "story.sources.what": "Beyond the registers, for the story of {name}: newspapers, directories, military, land and court records, graves, the history of the place",
+    "story.sources.where": "the digitised newspapers, books and archives of the country and time; the web (indexes and trees are leads only)",
+    "story.sources.why": "the story is to tell more than the registers do — every word still on a record; then strom proposes the story",
+    "story.sources.done": "each find recorded as a source and a fact with its citation (the person matched by more than the name), the history of the place as a source, every search recorded — also in vain",
     "review.research": "Review of {name}",
     "review.unproven.research": "People without a record of their own",
     "review.more": " (and {count} more after these)",
@@ -130,6 +134,7 @@ export const PHRASES = {
     "log.repository.edit": "Archive changed: {name}",
     "log.story.set": "Story: {who}",
     "log.story.approve": "Story approved: {who}",
+    "log.story.discard": "The new version of the story not wanted, the approved one stays: {who}",
     "log.note.add": "Note: {name}",
     "log.input.add": "Material from the family: {name}",
     "log.input.sync": "Family tree taken in: {name}",

package/dist/core/queue.js

@@ -16,6 +16,7 @@ import { now } from "./tree.js";
 import { subjectPeople } from "./records.js";
 import { directionOf, scopes } from "./directions.js";
 import { offTree } from "./kin.js";
+import { forStory } from "./stories.js";
 export const LEVEL_ORDER = { intake: 0, locate: 1, link: 2, verify: 3, enrich: 4, request: 5, narrate: 6 };
 /** Levels that read records: without images of their record sets they can only ask the user for them. */
 const NEEDS_IMAGES = new Set(["link", "verify"]);
@@ -92,7 +93,10 @@ export function rankTasks(tree, tasks, strategy = "balanced", opts = {}) {
         return t ? (place(t)?.line ?? `task:${t.id}`) : undefined;
     });
     // A story's turn: STORY_EVERY sessions since the last one on a story (or ever), and one waits.
-    const sinceStory = ended.findIndex((s) => tasksById.get(s.task)?.level === "narrate");
+    const sinceStory = ended.findIndex((s) => {
+        const t = tasksById.get(s.task);
+        return !!t && forStory(t);
+    });
     const storyDue = !!opts.storyTurn && strategy !== "priority" && (sinceStory === -1 ? ended.length : sinceStory) >= STORY_EVERY;
     const tries = new Map();
     for (const s of ended)
@@ -110,7 +114,7 @@ export function rankTasks(tree, tasks, strategy = "balanced", opts = {}) {
                 ? 0
                 : 2 * t.priority + intake - (gen - 1) - 2 * recent - 1.5 * tried;
         const blocked = lacksImages(tree, t, withImages);
-        const storyTurn = storyDue && t.level === "narrate";
+        const storyTurn = storyDue && forStory(t);
         const why = [
             t.state === "doing" ? "in progress" : undefined,
             storyTurn ? `a story's turn: none in the last ${STORY_EVERY} sessions` : undefined,
@@ -122,7 +126,7 @@ export function rankTasks(tree, tasks, strategy = "balanced", opts = {}) {
         ]
             .filter(Boolean)
             .join(" · ");
-        return { task: t, why, doing: t.state === "doing" ? 0 : 1, blocked: blocked ? 1 : 0, story: storyTurn ? 0 : t.level === "narrate" ? 2 : 1, score, gen };
+        return { task: t, why, doing: t.state === "doing" ? 0 : 1, blocked: blocked ? 1 : 0, story: storyTurn ? 0 : forStory(t) ? 2 : 1, score, gen };
     });
     return rows
         .sort((a, b) => a.doing - b.doing ||

package/dist/core/stories.js

@@ -1,10 +1,21 @@
 // Stories of the ancestors (the setting `stories`, on by default): once records
 // tell enough of a person's life, strom proposes the task of writing it for the
 // family — and of adding to it when records brought more after it was written.
-// The story goes into the family book of the Strom app (GEDCOM _STORY).
+// The story goes into the family book of the Strom app (GEDCOM _STORY). Before
+// it (the setting `stories.sources`, on by default), once per person a search
+// beyond the registers — newspapers, directories, military, land and court
+// records, graves, the history of the place — so the story can tell more, every
+// word still on a record; the story is proposed when that search is finished.
 import { researchPeople } from "./frontier.js";
 import { displayName, familiesAsPartner, lifespan } from "./people.js";
 import { phrase } from "./phrases.js";
+import { Settings } from "./config.js";
+/** The origin of the search beyond the registers that comes before a story (an enrich task). */
+export const STORY_SOURCES_ORIGIN = "story:sources";
+/** Work for a story: writing it, or the search beyond the registers before it — the queue keeps them after the research. */
+export function forStory(t) {
+    return t.level === "narrate" || t.origin === STORY_SOURCES_ORIGIN;
+}
 const FROM_RECORDS = new Set(["proven", "probable"]);
 const BIRTHS = new Set(["BIRT", "CHR", "BAPM"]);
 const OPEN = new Set(["open", "doing", "parked", "waiting"]);
@@ -22,7 +33,9 @@ export function factsFromRecords(tree, p) {
 /** The stories strom proposes to write (or add to) for the ancestors of a research. */
 export function storyProposals(tree, research) {
     const lang = tree.lang;
-    const narrate = tree.list("task").filter((t) => t.level === "narrate");
+    const tasks = tree.list("task");
+    const narrate = tasks.filter((t) => t.level === "narrate");
+    const sources = new Settings(tree.env, {}).storySources(tree.config);
     const out = [];
     for (const [id, generation] of researchPeople(tree, research)) {
         const p = tree.get(id);
@@ -34,17 +47,40 @@ export function storyProposals(tree, research) {
         const mine = narrate.filter((t) => t.subject.includes(id));
         if (mine.some((t) => OPEN.has(t.state)))
             continue;
+        // The latest version written: a new one waiting beside an approved story, else the story.
+        const latest = p.story?.draft ?? p.story;
         // Dropped since the story was written (or with none): that was the answer — not again until the story changes.
-        const since = p.story?.at ?? "";
+        const since = latest?.at ?? "";
         if (mine.some((t) => t.state === "dropped" && t.updated >= since))
             continue;
         // Done, yet no story: somebody decided so; the user can add the task by hand.
         if (!p.story && mine.some((t) => FINISHED.has(t.state)))
             continue;
         const name = `${displayName(p)}${lifespan(p) ? ` (${lifespan(p)})` : ""}`;
-        const fresh = p.story ? facts.filter((e) => !p.story.facts.includes(e.id)) : facts;
+        const fresh = latest ? facts.filter((e) => !latest.facts.includes(e.id)) : facts;
         if (p.story && fresh.length < STORY_NEW_FACTS)
             continue;
+        // First, once, the search beyond the registers; the story waits while it is open, and comes when it is finished
+        // (done, or dropped: the user's answer about the search, not about the story).
+        if (sources) {
+            const before = tasks.filter((t) => t.origin === STORY_SOURCES_ORIGIN && t.subject.includes(id));
+            if (before.some((t) => OPEN.has(t.state)))
+                continue;
+            if (!before.length) {
+                out.push({
+                    level: "enrich",
+                    priority: 1, // with the stories: after the research
+                    what: phrase(lang, "story.sources.what", { name }),
+                    where: [phrase(lang, "story.sources.where")],
+                    why: phrase(lang, "story.sources.why"),
+                    doneWhen: phrase(lang, "story.sources.done"),
+                    subject: [id],
+                    research: research.id,
+                    origin: STORY_SOURCES_ORIGIN,
+                });
+                continue;
+            }
+        }
         out.push({
             level: "narrate",
             priority: 1, // the research first; a story when there is a moment for it
@@ -58,3 +94,10 @@ export function storyProposals(tree, research) {
     }
     return out;
 }
+/** The new versions of approved stories that wait for the user (the lock): whose, and since when. */
+export function storiesToApprove(tree) {
+    return [...tree.list("person"), ...tree.list("family")]
+        .filter((r) => !r.retracted && r.story?.status === "final" && r.story.draft)
+        .map((r) => ({ id: r.id, at: r.story.draft.at }))
+        .sort((a, b) => a.at.localeCompare(b.at));
+}

package/dist/core/stromapp.js

@@ -82,6 +82,48 @@ export function appShowsEdges(settings, version) {
             return (a[i] ?? 0) > (b[i] ?? 0);
     return true;
 }
+/**
+ * The Strom app keeps a couple's events as events (the app's spec docs/ZADANI_VYZKUM_udalosti-paru.md, its 3.8.0):
+ * their residence goes to it as 1 RESI under FAM (before: an EVEN named so — an older app keeps either in the couple's
+ * note). stromapp.info from 3.8.0 (2026-10-02); another copy of the app (its beta, its development) is taken as current.
+ * An app of unknown version: today's.
+ */
+export const APP_SHOWS_COUPLE_EVENTS = "3.8.0";
+export function appShowsCoupleEvents(settings, version) {
+    if (stromAppUrl(settings) !== STROM_APP_URL)
+        return true;
+    if (!APP_SHOWS_COUPLE_EVENTS)
+        return false;
+    if (!version)
+        return true;
+    const n = (v) => v.split(".").map((x) => Number.parseInt(x, 10) || 0);
+    const [a, b] = [n(version), n(APP_SHOWS_COUPLE_EVENTS)];
+    for (let i = 0; i < 3; i++)
+        if ((a[i] ?? 0) !== (b[i] ?? 0))
+            return (a[i] ?? 0) > (b[i] ?? 0);
+    return true;
+}
+/**
+ * The Strom app shows the new version of a story the user approved, waiting beside it (the app's spec
+ * docs/ZADANI_VYZKUM_vypraveni-zamek.md): 2 _DRAFT under _STORY, and in the bridge's waiting (kind story). stromapp.info
+ * from 3.7.0 (2026-10-02); another copy of the app (its beta, its development: strom.app.url) is taken as current, so it
+ * can be built. An app of unknown version: today's.
+ */
+export const APP_SHOWS_STORY_DRAFTS = "3.7.0";
+export function appShowsStoryDrafts(settings, version) {
+    if (stromAppUrl(settings) !== STROM_APP_URL)
+        return true;
+    if (!APP_SHOWS_STORY_DRAFTS)
+        return false;
+    if (!version)
+        return true;
+    const n = (v) => v.split(".").map((x) => Number.parseInt(x, 10) || 0);
+    const [a, b] = [n(version), n(APP_SHOWS_STORY_DRAFTS)];
+    for (let i = 0; i < 3; i++)
+        if ((a[i] ?? 0) !== (b[i] ?? 0))
+            return (a[i] ?? 0) > (b[i] ?? 0);
+    return true;
+}
 /** The address that opens the Strom app to send the user's edited tree to the bridge. */
 export function sendAppUrl(bridge, settings) {
     return `${stromAppUrl(settings)}?send=${encodeURIComponent(bridge)}`;