strom-research 1.22.2 → 1.23.0-beta.2

package/CHANGELOG.cs.md

@@ -5,6 +5,24 @@
 Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou na
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (anglicky).
 
+## 1.23.0
+
+*Připravuje se: bety do 1.23.0-beta.2. 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
+  `--clear`), nebo `strom name add --primary`. Volba patří jen uživateli, nikdy se nečte ze záznamu; opravy, citace
+  i synchronizace s aplikací Strom se dál řídí rodným jménem. Soubor pro Strom zvolené jméno označí, standardní soubor
+  GEDCOM ho dá na první místo.
+- **Soubor pro aplikaci Strom bez varování.** Export pro aplikaci Strom varoval před nestandardní značkou u každé
+  osoby se zvoleným jménem a u několika značek zdrojů; kontrola teď zná všechny vlastní značky Stromu.
+- **Commit gitem navrch výzkumu zapečetěného dvěma klíči (Windows).** `strom check` radil zároveň `strom repair` i
+  „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“.
+
 ## 1.22.2
 
 *30. 10. 2026 · patří k aplikaci Strom 3.17.1.*

package/CHANGELOG.de.md

@@ -5,6 +5,28 @@
 Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Installationszeilen stehen bei
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (auf Englisch).
 
+## 1.23.0
+
+*In Vorbereitung: die Betas bis 1.23.0-beta.2. 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
+  hinzukommt: `strom name primary <Person> "<Name>"` (und `--clear`) oder `strom name add --primary`. Die Wahl trifft
+  allein der Nutzer, nie wird sie aus einem Eintrag gelesen; Korrekturen, Zitate und der Abgleich mit der Strom-App
+  richten sich weiter nach dem Geburtsnamen. Die Strom-Datei markiert den gewählten Namen, die Standard-GEDCOM-Datei
+  setzt ihn an die erste Stelle.
+- **Die Datei für die Strom-App ohne Warnungen.** Der Export für die Strom-App warnte bei jeder Person mit gewähltem
+  Namen und bei mehreren Kennzeichen von Quellen vor einem nicht standardisierten Tag; die Prüfung kennt jetzt alle
+  eigenen Tags von Strom.
+- **Ein Commit mit git über einer mit zwei Schlüsseln versiegelten Forschung (Windows).** `strom check` riet zugleich
+  zu `strom repair` und zu „nie `strom repair`“, und `strom repair` machte die mit dem Schlüssel des Terminals
+  geschriebene Arbeit rückgängig. `strom repair` macht jetzt nur rückgängig, was außerhalb von strom geschah, die
+  Arbeit beider Schlüssel bleibt; danach vereint `strom seal adopt` in einem eigenen Terminal die Schlüssel – `strom
+  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“.
+
 ## 1.22.2
 
 *30.10.2026 · gehört zur Strom-App 3.17.1.*

package/CHANGELOG.md

@@ -5,6 +5,24 @@ English · [Čeština](CHANGELOG.cs.md) · [Deutsch](CHANGELOG.de.md)
 The changes of each version in short. The full notes and the install lines are on
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases).
 
+## 1.23.0
+
+*In preparation: the betas up to 1.23.0-beta.2. 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>
+  "<name>"` (and `--clear`), or `strom name add --primary`. The choice is the user's alone, never read from a record;
+  corrections, citations and the sync with the Strom app still go by the birth name. The Strom file marks the chosen
+  name, the standard GEDCOM file gives it first.
+- **The file for the Strom app without warnings.** Exporting for the Strom app warned of a non-standard tag on each
+  person with a chosen name and on several marks of sources; the check now knows every tag of Strom's own.
+- **A commit made with git on top of a research sealed with two keys (Windows).** `strom check` advised `strom repair`
+  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".
+
 ## 1.22.2
 
 *2026-10-30 · goes with the Strom app 3.17.1.*

package/assets/lang/cs.json

@@ -1065,6 +1065,7 @@
   "ui.show.name.married": "po sňatku",
   "ui.show.name.religious": "řeholní",
   "ui.show.name.alias": "jinak též",
+  "ui.show.name.current": "hlavní",
   "ui.show.role.godparent": "kmotr",
   "ui.show.role.witness": "svědek",
   "ui.show.role.officiant": "duchovní",
@@ -1353,7 +1354,10 @@
   "ui.sync.do.name.gone": "odebere se (měly ho jen úpravy v aplikaci nebo jiné rodokmeny)",
   "ui.sync.do.name.kept": "zůstává: dokládá ho záznam",
   "ui.sync.do.name.user": "platí úprava z aplikace: osoba se ukazuje pod novým jménem, jméno ze záznamu zůstane vedle něj",
+  "ui.sync.do.name.shown": "osoba se ukazuje tímto jménem",
+  "ui.sync.do.name.shown.conflict": "rozpor k rozhodnutí (výzkum ho změnil také)",
   "ui.sync.name.title": "{n}. {who}: {title} — {old} → {new}",
+  "ui.sync.name.shown": "{n}. {who}: hlavní jméno — {old} → {new}",
   "ui.sync.do.title": "doplní se ke jménu s odkazem na strom z aplikace",
   "ui.sync.do.title.user": "platí úprava z aplikace (verze výzkumu zůstane v historii)",
   "ui.sync.sex.changed": "{n}. {who}: pohlaví {text}",
@@ -2247,6 +2251,8 @@
   "log.note.edit": "Opravená poznámka: {name}",
   "log.name.retract": "Odvolané jméno: {name} – {who}",
   "log.name.restore": "Vrácené jméno: {name} – {who}",
+  "log.name.primary": "Za hlavní zvoleno jméno: {name} – {who}",
+  "log.name.primary.clear": "Za hlavní zase rodné jméno: {name} – {who}",
   "log.note.retract": "Odvolaná poznámka: {name}",
   "log.note.restore": "Vrácená poznámka: {name}",
   "log.event.status": "Změněná jistota údaje: {who} – {fact}",
@@ -2512,6 +2518,8 @@
   "ui.conflict.sex": "pohlaví",
   "ui.conflict.sex.U": "neznámé",
   "ui.conflict.name": "jméno",
+  "ui.conflict.primary": "hlavní jméno",
+  "ui.conflict.primary.none": "nezvoleno",
   "ui.conflict.titleBefore": "titul před jménem",
   "ui.conflict.titleAfter": "titul za jménem",
   "ui.conflict.parents": "rodiče",
@@ -3101,6 +3109,11 @@
   "ui.check.otherkey": "zapečetěno dvěma klíči stromu na tomto počítači (strom z aplikace a z terminálu): zápisy obou jsou stromu",
   "ui.check.otherkey.hint": "sjednotit ve vlastním terminálu: strom seal adopt – nikdy strom repair",
   "ui.seal.problems": "nepřevzato: záznamy nesedí se svou pečetí – co, řekne strom check",
+  "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.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).",
   "ui.seal.bridge": "výzkum „{name}“ je zapečetěný na jiném počítači: nic se nezapsalo – po převzetí na tomto počítači (terminál: strom seal adopt, nebo nabídka strom) poslat znovu",
   "ui.seal.bridge.twokeys": "výzkum „{name}“ je na tomto počítači zapečetěný dvěma klíči stromu (strom z aplikace a z terminálu): nic se nezapsalo – po sjednocení (terminál: strom seal adopt, nebo nabídka strom) poslat znovu",

package/assets/lang/de.json

@@ -1065,6 +1065,7 @@
   "ui.show.name.married": "nach der Heirat",
   "ui.show.name.religious": "Ordensname",
   "ui.show.name.alias": "auch genannt",
+  "ui.show.name.current": "Hauptname",
   "ui.show.role.godparent": "Pate",
   "ui.show.role.witness": "Zeuge",
   "ui.show.role.officiant": "Geistlicher",
@@ -1353,7 +1354,10 @@
   "ui.sync.do.name.gone": "wird entfernt (nur Änderungen in der App oder andere Stammbäume gaben ihn)",
   "ui.sync.do.name.kept": "bleibt: ein Eintrag belegt ihn",
   "ui.sync.do.name.user": "Die eigene Änderung gilt: die Person erscheint unter dem neuen Namen, der Name aus dem Eintrag bleibt daneben",
+  "ui.sync.do.name.shown": "die Person wird so angezeigt",
+  "ui.sync.do.name.shown.conflict": "ein Widerspruch zum Entscheiden (auch die Forschung hat es geändert)",
   "ui.sync.name.title": "{n}. {who}: {title} — {old} → {new}",
+  "ui.sync.name.shown": "{n}. {who}: Hauptname — {old} → {new}",
   "ui.sync.do.title": "wird dem Namen hinzugefügt, mit Verweis auf den eigenen Stammbaum",
   "ui.sync.do.title.user": "Die eigene Änderung gilt (die der Forschung bleibt in ihrer Geschichte)",
   "ui.sync.sex.changed": "{n}. {who}: Geschlecht {text}",
@@ -2247,6 +2251,8 @@
   "log.note.edit": "Notiz berichtigt: {name}",
   "log.name.retract": "Name zurückgezogen: {name} – {who}",
   "log.name.restore": "Name wiederhergestellt: {name} – {who}",
+  "log.name.primary": "Hauptname: {name} – {who}",
+  "log.name.primary.clear": "Hauptname wieder der Geburtsname: {name} – {who}",
   "log.note.retract": "Notiz zurückgezogen: {name}",
   "log.note.restore": "Notiz wiederhergestellt: {name}",
   "log.event.status": "Sicherheit einer Angabe geändert: {who} – {fact}",
@@ -2512,6 +2518,8 @@
   "ui.conflict.sex": "Geschlecht",
   "ui.conflict.sex.U": "unbekannt",
   "ui.conflict.name": "Name",
+  "ui.conflict.primary": "Hauptname",
+  "ui.conflict.primary.none": "nicht gewählt",
   "ui.conflict.titleBefore": "Titel vor dem Namen",
   "ui.conflict.titleAfter": "Titel nach dem Namen",
   "ui.conflict.parents": "Eltern",
@@ -3101,6 +3109,11 @@
   "ui.check.otherkey": "mit zwei Schlüsseln von strom auf diesem Computer versiegelt (strom aus einer App und aus einem Terminal): was beide schrieben, ist von strom",
   "ui.check.otherkey.hint": "vereinen in einem eigenen Terminal: strom seal adopt – nie strom repair",
   "ui.seal.problems": "nicht übernommen: was im Stammbaum steht, ist nicht so versiegelt, wie strom es schrieb – was, sagt strom check",
+  "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.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).",
   "ui.seal.bridge": "die Forschung „{name}“ ist auf einem anderen Computer versiegelt: nichts wurde geschrieben – nach der Übernahme auf diesem Computer (Terminal: strom seal adopt, oder das Menü von strom) erneut senden",
   "ui.seal.bridge.twokeys": "die Forschung „{name}“ ist auf diesem Computer mit zwei Schlüsseln von strom versiegelt (strom einer App und eines Terminals): nichts wurde geschrieben – nach dem Vereinen (Terminal: strom seal adopt, oder das Menü von strom) erneut senden",

package/dist/brief/brief.js

@@ -116,7 +116,7 @@ function personBlock(tree, p, depth, short = false) {
     const out = [`  ${label(p)} ${p.sex}`];
     // other names, and where any name comes from
     if (p.names.length > 1 || p.names.some((n) => n.citations?.length))
-        out.push(`    names: ${p.names.map((n) => `${formatName(n)}${n.kind ? ` (${n.kind})` : ""}${n.citations?.length ? ` ← ${citesOf(n.citations)}` : ""}`).join("; ")}`);
+        out.push(`    names: ${p.names.map((n) => `${formatName(n)}${n.kind ? ` (${n.kind})` : ""}${n.primary ? " (shown by it)" : ""}${n.citations?.length ? ` ← ${citesOf(n.citations)}` : ""}`).join("; ")}`);
     for (const e of p.events.filter((x) => !x.retracted))
         out.push(eventLine(e));
     const parents = parentsOf(tree, p.id);

package/dist/cli/seal.js

@@ -1,7 +1,8 @@
 // Taking a family tree over on this computer (its seal): strom seal adopt, the menu and the setup go the same way —
 // every record checked against its seal, the person's yes, then this computer's key. Never by itself, never by an agent.
 import { ui } from "./ui.js";
-import { verifyFull } from "../core/integrity.js";
+import { oneWay, verifyFull } from "../core/integrity.js";
+import { settingsHidden } from "../core/oldsettings.js";
 import { createKey, fingerprint, otherKeys } from "../core/seal.js";
 import { sealedHere } from "../core/tree.js";
 /**
@@ -79,7 +80,8 @@ async function uniteSeal(ctx, tree, lang) {
     const others = keysToUnite(tree);
     if (!others.length)
         return { adopted: false, why: "already" };
-    const problems = verifyFull(tree, { trust: others }).findings.filter((f) => f.level === "error");
+    // a change outside strom too: strom repair first (it keeps the work of both keys), then this again
+    const problems = oneWay(verifyFull(tree, { trust: others }).findings.filter((f) => f.level === "error"), () => settingsHidden(tree.env));
     if (problems.length)
         return { adopted: false, why: "problems", problems };
     if (!(await ctx.confirm(ui(lang, "ui.seal.unite.ask", { name: tree.config.name }), true)))

package/dist/cli/ui.js

@@ -889,6 +889,7 @@ export const UI = {
     "ui.show.name.married": "married",
     "ui.show.name.religious": "religious",
     "ui.show.name.alias": "alias",
+    "ui.show.name.current": "current",
     "ui.show.role.godparent": "godparent",
     "ui.show.role.witness": "witness",
     "ui.show.role.officiant": "officiant",
@@ -1318,7 +1319,10 @@ export const UI = {
     "ui.sync.do.name.gone": "taken off (only edits in the app or other family trees gave it)",
     "ui.sync.do.name.kept": "kept: a record gives it",
     "ui.sync.do.name.user": "the edit wins: shown by the new name, the record's kept beside it",
+    "ui.sync.do.name.shown": "the person shown by it",
+    "ui.sync.do.name.shown.conflict": "a conflict to decide (the research changed it too)",
     "ui.sync.name.title": "{n}. {who}: {title} — {old} → {new}",
+    "ui.sync.name.shown": "{n}. {who}: name shown — {old} → {new}",
     "ui.sync.do.title": "added to the name, citing the tree sent",
     "ui.sync.do.title.user": "the edit wins (the research's in its history)",
     "ui.sync.sex.changed": "{n}. {who}: sex {text}",
@@ -2439,6 +2443,8 @@ export const UI = {
     "ui.conflict.sex": "sex",
     "ui.conflict.sex.U": "not known",
     "ui.conflict.name": "name",
+    "ui.conflict.primary": "name shown",
+    "ui.conflict.primary.none": "none chosen",
     "ui.conflict.titleBefore": "title before the name",
     "ui.conflict.titleAfter": "title after the name",
     "ui.conflict.parents": "parents",
@@ -2795,6 +2801,11 @@ export const UI = {
     "ui.check.otherkey": "sealed with two keys of strom on this computer (strom of an app and of a terminal): the writes of both are strom's own",
     "ui.check.otherkey.hint": "united in a terminal of its own: strom seal adopt — never strom repair",
     "ui.seal.problems": "not taken over: records do not match their seals — what, strom check says",
+    "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.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).",
     "ui.seal.bridge": "\"{name}\" was sealed on another computer: nothing was written — once it is taken over on this one (a terminal: strom seal adopt, or strom's menu), send again",
     "ui.seal.bridge.twokeys": "\"{name}\" was sealed with two keys of strom on this computer (strom of an app and of a terminal): nothing was written — once they are united (a terminal: strom seal adopt, or strom's menu), send again",

package/dist/commands/checks.js

@@ -8,8 +8,9 @@ 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 { NOT_DOWNLOADED, OTHER_KEY, SEALED_PATHS, notDownloaded, notDownloadedError, otherKeyError, verifyFast, verifyFull } from "../core/integrity.js";
-import { verifyCommitSeal } from "../core/seal.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 { adoptSeal, keysToUnite } from "../cli/seal.js";
 import { NeedsConsentError, StromError } from "../core/errors.js";
 import * as git from "../core/git.js";
@@ -48,7 +49,7 @@ function hintSaid(f, lang) {
     if (lang && f.code === "foreign-seal")
         return ui(lang, "ui.check.foreignseal.hint");
     if (lang && f.code === OTHER_KEY)
-        return ui(lang, "ui.check.otherkey.hint");
+        return ui(lang, f.hint === AFTER_REPAIR_HINT ? "ui.check.otherkey.afterrepair.hint" : "ui.check.otherkey.hint");
     if (lang && f.code === NOT_DOWNLOADED)
         return ui(lang, "ui.check.notdownloaded.hint");
     if (lang && f.code === SHARED_MISSING)
@@ -156,10 +157,22 @@ function repair(tree) {
     const key = tree.requireKey();
     const stamp = new Date().toISOString().replace(/[:.]/g, "-");
     const head = git.headInfo(tree.root);
-    const sealed = git.findCommit(tree.root, (t, m) => verifyCommitSeal(key, t, m));
+    // 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));
     if (!sealed)
         throw new StromError("no sealed commit found — nothing to restore from", { hint: "ask the user; the history may have been rewritten" });
-    const headSealed = head !== undefined && verifyCommitSeal(key, head.tree, head.message);
+    // 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))
+        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)",
+            code: "seal.repair-in-terminal",
+            params: { name: tree.config.name },
+        });
+    const headSealed = head !== undefined && head.hash === sealed;
     // Paths to compare: whatever differs between the sealed commit and the working tree.
     const candidates = new Set();
     for (const c of git.changes(tree.root, SEALED_PATHS))
@@ -193,7 +206,7 @@ function repair(tree) {
     // commit stays unsealed and every write refused, with nothing left to repair
     if (!headSealed)
         tree.commit(`Repair: restore the sealed state of ${sealed.slice(0, 8)}\n\nCommits made outside strom were undone for data/, strom.json, history/ and quality/.`, SEALED_PATHS, true);
-    return { restored, quarantined, from: sealed };
+    return { restored, quarantined, from: sealed, resealed: !headSealed };
 }
 register({
     path: ["repair"],
@@ -201,15 +214,25 @@ register({
     group: "history",
     tree: true,
     description: "Edited records are restored, records created outside strom are removed; copies of everything\n" +
-        "that was replaced are kept in .strom/quarantine/. Commits made with git directly are undone for data/.",
+        "that was replaced are kept in .strom/quarantine/. Commits made with git directly are undone for data/.\n" +
+        "A tree sealed with two keys of this computer (an app packaged for Windows and a terminal): the work of both kept,\n" +
+        "the keys united after it with strom seal adopt.",
     run(ctx) {
         const tree = ctx.tree();
+        // what a person meets here in the research's language, an agent in English
+        const lang = isAgent(ctx.env) ? "en" : tree.lang;
         const r = tree.withTreeLock(() => repair(tree));
-        const after = verifyFast(tree).findings.filter((f) => f.level === "error");
+        // the work of another key of this computer kept: united next, by the person in their terminal (no problem left of
+        // what strom repair undoes)
+        const after = verifyFast(tree).findings.filter((f) => f.level === "error" && f.code !== OTHER_KEY);
+        const unite = !!tree.key && otherKeys(tree.env, tree.config.id, tree.key).length > 0 && keysToUnite(tree).length > 0;
+        const next = unite ? ui(lang, "ui.repair.unite") : undefined;
         const text = r.restored.length + r.quarantined.length === 0
-            ? "nothing to repair — every record matches its seal"
-            : 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` : undefined);
-        return { text, data: { ...r, ok: after.length === 0 }, exitCode: after.length ? 1 : 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);
+        return { text, data: { ...r, ok: after.length === 0, ...(unite ? { unite: "strom seal adopt" } : {}) }, exitCode: after.length ? 1 : 0 };
     },
 }, {
     path: ["seal", "adopt"],

package/dist/commands/people.js

@@ -3,13 +3,13 @@ import { register } from "../cli/registry.js";
 import { lines, moreLine, paginate, table, truncate } from "../cli/format.js";
 import { suggestionLines, suggestPeople } from "../core/participantlinks.js";
 import { checkStreetPlace } from "../core/streets.js";
-import { addChild, addEvent, addFamily, addName, addNote, addPerson, citeEvent, citeRecord, editEvent, editFamily, editPerson, findEventOwner, mergeFamilies, notRetracted, mergePersons, parseParticipant, retractEvent, retractPerson } from "../core/actions.js";
+import { addChild, addEvent, addFamily, addName, addNote, addPerson, citeEvent, citeRecord, editEvent, editFamily, editPerson, findEventOwner, markPrimaryName, mergeFamilies, notRetracted, mergePersons, parseParticipant, retractEvent, retractPerson } from "../core/actions.js";
 import { listOpt, normId, requireRecord } from "../core/records.js";
 import { SINGLE_KINDS } from "../core/actions.js";
 import { UsageError } from "../core/errors.js";
 import { INFORMATION } from "../core/evidence.js";
 import { EVENT_KINDS, NAME_KINDS } from "../core/model.js";
-import { ancestorGenerations, displayName, familiesAsChild, familiesAsPartner, findPersons, formatName, gedcomName, label, lifespan, parseName, primaryName, relationTo, resolvePerson, sameName, titledName, } from "../core/people.js";
+import { ancestorGenerations, currentName, displayName, familiesAsChild, familiesAsPartner, findPersons, formatName, gedcomName, label, lifespan, parseName, primaryName, relationTo, resolvePerson, sameName, titledName, } from "../core/people.js";
 import { resolveResearch } from "./research.js";
 import { editNote, notesOf, restoreName, restoreNote, retractName, retractNote } from "../core/retractions.js";
 import { DEATH_AFTER_YEARS, unprovenPeople } from "../core/review.js";
@@ -126,7 +126,7 @@ function citesOf(citations, w = ENGLISH) {
 }
 function nameLine(n, w = ENGLISH) {
     const cites = citesOf(n.citations, w);
-    return `${titledName(n)}${n.kind ? ` (${w.word("name", n.kind)})` : ""}${cites ? `  ← ${cites}` : ""}`;
+    return `${titledName(n)}${n.kind ? ` (${w.word("name", n.kind)})` : ""}${n.primary ? ` · ${w.word("name", "current")}` : ""}${cites ? `  ← ${cites}` : ""}`;
 }
 function historyOf(p) {
     const out = [];
@@ -305,7 +305,7 @@ register({
         const who = (x) => (shown.add(x), relative(x, w));
         const out = [
             ...(removed ? [removed.line, ""] : []),
-            `${p.id} ${titledName(primaryName(p))}${lifespan(p) ? ` (${lifespan(p)})` : ""}  ${w.lang ? w.word("sex", p.sex) : `sex ${p.sex}`}`,
+            `${p.id} ${titledName(currentName(p))}${lifespan(p) ? ` (${lifespan(p)})` : ""}  ${w.lang ? w.word("sex", p.sex) : `sex ${p.sex}`}`,
             ...(p.names.length > 1 || p.names.some((n) => n.citations?.length) ? ["", w.say("ui.show.names", "names"), ...p.names.map((n) => `  ${nameLine(n, w)}`)] : []),
             "",
             w.say("ui.show.facts", "facts"),
@@ -426,14 +426,15 @@ register({
     tree: true,
     writes: true,
     description: "A name without a surname (\"Markéta\") is completed by the full one and the person is shown by it; the same\n" +
-        "name again only adds its citation. A woman is shown by her birth name; --kind married keeps the married one aside.",
+        "name again only adds its citation. A woman is shown by her birth name; --kind married keeps the married one aside.\n" +
+        "--primary shows the person by this name from now on (strom name primary marks a name they have already).",
     args: [
         { name: "person", description: "ID (P0001) or name", required: true },
         { name: "name", description: 'the name, surname in slashes: "Markéta /Růžičková/"', required: true },
     ],
     options: [
         { name: "kind", type: "string", value: "<kind>", description: `${NAME_KINDS.join(", ")} (default: plain)` },
-        { name: "primary", type: "boolean", description: "show the person by this name" },
+        { name: "primary", type: "boolean", description: "show the person by this name now (their identity stays the birth name)" },
         ...TITLE_OPTIONS,
         ...CITE_OPTIONS.filter((o) => o.name !== "status"),
     ],
@@ -454,6 +455,34 @@ register({
         const r = addName(tree, p.id, { name: args[1], kind: opts.kind, citation: citationOf(opts), primary: Boolean(opts.primary), prefix: opts.prefix, suffix: opts.suffix });
         return { text: written(tree), data: { person: r.person, name: r.name } };
     },
+}, {
+    path: ["name", "primary"],
+    summary: "Show a person by one of their names now — a divorced woman back at her birth surname — without adding it again",
+    group: "people",
+    tree: true,
+    writes: true,
+    description: "The user's choice, never told from a record (a divorce does not say it): the name is marked, every other name\n" +
+        "stays as it is. person show, lists, the brief, the Strom app show the person by it; their identity — what a\n" +
+        "correction (person edit --name), a citation of the person and pairing go by — stays the birth name. --clear takes\n" +
+        "the mark off: shown by the birth name again (the Strom app: by the married surname, as before).",
+    args: [
+        { name: "person", description: "ID (P0001) or name", required: true },
+        { name: "name", description: 'one of their names, surname in slashes: "Jana /Lhotová/" (none with --clear)' },
+    ],
+    options: [
+        { name: "clear", type: "boolean", description: "take the mark off: no name chosen" },
+    ],
+    examples: ['strom name primary P0002 "Josef /Nowak/"', "strom name primary P0002 --clear"],
+    run(ctx, { args, opts }) {
+        const tree = ctx.tree();
+        const p = resolvePerson(tree, args[0]);
+        if (opts.clear && args[1] !== undefined)
+            throw new UsageError("a name or --clear, not both", { hint: `strom name primary ${p.id} "<Given /Surname/>" · strom name primary ${p.id} --clear` });
+        if (!opts.clear && args[1] === undefined)
+            throw new UsageError("which name?", { hint: `its names: ${p.names.map((n) => `"${gedcomName(n)}"`).join(", ")} · strom name primary ${p.id} "<Given /Surname/>" · --clear` });
+        const r = markPrimaryName(tree, p.id, opts.clear ? undefined : args[1], opts.reason);
+        return { text: written(tree), data: { person: r.person, name: r.name, ...(r.was ? { was: r.was } : {}) } };
+    },
 }, {
     path: ["name", "retract"],
     summary: "Take back a name of a person that turned out wrong (kept with the reason, shown nowhere but in the history)",

package/dist/commands/sync.js

@@ -110,8 +110,8 @@ function changeLine(tree, c, incoming, lang, readings) {
         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),
-        old: c.note ? truncate(c.note.was, 80) : c.title ? truncate(c.title.was, 80) || "—" : c.wasTitle !== undefined ? truncate(c.wasTitle, 80) : shownName(c.wasName),
-        new: c.note ? truncate(c.text ?? "", 80) : c.title || c.wasTitle !== undefined ? truncate(c.text ?? "", 80) || "—" : shownName(c.text),
+        old: c.note ? truncate(c.note.was, 80) : c.title ? truncate(c.title.was, 80) || "—" : c.wasTitle !== undefined ? truncate(c.wasTitle, 80) : c.shown ? shownName(c.wasName) || ui(lang, "ui.conflict.primary.none") : shownName(c.wasName),
+        new: c.note ? truncate(c.text ?? "", 80) : c.title || c.wasTitle !== undefined ? truncate(c.text ?? "", 80) || "—" : c.shown ? shownName(c.text) || ui(lang, "ui.conflict.primary.none") : shownName(c.text),
         title: c.title ? ui(lang, c.title.part === "before" ? "ui.conflict.titleBefore" : "ui.conflict.titleAfter") : "",
         child: name(c.child),
         // a child's tie to each parent: one word for both, else each parent's
@@ -148,30 +148,32 @@ function changeLine(tree, c, incoming, lang, readings) {
                         ? `ui.sync.do.removed${c.action === "conflict" ? ".conflict" : ""}`
                         : c.kind === "name.changed" && c.action === "user"
                             ? "ui.sync.do.name.user"
-                            : c.kind === "name.gone"
-                                ? `ui.sync.do.name.${c.action === "remove" ? "gone" : "kept"}`
-                                : c.kind === "name.title" && (c.action === "add" || c.action === "user")
-                                    ? `ui.sync.do.title${c.action === "user" ? ".user" : ""}`
-                                    : c.kind === "note.changed" && c.action !== "pick"
-                                        ? "ui.sync.do.note.changed"
-                                        : c.kind === "family.union" && c.action !== "report"
-                                            ? "ui.sync.do.family.union"
-                                            : c.kind === "fact.detail" && c.action === "add"
-                                                ? "ui.sync.do.detail"
-                                                : c.kind === "fact.part" && (c.action === "add" || c.action === "user")
-                                                    ? `ui.sync.do.part${c.action === "user" ? ".user" : ""}`
-                                                    : c.kind === "source.title"
-                                                        ? `ui.sync.do.source.title${c.action === "add" ? ".beside" : c.action === "user" ? ".user" : ""}`
-                                                        : c.kind === "source.new" && c.reading?.ok
-                                                            ? `ui.sync.do.source.new.reading${c.reading.edited ? ".edited" : ""}`
-                                                            : c.kind.startsWith("source.") || c.kind === "fact.cite" || c.kind === "person.cite" || c.kind === "family.cite"
-                                                                ? `ui.sync.do.${c.kind}${c.reads || (c.kind === "source.new" && newReads(c, incoming)) ? ".read" : ""}`
-                                                                : c.kind === "fact.new" && c.reads
-                                                                    ? "ui.sync.do.reading"
-                                                                    // a fact on an entry of the research's reading of a document: as sure as its readers read it
-                                                                    : c.kind === "fact.new" && c.fact?.cites?.some((x) => readings?.get(x.source)?.ok)
-                                                                        ? "ui.sync.do.reading.document"
-                                                                        : `ui.sync.do.${c.action}`;
+                            : c.kind === "name.shown"
+                                ? `ui.sync.do.name.shown${c.action === "conflict" ? ".conflict" : ""}`
+                                : c.kind === "name.gone"
+                                    ? `ui.sync.do.name.${c.action === "remove" ? "gone" : "kept"}`
+                                    : c.kind === "name.title" && (c.action === "add" || c.action === "user")
+                                        ? `ui.sync.do.title${c.action === "user" ? ".user" : ""}`
+                                        : c.kind === "note.changed" && c.action !== "pick"
+                                            ? "ui.sync.do.note.changed"
+                                            : c.kind === "family.union" && c.action !== "report"
+                                                ? "ui.sync.do.family.union"
+                                                : c.kind === "fact.detail" && c.action === "add"
+                                                    ? "ui.sync.do.detail"
+                                                    : c.kind === "fact.part" && (c.action === "add" || c.action === "user")
+                                                        ? `ui.sync.do.part${c.action === "user" ? ".user" : ""}`
+                                                        : c.kind === "source.title"
+                                                            ? `ui.sync.do.source.title${c.action === "add" ? ".beside" : c.action === "user" ? ".user" : ""}`
+                                                            : c.kind === "source.new" && c.reading?.ok
+                                                                ? `ui.sync.do.source.new.reading${c.reading.edited ? ".edited" : ""}`
+                                                                : c.kind.startsWith("source.") || c.kind === "fact.cite" || c.kind === "person.cite" || c.kind === "family.cite"
+                                                                    ? `ui.sync.do.${c.kind}${c.reads || (c.kind === "source.new" && newReads(c, incoming)) ? ".read" : ""}`
+                                                                    : c.kind === "fact.new" && c.reads
+                                                                        ? "ui.sync.do.reading"
+                                                                        // a fact on an entry of the research's reading of a document: as sure as its readers read it
+                                                                        : c.kind === "fact.new" && c.fact?.cites?.some((x) => readings?.get(x.source)?.ok)
+                                                                            ? "ui.sync.do.reading.document"
+                                                                            : `ui.sync.do.${c.action}`;
     // an archive: nobody reads a record there, nor is an agent told — said without it
     const said = actsAsArchive(tree) && `${does}.archive` in UI ? `${does}.archive` : does;
     return `${ui(lang, key, v)} → ${ui(lang, said)}`;