strom-research 1.23.0-beta.3 → 1.23.0-beta.4

package/CHANGELOG.cs.md

@@ -7,7 +7,7 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 
 ## 1.23.0
 
-*Připravuje se: bety do 1.23.0-beta.3. Oddíl bude úplný s vydáním.*
+*Připravuje se: bety do 1.23.0-beta.4. Oddíl bude úplný s vydáním.*
 
 - **Osoba ukázaná zvoleným jménem.** Žena narozená pod jedním jménem, provdaná pod druhým a po rozvodu zase u prvního
   se dá ukazovat tímto jménem znovu, aniž by se přidávalo podruhé: `strom name primary <osoba> "<jméno>"` (a
@@ -28,6 +28,11 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   zůstává výzkum na tomto počítači zapečetěný. Klíč, který tam už je, se nikdy nepřepíše.
 - **Vyprávění páru schválené z aplikace Strom.** Dotaz v terminálu teď mluví o vyprávění páru, už ne o vyprávění
   osoby.
+- **Vyprávění páru navrhuje výzkum sám.** Jakmile záznamy vyprávějí společný život páru (svatbu nebo dítě a další
+  dva údaje) a jeden z dvojice už má vlastní vyprávění, výzkum navrhne vyprávění páru stejně jako vyprávění osoby –
+  jen společný život (svatba, domácnost, bydliště, děti, ovdovění); vyprávění partnerů odkáže, neopakuje je.
+  Vyprávění osoby napsané potom shrne manželství jednou větou; žádné už napsané vyprávění se kvůli tomu nezkracuje.
+  `strom config set stories no` vypne i tato.
 - **`strom repair` jedním jazykem.** Každý jeho řádek („obnoveno“, „není co opravit“ …) je pro člověka v jazyce
   výzkumu; agent je čte anglicky jako dřív.
 

package/CHANGELOG.de.md

@@ -7,7 +7,7 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.23.0
 
-*In Vorbereitung: die Betas bis 1.23.0-beta.3. Der Abschnitt ist mit dem Release vollständig.*
+*In Vorbereitung: die Betas bis 1.23.0-beta.4. Der Abschnitt ist mit dem Release vollständig.*
 
 - **Eine Person unter dem gewählten Namen.** Eine Frau, unter einem Namen geboren, unter einem anderen verheiratet und
   nach einer Scheidung wieder beim ersten, lässt sich wieder unter diesem Namen zeigen, ohne dass er ein zweites Mal
@@ -33,6 +33,12 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   der dort schon liegt, wird nie ersetzt.
 - **Die Erzählung eines Paares, aus der Strom-App freigegeben.** Die Frage im Terminal nennt jetzt die Erzählung des
   Paares, nicht mehr die einer Person.
+- **Die Erzählung eines Paares, von der Forschung vorgeschlagen.** Sobald Einträge das gemeinsame Leben eines Paares
+  erzählen (die Hochzeit oder ein Kind und zwei weitere Angaben) und einer der beiden schon eine eigene Erzählung hat,
+  schlägt die Forschung die Erzählung des Paares vor wie die einer Person – nur das gemeinsame Leben (Hochzeit,
+  Haushalt, Wohnorte, Kinder, Witwenschaft); auf die Erzählungen der Partner wird verwiesen, sie werden nicht
+  wiederholt. Eine danach geschriebene Erzählung einer Person fasst die Ehe in einem Satz zusammen; keine schon
+  geschriebene wird dafür gekürzt. `strom config set stories no` schaltet auch diese aus.
 - **`strom repair` in einer Sprache.** Jede Zeile („wiederhergestellt“, „nichts zu reparieren“ …) steht für eine
   Person in der Sprache der Forschung; ein Agent liest sie wie bisher auf Englisch.
 

package/CHANGELOG.md

@@ -7,7 +7,7 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 1.23.0
 
-*In preparation: the betas up to 1.23.0-beta.3. The section is complete with the release.*
+*In preparation: the betas up to 1.23.0-beta.4. The section is complete with the release.*
 
 - **A person shown by the name chosen.** A woman born under one name, married under another and back at the first
   after a divorce can be shown by that name again without it being added twice: `strom name primary <person>
@@ -28,6 +28,12 @@ The changes of each version in short. The full notes and the install lines are o
   older version, the research is still sealed on this computer. A key there already is never replaced.
 - **A couple's story approved from the Strom app.** The question in the terminal now names the story of the couple,
   no longer of a person.
+- **A couple's story proposed by the research.** Once records tell a couple's life together (their wedding or a
+  child, and two more facts) and one of the two has a story of their own, the research proposes the couple's story
+  as it does a person's — their life together alone (the wedding, the household, the homes, the children, the
+  widowhood), the partners' stories referred to, never told again. A person's story written after it says the
+  marriage in a sentence; no story written already is shortened for it. `strom config set stories no` turns these off
+  too.
 - **`strom repair` in one language.** Every line it writes ("restored", "nothing to repair", …) is in the research's
   language for a person; an agent reads them in English as before.
 

package/assets/lang/cs.json

@@ -697,6 +697,12 @@
   "story.where": "zapsané údaje (strom person show {id})",
   "story.why": "{count, plural, one {# údaj ze zápisů vypráví} few {# údaje ze zápisů vyprávějí} other {# údajů ze zápisů vypráví}} ž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.couple.what": "Napsat vyprávění páru: {a} a {b}",
+  "story.couple.more.what": "Doplnit vyprávění páru: {a} a {b} – {count, plural, one {# nový údaj} few {# nové údaje} other {# nových údajů}}",
+  "story.couple.where": "zapsané údaje páru (strom family show {id})",
+  "story.couple.partner": "vyprávění: {name}, už napsané – odkázat, neopakovat (strom story show {id})",
+  "story.couple.why": "{count, plural, one {# údaj ze zápisů vypráví} few {# údaje ze zápisů vyprávějí} other {# údajů ze zápisů vypráví}} jejich společný život (generace {generation} výzkumu {research}); život každého z nich je v jeho vlastním vyprávění",
+  "story.couple.done": "strom story set {id} se všemi údaji, o které se opírá (--fact): jen společný život – svatba, domácnost, bydliště, děti, ovdovění – 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í",

package/assets/lang/de.json

@@ -697,6 +697,12 @@
   "story.where": "die erfassten Angaben (strom person show {id})",
   "story.why": "{count, plural, one {# Angabe aus Einträgen erzählt} other {# 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.couple.what": "Die Geschichte des Paares schreiben: {a} und {b}",
+  "story.couple.more.what": "Die Geschichte des Paares ergänzen: {a} und {b} – {count, plural, one {# neue Angabe} other {# neue Angaben}}",
+  "story.couple.where": "die erfassten Angaben des Paares (strom family show {id})",
+  "story.couple.partner": "die Geschichte: {name}, schon geschrieben – darauf verweisen, nicht wiederholen (strom story show {id})",
+  "story.couple.why": "{count, plural, one {# Angabe aus Einträgen erzählt} other {# Angaben aus Einträgen erzählen}} ihr gemeinsames Leben (Generation {generation} der Forschung {research}); das eigene Leben jedes der beiden steht in seiner eigenen Geschichte",
+  "story.couple.done": "strom story set {id} mit jeder Angabe, auf der sie beruht (--fact): nur das gemeinsame Leben – die Hochzeit, der Haushalt, die Wohnorte, die Kinder, die Witwenschaft – 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",

package/assets/method/narrate.md

@@ -18,6 +18,11 @@ A story is written from the facts, for the family.
 - Write it to a file in notes/, then `strom story set P… --text @notes/story-P….md
   --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…).
+- A couple's story tells their life together: the wedding, the household, the
+  homes, the children, the widowhood. Each one's life before and after it is
+  their own story's — referred to in a sentence, never told again.
+- A person whose couple has a story: the marriage in one sentence pointing to
+  it. What a story told already stays; it is never shortened for a couple's.
 - It stays a draft; when the user says it is right: `strom story approve P…`
   (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

package/dist/brief/brief.js

@@ -294,6 +294,46 @@ function familyBlock(tree, f, short = false) {
         out.push(`    note: ${noteStart(n.text, short ? NOTE_LINE : NOTE_SHOWN)}`);
     return out;
 }
+/**
+ * What the other stories tell already, for a story to write (spec 027 K6.3–K6.4): a couple's — the partners' own
+ * stories, to be referred to and not told again; a person's — the couples' stories of theirs, the marriage in a
+ * sentence pointing to it, and what the person's story told already never shortened for it.
+ */
+function storiesTold(tree, task) {
+    const subject = task.subject.map((id) => tree.get(id)).find((r) => r?.type === "family" || r?.type === "person");
+    if (!subject)
+        return undefined;
+    if (subject.type === "family") {
+        const partners = subject.partners.map((x) => tree.get(x)).filter((x) => !!x && !x.retracted);
+        const text = [
+            `## The couple's story (${subject.id}): their life together alone — the wedding, the household, the homes, the children, the widowhood`,
+            "- each one's life before the wedding and after it is their own story's: referred to in a sentence, never told again",
+            "- every statement on a recorded fact (--fact), as in a person's story",
+        ];
+        // who has no story comes before the stories: a line under a partner's story would read as part of it
+        for (const p of partners)
+            if (!(p.story?.draft ?? p.story))
+                text.push(`- ${label(p)}: no story of their own yet — their life outside the marriage stays out of this one too`);
+        for (const p of partners) {
+            const st = p.story?.draft ?? p.story;
+            if (!st)
+                continue;
+            text.push(`### The story of ${label(p)}${p.story?.draft ? " (its new version, waiting for the user)" : ` (${p.story.status})`}${st.title ? `: ${st.title}` : ""}`, st.text.trim());
+        }
+        return { name: "stories told", first: true, pointer: `strom story show ${partners.map((p) => p.id).join(" · strom story show ")}`, text: text.join("\n") };
+    }
+    const couples = familiesAsPartner(tree, subject.id).filter((f) => !f.retracted && f.story);
+    if (!couples.length)
+        return undefined;
+    const text = [`## The couples' stories of ${label(subject)}: told already`];
+    for (const f of couples) {
+        const others = f.partners.filter((x) => x !== subject.id).map((x) => tree.get(x)).filter((x) => !!x).map(label);
+        text.push(`- ${f.id}${others.length ? ` with ${others.join(", ")}` : ""} has a story of its own (strom story show ${f.id}): the marriage in one sentence pointing to it — their life together not told again`);
+    }
+    if (subject.story)
+        text.push("- what the story told already stays — never shortened because of a couple's story");
+    return { name: "stories told", first: true, pointer: `strom story show ${couples.map((f) => f.id).join(" · strom story show ")}`, text: text.join("\n") };
+}
 /** A small text file of an input, as strom input show gives it; unreadable: nothing. */
 function readSmall(file) {
     try {
@@ -1299,6 +1339,9 @@ export function buildBrief(tree, opts) {
     const ofTime = storyHistoryOn && task.level === "narrate" ? storyHistorySection(tree, task, opts.shared) : undefined;
     if (ofTime)
         sections.push(ofTime);
+    const told = task?.level === "narrate" ? storiesTold(tree, task) : undefined;
+    if (told)
+        sections.push(told);
     // 8 bis. the search beyond the registers: its budget of pages, printed pages for the user's model for print where the
     // agent hands work to another model, and what the research has written of the person's places already
     if (task?.origin === STORY_SOURCES_ORIGIN) {

package/dist/commands/guide.js

@@ -253,7 +253,8 @@ STORIES OF THE ANCESTORS (the setting stories — on by default; strom shows it)
   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 --title "…" --fact E… …; paragraphs,
   "## " subheadings, "- " bullets, **bold**, *italic* — nothing else shows in the app). More facts later: it
-  proposes adding to it. Stories wait behind all the research; working alone
+  proposes adding to it. Once one of a couple has a story, the couple's (strom story set F…): their life
+  together alone, the partners' stories referred to, not retold. 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 (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

package/dist/core/phrases.js

@@ -35,6 +35,12 @@ export const PHRASES = {
     "story.where": "the facts recorded (strom person show {id})",
     "story.why": "{count, plural, one {# fact from records tells} other {# 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.couple.what": "Write the story of the couple {a} and {b}",
+    "story.couple.more.what": "Add to the story of the couple {a} and {b}: {count, plural, one {# new fact} other {# new facts}}",
+    "story.couple.where": "the couple's facts recorded (strom family show {id})",
+    "story.couple.partner": "the story of {name}, told already: referred to, not retold (strom story show {id})",
+    "story.couple.why": "{count, plural, one {# fact from records tells} other {# facts from records tell}} their life together (generation {generation} of {research}); each one's own life is in their own story",
+    "story.couple.done": "strom story set {id} with every fact it rests on (--fact): their life together alone — the wedding, the household, the homes, the children, the widowhood — 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",

package/dist/core/queue.js

@@ -24,8 +24,7 @@
 import { parentsOf } from "./people.js";
 import { taskRecordsets } from "./frontier.js";
 import { now } from "./tree.js";
-import { subjectPeople } from "./records.js";
-import { directionOf, scopes } from "./directions.js";
+import { aboutPeople, directionOf, scopes } from "./directions.js";
 import { offTree } from "./kin.js";
 import { forStory } from "./stories.js";
 import { HYPOTHESIS_LINKS_TRIES, linksFirst } from "./hypolinks.js";
@@ -153,7 +152,8 @@ export function rankTasks(tree, tasks, strategy = "balanced", opts = {}) {
     const place = (t) => {
         // a task of no research of its own: the direction its people are in (directions.ts), as the menu and the app say
         const map = linesOf(t.research ?? directionOf(tree, t, all));
-        const found = [...t.subject, ...subjectPeople(tree, t.subject)].map((s) => map?.get(s)).filter((x) => !!x);
+        // a family's task: its partners' (a couple's story)
+        const found = [...t.subject, ...aboutPeople(tree, t.subject)].map((s) => map?.get(s)).filter((x) => !!x);
         return found.sort((a, b) => a.gen - b.gen)[0];
     };
     const tasksById = new Map(tree.list("task").map((t) => [t.id, t]));

package/dist/core/stories.js

@@ -6,6 +6,9 @@
 // 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.
+// A couple's story too, once one of the two has a story of their own: their life
+// together alone (the wedding, the household, the homes, the children, the
+// widowhood); what the partners' stories tell is referred to, never told again.
 import { researchPeople } from "./frontier.js";
 import { displayName, familiesAsPartner, lifespan } from "./people.js";
 import { phrase } from "./phrases.js";
@@ -24,6 +27,7 @@ export function forStory(t) {
 }
 const FROM_RECORDS = new Set(["proven", "probable"]);
 const BIRTHS = new Set(["BIRT", "CHR", "BAPM"]);
+const MARRIAGES = new Set(["MARR"]);
 const OPEN = new Set(["open", "doing", "parked", "waiting"]);
 const FINISHED = new Set(["done", "dropped"]);
 /** Enough to tell a life: a birth or baptism from a record, and more facts from records. */
@@ -36,6 +40,23 @@ export function factsFromRecords(tree, p) {
     const marriages = familiesAsPartner(tree, p.id).flatMap((f) => f.events.filter((e) => !e.retracted && FROM_RECORDS.has(e.status)));
     return [...own, ...marriages];
 }
+/**
+ * The facts of a couple's life together that records support: the family's own (the wedding, the homes, …) and the
+ * birth or baptism of each child — and whether they show the couple (a wedding or a child from a record).
+ */
+export function coupleFacts(tree, f) {
+    const own = f.events.filter((e) => !e.retracted && FROM_RECORDS.has(e.status));
+    const births = f.children.flatMap((c) => {
+        const child = tree.get(c.person);
+        const birth = child && !child.retracted ? child.events.find((e) => !e.retracted && FROM_RECORDS.has(e.status) && BIRTHS.has(e.kind)) : undefined;
+        return birth ? [birth] : [];
+    });
+    return { facts: [...own, ...births], shown: births.length > 0 || own.some((e) => MARRIAGES.has(e.kind)) };
+}
+/** Has the person a story of their own — written, or the task of it done? */
+function toldAlone(p, narrate) {
+    return !!p.story || narrate.some((t) => t.state === "done" && t.subject.includes(p.id));
+}
 /** The stories strom proposes to write (or add to) for the ancestors of a research. */
 export function storyProposals(tree, research) {
     const lang = tree.lang;
@@ -43,29 +64,18 @@ export function storyProposals(tree, research) {
     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 people = researchPeople(tree, research);
+    for (const [id, generation] of people) {
         const p = tree.get(id);
         if (!p || p.retracted)
             continue;
         const facts = factsFromRecords(tree, p);
         if (facts.length < STORY_MIN_FACTS || !facts.some((e) => BIRTHS.has(e.kind)))
             continue;
-        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 = 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)))
+        const fresh = due(p, facts, narrate);
+        if (!fresh)
             continue;
         const name = `${displayName(p)}${lifespan(p) ? ` (${lifespan(p)})` : ""}`;
-        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) {
@@ -98,8 +108,60 @@ export function storyProposals(tree, research) {
             research: research.id,
         });
     }
+    // The couples of the research, once one of the two has a story of their own: their life together, the partners'
+    // stories given to the agent as what is told already. The search beyond the registers was each partner's.
+    for (const f of tree.list("family")) {
+        if (f.retracted || f.noCouple || f.partners.length !== 2 || !f.partners.some((x) => people.has(x)))
+            continue;
+        const partners = f.partners.map((x) => tree.get(x));
+        if (partners.some((x) => !x || x.retracted))
+            continue;
+        const [a, b] = partners;
+        if (!toldAlone(a, narrate) && !toldAlone(b, narrate))
+            continue;
+        const { facts, shown } = coupleFacts(tree, f);
+        if (!shown || facts.length < STORY_MIN_FACTS)
+            continue;
+        const fresh = due(f, facts, narrate);
+        if (!fresh)
+            continue;
+        const generation = Math.min(...f.partners.map((x) => people.get(x) ?? Infinity));
+        const names = { a: displayName(a), b: displayName(b) };
+        out.push({
+            level: "narrate",
+            priority: 1, // like a person's: after the research
+            what: phrase(lang, f.story ? "story.couple.more.what" : "story.couple.what", { ...names, count: fresh.length }),
+            where: [phrase(lang, "story.couple.where", { id: f.id }), ...[a, b].filter((x) => x.story).map((x) => phrase(lang, "story.couple.partner", { name: displayName(x), id: x.id }))],
+            why: phrase(lang, "story.couple.why", { count: facts.length, generation, research: research.name }),
+            doneWhen: phrase(lang, "story.couple.done", { id: f.id }),
+            subject: [f.id],
+            research: research.id,
+        });
+    }
     return out;
 }
+/**
+ * The new facts a story of the person or couple is due for — all of them before it is written — or undefined: its task
+ * open, dropped since the story was written (that was the answer), done with no story, or too few new since.
+ */
+function due(rec, facts, narrate) {
+    const mine = narrate.filter((t) => t.subject.includes(rec.id));
+    if (mine.some((t) => OPEN.has(t.state)))
+        return undefined;
+    // The latest version written: a new one waiting beside an approved story, else the story.
+    const latest = rec.story?.draft ?? rec.story;
+    // Dropped since the story was written (or with none): that was the answer — not again until the story changes.
+    const since = latest?.at ?? "";
+    if (mine.some((t) => t.state === "dropped" && t.updated >= since))
+        return undefined;
+    // Done, yet no story: somebody decided so; the user can add the task by hand.
+    if (!rec.story && mine.some((t) => FINISHED.has(t.state)))
+        return undefined;
+    const fresh = latest ? facts.filter((e) => !latest.facts.includes(e.id)) : facts;
+    if (rec.story && fresh.length < STORY_NEW_FACTS)
+        return undefined;
+    return fresh;
+}
 /** 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")]

package/dist/core/tree.js

@@ -29,7 +29,7 @@ export const TREE_FILE = "strom.json";
 export const SEAL_FOREIGN = "seal.foreign";
 // between releases the candidate being made (a bridge run from the sources says what it is: the Strom app goes by it);
 // at a release the release's own (package.json)
-export const VERSION = "1.23.0-beta.3";
+export const VERSION = "1.23.0-beta.4";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.23.0-beta.3",
+  "version": "1.23.0-beta.4",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {