strom-research 1.23.0-beta.2 → 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.2. 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
@@ -20,8 +20,21 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   „nikdy `strom repair`“ a `strom repair` vrátil zpět práci zapsanou klíčem terminálu. `strom repair` teď vrací jen
   to, co se udělalo mimo strom, práce obou klíčů zůstává; potom klíče sjednotí `strom seal adopt` ve vlastním
   terminálu – `strom check` říká oba kroky v tomto pořadí. Spuštěný z aplikace agenta balené pro Windows nechá `strom
-  repair` takový výzkum beze změny a odkáže na terminál. Po commitu gitem, který nezměnil žádný záznam, `strom repair`
-  řekne, že výzkum znovu zapečetil, už ne „nothing to repair“.
+  repair` takový výzkum beze změny a odkáže na terminál; odmítnutý zápis tam odkáže na terminál také, už ne nejdřív
+  na `strom repair`. Po commitu gitem, který nezměnil žádný záznam, `strom repair` řekne, že výzkum znovu zapečetil,
+  už ne „nothing to repair“.
+- **Pečetní klíč i tam, kde ho hledá starší strom (Windows).** Klíč převzatý z kopie aplikace balené pro Windows se
+  teď ukládá i do `%APPDATA%\strom\keys`, kde ho hledá strom 1.22.1 nebo starší v terminálu: po návratu ke starší verzi
+  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.
 
 ## 1.22.2
 

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.2. 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
@@ -25,7 +25,22 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   check` nennt beide Schritte in dieser Reihenfolge. Aus der für Windows paketierten Desktop-App eines Agenten
   gestartet, lässt `strom repair` eine solche Forschung unverändert und verweist auf das Terminal. Nach einem Commit
   mit git, der keinen Eintrag änderte, sagt `strom repair`, dass es die Forschung neu versiegelt hat, nicht mehr
-  „nothing to repair“.
+  „nothing to repair“. Ein dort abgelehnter Schreibvorgang verweist ebenfalls auf das Terminal, nicht mehr zuerst auf
+  `strom repair`.
+- **Der Siegelschlüssel auch dort, wo ein älteres strom sucht (Windows).** Ein aus der Kopie einer für Windows
+  paketierten App übernommener Schlüssel liegt jetzt auch in `%APPDATA%\strom\keys`, wo ihn strom 1.22.1 oder älter
+  im Terminal sucht: zurück bei einer älteren Version bleibt die Forschung auf diesem Computer versiegelt. Ein Schlüssel,
+  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.
 
 ## 1.22.2
 

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.2. 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>
@@ -20,8 +20,22 @@ The changes of each version in short. The full notes and the install lines are o
   and never `strom repair` at once, and `strom repair` undid the work written with the terminal's key. `strom repair`
   now undoes only what was done outside strom, the work of both keys stays; then `strom seal adopt` in a terminal
   unites the keys — `strom check` says the two steps in this order. Started by an agent's desktop app packaged for
-  Windows, `strom repair` leaves such a research as it is and points to the terminal. After a commit made with git
-  that changed no record, `strom repair` says it sealed the research again, no longer "nothing to repair".
+  Windows, `strom repair` leaves such a research as it is and points to the terminal; a write refused there points to
+  the terminal too, no longer to `strom repair` first. After a commit made with git that changed no record, `strom
+  repair` says it sealed the research again, no longer "nothing to repair".
+- **The seal key also where an older strom looks (Windows).** A key taken over from the copy of an app packaged for
+  Windows is now kept in `%APPDATA%\strom\keys` too, where a terminal's strom 1.22.1 or older looks for it: back on an
+  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.
 
 ## 1.22.2
 

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í",
@@ -1956,6 +1962,7 @@
   "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.what.story.couple": "schválit vyprávění páru {couple}, jak je (už nebude návrh).",
   "ui.link.story.done": "✓ Vyprávění je schválené. Po novém otevření výzkumu v aplikaci Strom tam bude bez štítku Návrh.",
   "ui.link.sync.none": "{input} není v tomto výzkumu poslání z aplikace Strom. Nic se nestalo.",
   "ui.link.sync.was": "Toto poslání už bylo vráceno.",
@@ -3112,6 +3119,11 @@
   "ui.check.otherkey.afterrepair.hint": "po strom repair sjednotit ve vlastním terminálu: strom seal adopt",
   "ui.repair.resealed": "znovu zapečetěno – commit udělaný mimo strom nezměnil žádný záznam",
   "ui.repair.unite": "dál: sjednotit klíče stromu na tomto počítači ve vlastním terminálu: strom seal adopt",
+  "ui.repair.nothing": "není co opravit – každý záznam odpovídá své pečeti",
+  "ui.repair.restored": "obnoveno  {file}",
+  "ui.repair.removed": "odebráno  {file}",
+  "ui.repair.from": "zapečetěný stav: {commit} · kopie nahrazených souborů: .strom/quarantine/",
+  "ui.repair.still": "{n, plural, one {zbývá # problém} few {zbývají # problémy} other {zbývá # problémů}} → strom verify",
   "ui.error.seal.repair-in-terminal": "výzkum „{name}“ obsahuje práci zapečetěnou klíčem stromu z terminálu, který strom spuštěný z aplikace nevidí: nic se neopravilo",
   "ui.error.seal.repair-in-terminal.hint": "ve vlastním terminálu: strom repair, pak strom seal adopt – ten vidí oba klíče a vrátí jen to, co se udělalo mimo strom",
   "ui.menu.seal": "Zapečetěno na jiném počítači: zapisovat tu jde až po převzetí (strom seal adopt).",

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",
@@ -1956,6 +1962,7 @@
   "ui.link.story.none": "{person} hat noch keine Erzählung. Es ist nichts geschehen.",
   "ui.link.story.final": "Die Erzählung von {person} ist bereits freigegeben.",
   "ui.link.what.story": "die Erzählung von {person} so freigeben, wie sie ist (dann kein Entwurf mehr).",
+  "ui.link.what.story.couple": "die Erzählung des Paares {couple} so freigeben, wie sie ist (dann kein Entwurf mehr).",
   "ui.link.story.done": "✓ Die Erzählung ist freigegeben. Wird die Forschung in der Strom-App erneut geöffnet, steht sie ohne das Etikett Entwurf da.",
   "ui.link.sync.none": "{input} ist in dieser Forschung keine Sendung aus der Strom-App. Es ist nichts geschehen.",
   "ui.link.sync.was": "Diese Sendung wurde bereits zurückgenommen.",
@@ -3112,6 +3119,11 @@
   "ui.check.otherkey.afterrepair.hint": "nach strom repair vereinen in einem eigenen Terminal: strom seal adopt",
   "ui.repair.resealed": "neu versiegelt – der Commit außerhalb von strom änderte keinen Eintrag",
   "ui.repair.unite": "weiter: die Schlüssel von strom auf diesem Computer vereinen in einem eigenen Terminal: strom seal adopt",
+  "ui.repair.nothing": "nichts zu reparieren – jeder Eintrag stimmt mit seiner Versiegelung überein",
+  "ui.repair.restored": "wiederhergestellt  {file}",
+  "ui.repair.removed": "entfernt           {file}",
+  "ui.repair.from": "versiegelter Stand: {commit} · Kopien ersetzter Dateien: .strom/quarantine/",
+  "ui.repair.still": "noch {n, plural, one {# Problem} other {# Probleme}} → strom verify",
   "ui.error.seal.repair-in-terminal": "die Forschung „{name}“ enthält Arbeit, versiegelt mit dem Schlüssel des strom aus dem Terminal, den ein aus einer App gestartetes strom nicht sieht: nichts wurde repariert",
   "ui.error.seal.repair-in-terminal.hint": "in einem eigenen Terminal: strom repair, dann strom seal adopt – es sieht beide Schlüssel und macht nur rückgängig, was außerhalb von strom geschah",
   "ui.menu.seal": "Auf einem anderen Computer versiegelt: schreiben hier erst nach der Übernahme (strom seal adopt).",

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/cli/menu-links.js

@@ -442,7 +442,9 @@ export async function approveStory(ctx, run, lang, root, person, who, how = "fin
     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, ""), ""));
-    if (!(await asks(ctx, lang, root, t("ui.link.what.story", { person: who }))))
+    // a couple's story said as the couple's, never as a person's
+    const what = person.type === "family" ? t("ui.link.what.story.couple", { couple: who }) : t("ui.link.what.story", { person: who });
+    if (!(await asks(ctx, lang, root, what)))
         return false;
     if ((await run(["story", "approve", person.id], true)) !== 0)
         return false;

package/dist/cli/ui.js

@@ -1930,6 +1930,7 @@ export const UI = {
     "ui.link.story.none": "{person} has no story yet. Nothing was done.",
     "ui.link.story.final": "The story of {person} is approved already.",
     "ui.link.what.story": "approve the story of {person} as it is (it will no longer be a draft).",
+    "ui.link.what.story.couple": "approve the story of the couple {couple} as it is (it will no longer be a draft).",
     "ui.link.story.done": "✓ The story is approved. Open the research in the Strom app again and it is there without the draft label.",
     "ui.link.sync.none": "{input} is not a sending from the Strom app in this research. Nothing was done.",
     "ui.link.sync.was": "This sending was taken back already.",
@@ -2804,6 +2805,11 @@ export const UI = {
     "ui.check.otherkey.afterrepair.hint": "after strom repair, united in a terminal of its own: strom seal adopt",
     "ui.repair.resealed": "sealed again — the commit made outside strom changed no record",
     "ui.repair.unite": "next: the keys of strom on this computer united in a terminal of its own: strom seal adopt",
+    "ui.repair.nothing": "nothing to repair — every record matches its seal",
+    "ui.repair.restored": "restored  {file}",
+    "ui.repair.removed": "removed   {file}",
+    "ui.repair.from": "sealed state: {commit} · copies of replaced files: .strom/quarantine/",
+    "ui.repair.still": "still {n, plural, one {# problem} other {# problems}} → strom verify",
     "ui.error.seal.repair-in-terminal": "\"{name}\" holds work sealed with the key of the terminal's strom, which a strom started by an app cannot see: nothing repaired",
     "ui.error.seal.repair-in-terminal.hint": "in a terminal of its own: strom repair, then strom seal adopt — it sees both keys and undoes only what was done outside strom",
     "ui.menu.seal": "Sealed on another computer: writing here only once taken over (strom seal adopt).",

package/dist/commands/checks.js

@@ -8,9 +8,8 @@ import { counted, lines, table } from "../cli/format.js";
 import { check, SHARED_MISSING, sharedMissing } from "../core/check.js";
 import { guard } from "../core/guard.js";
 import { unprovenPeople } from "../core/review.js";
-import { AFTER_REPAIR_HINT, NOT_DOWNLOADED, OTHER_KEY, SEALED_PATHS, notDownloaded, notDownloadedError, otherKeyError, verifyFast, verifyFull } from "../core/integrity.js";
-import { otherKeys, readCommitSeal, verifyCommitSeal } from "../core/seal.js";
-import { settingsHidden } from "../core/oldsettings.js";
+import { AFTER_REPAIR_HINT, NOT_DOWNLOADED, OTHER_KEY, REPAIR_IN_TERMINAL_HINT, SEALED_PATHS, lastSealed, notDownloaded, notDownloadedError, otherKeyError, verifyFast, verifyFull } from "../core/integrity.js";
+import { otherKeys } from "../core/seal.js";
 import { adoptSeal, keysToUnite } from "../cli/seal.js";
 import { NeedsConsentError, StromError } from "../core/errors.js";
 import * as git from "../core/git.js";
@@ -157,18 +156,14 @@ function repair(tree) {
     const key = tree.requireKey();
     const stamp = new Date().toISOString().replace(/[:.]/g, "-");
     const head = git.headInfo(tree.root);
-    // the newest commit any key of this computer sealed (strom of an app packaged for Windows and of a terminal each had
-    // their own): only what was done outside strom undone, the other key's work kept — strom seal adopt unites them after
-    const keys = [key, ...otherKeys(tree.env, tree.config.id, key).map((o) => o.key)];
-    const above = [];
-    const sealed = git.findCommit(tree.root, (t, m) => keys.some((k) => verifyCommitSeal(k, t, m)) || (above.push(m), false));
+    // the newest commit any key of this computer sealed: only what was done outside strom undone, the other key's work
+    // kept — strom seal adopt unites them after
+    const { sealed, inTerminal } = lastSealed(tree, key);
     if (!sealed)
         throw new StromError("no sealed commit found — nothing to restore from", { hint: "ask the user; the history may have been rewritten" });
-    // started by an app packaged for Windows: a commit above it with strom's seal may be the terminal's key out of its
-    // sight — never undone from here, the terminal's strom sees both keys
-    if (above.some((m) => readCommitSeal(m) !== undefined) && settingsHidden(tree.env))
+    if (inTerminal)
         throw new StromError(`"${tree.config.name}" holds work sealed with the key of the terminal's strom, which this strom (started by an app packaged for Windows) does not see — nothing repaired`, {
-            hint: "the user runs in their terminal: strom repair, then strom seal adopt   (it sees both keys and undoes only what was done outside strom)",
+            hint: REPAIR_IN_TERMINAL_HINT,
             code: "seal.repair-in-terminal",
             params: { name: tree.config.name },
         });
@@ -230,8 +225,8 @@ register({
         const text = r.restored.length + r.quarantined.length === 0
             ? r.resealed
                 ? lines(ui(lang, "ui.repair.resealed"), next)
-                : lines("nothing to repair — every record matches its seal", next)
-            : lines(...r.restored.map((f) => `restored  ${f}`), ...r.quarantined.map((f) => `removed   ${f}`), `sealed state: ${r.from.slice(0, 8)} · copies of replaced files: .strom/quarantine/`, after.length ? `still ${counted(after.length, "problem")} → strom verify` : next);
+                : lines(ui(lang, "ui.repair.nothing"), next)
+            : lines(...r.restored.map((file) => ui(lang, "ui.repair.restored", { file })), ...r.quarantined.map((file) => ui(lang, "ui.repair.removed", { file })), ui(lang, "ui.repair.from", { commit: r.from.slice(0, 8) }), after.length ? ui(lang, "ui.repair.still", { n: after.length }) : next);
         return { text, data: { ...r, ok: after.length === 0, ...(unite ? { unite: "strom seal adopt" } : {}) }, exitCode: after.length ? 1 : 0 };
     },
 }, {

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/integrity.js

@@ -484,6 +484,19 @@ export function writableUnasked(tree) {
         return false;
     }
 }
+/**
+ * The newest commit any key of this computer sealed (strom of an app packaged for Windows and of a terminal each had
+ * their own), and whether strom repair is the terminal's: started by such an app, a commit above it with strom's seal may
+ * be the terminal's key out of its sight — never undone from here, the terminal's strom sees both keys.
+ */
+export function lastSealed(tree, key) {
+    const keys = [key, ...otherKeys(tree.env, tree.config.id, key).map((o) => o.key)];
+    const above = [];
+    const sealed = git.findCommit(tree.root, (t, m) => keys.some((k) => verifyCommitSeal(k, t, m)) || (above.push(m), false));
+    return { sealed, inTerminal: !!sealed && above.some((m) => readCommitSeal(m) !== undefined) && settingsHidden(tree.env) };
+}
+/** What strom repair started by an app packaged for Windows says instead (lastSealed inTerminal). */
+export const REPAIR_IN_TERMINAL_HINT = "the user runs in their terminal: strom repair, then strom seal adopt   (it sees both keys and undoes only what was done outside strom)";
 /** Refuse to write on top of data that was changed outside strom. */
 export function assertIntact(tree) {
     const { findings } = verifyFast(tree);
@@ -498,8 +511,15 @@ export function assertIntact(tree) {
     // files only in iCloud: downloaded first — what else is wrong is judged then
     if (errors.some((f) => f.code === NOT_DOWNLOADED))
         throw notDownloadedError(notDownloaded(tree.root));
+    // with another key of this computer: the one way strom check says (oneWay); started by an app packaged for Windows
+    // above the terminal's work, strom repair in the terminal — never first the app's own, which refuses (found 2026-10-30)
+    const way = errors.some((f) => f.code === OTHER_KEY)
+        ? errors.find((f) => f.code !== OTHER_KEY && f.hint?.endsWith("then strom seal adopt"))?.hint
+        : tree.key && errors.some((f) => f.code === "foreign-commit") && lastSealed(tree, tree.key).inTerminal
+            ? REPAIR_IN_TERMINAL_HINT
+            : undefined;
     throw new StromError(`data was changed outside strom (${counted(errors.length, "problem")}) — refusing to write`, {
-        hint: "strom verify   (details)\nstrom repair   (restore the last sealed state)",
+        hint: `strom verify   (details)\n${way ?? "strom repair   (restore the last sealed state)"}`,
         details: errors,
     });
 }

package/dist/core/oldsettings.js

@@ -12,6 +12,18 @@ import path from "node:path";
 import { configDir, userHome } from "./paths.js";
 import { writesPrivately } from "./packaged.js";
 import { installation } from "./self.js";
+/**
+ * %APPDATA%\strom alone, as this process sees it (oldSettingsDirs' first), without looking through the packaged apps:
+ * where an older strom looks for its keys.
+ */
+export function oldSettingsDir(env, platform = process.platform, inst = installation()) {
+    if (inst.kind === "source" && env.STROM_TEST_OLD_SETTINGS !== undefined)
+        return env.STROM_TEST_OLD_SETTINGS.split(path.delimiter).filter(Boolean)[0];
+    if (env.STROM_CONFIG_DIR || platform !== "win32")
+        return undefined;
+    const home = env.USERPROFILE || userHome(env);
+    return path.join(env.APPDATA || path.join(home, "AppData", "Roaming"), "strom");
+}
 /**
  * The folders strom kept its settings in before, as this process sees them: %APPDATA%\strom first (in a packaged app
  * its private copy where there is one, else the real one), then each packaged app's copy, read by its path. None with
@@ -21,10 +33,10 @@ import { installation } from "./self.js";
 export function oldSettingsDirs(env, platform = process.platform, inst = installation()) {
     if (inst.kind === "source" && env.STROM_TEST_OLD_SETTINGS !== undefined)
         return env.STROM_TEST_OLD_SETTINGS.split(path.delimiter).filter(Boolean);
-    if (env.STROM_CONFIG_DIR || platform !== "win32")
+    const roaming = oldSettingsDir(env, platform, inst);
+    if (!roaming)
         return [];
     const home = env.USERPROFILE || userHome(env);
-    const roaming = path.join(env.APPDATA || path.join(home, "AppData", "Roaming"), "strom");
     const packages = path.join(env.LOCALAPPDATA || path.join(home, "AppData", "Local"), "Packages");
     let apps = [];
     try {

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/seal.js

@@ -16,7 +16,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { configDir } from "./paths.js";
 import { canonicalize } from "./json.js";
-import { oldKeys, oldSettingsDirs } from "./oldsettings.js";
+import { oldKeys, oldSettingsDir } from "./oldsettings.js";
 export function sha256(content) {
     return crypto.createHash("sha256").update(content).digest("hex");
 }
@@ -51,8 +51,10 @@ export function loadKey(env, treeId) {
  */
 export function settleKey(env, treeId, prefer) {
     const own = readKey(keyFile(env, treeId));
-    if (own)
+    if (own) {
+        mirrorKey(env, treeId, own);
         return own;
+    }
     const old = oldKeys(env, treeId);
     if (!old.length)
         return undefined;
@@ -65,8 +67,29 @@ export function settleKey(env, treeId, prefer) {
     catch {
         // taken over next time
     }
+    mirrorKey(env, treeId, key);
     return key;
 }
+/**
+ * The key also where an older strom looks (Windows: %APPDATA%\strom\keys), made if need be — back on an older version,
+ * the research is still sealed here. Only added: a key of its own there already stays (found 2026-10-30: a key taken
+ * from a packaged app's copy, never in the folder the terminal's older strom reads).
+ */
+function mirrorKey(env, treeId, key) {
+    const old = oldSettingsDir(env);
+    if (!old)
+        return;
+    const file = path.join(old, "keys", `${treeId}.key`);
+    if (fs.existsSync(file))
+        return;
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, key.toString("hex") + "\n", { mode: 0o600, flag: "wx" });
+    }
+    catch {
+        // a key of its own there already: the older strom keeps it
+    }
+}
 /** The tree's other keys on this computer: those of the old settings folders that are not `key` (strom seal adopt unites them). */
 export function otherKeys(env, treeId, key) {
     return oldKeys(env, treeId).filter((o) => !o.key.equals(key));
@@ -80,18 +103,7 @@ export function createKey(env, treeId) {
     fs.mkdirSync(path.dirname(file), { recursive: true });
     const key = crypto.randomBytes(32);
     fs.writeFileSync(file, key.toString("hex") + "\n", { mode: 0o600, flag: "wx" });
-    // also where an older strom looks (Windows: %APPDATA%\strom), made if need be — back on an older version, the research
-    // is still sealed here
-    const old = oldSettingsDirs(env)[0];
-    if (old) {
-        try {
-            fs.mkdirSync(path.join(old, "keys"), { recursive: true });
-            fs.writeFileSync(path.join(old, "keys", `${treeId}.key`), key.toString("hex") + "\n", { mode: 0o600, flag: "wx" });
-        }
-        catch {
-            // a key of its own there already: the older strom keeps it
-        }
-    }
+    mirrorKey(env, treeId, key);
     return key;
 }
 /** Short public fingerprint of a key, stored on each operation. */

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.2";
+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.2",
+  "version": "1.23.0-beta.4",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {