strom-research 1.4.1 → 1.5.0

package/assets/lang/cs.json

@@ -259,6 +259,7 @@
   "story.why": "{count} údaje ze zápisů vyprávějí život (generace {generation} výzkumu {research}); rodina si ho přečte v rodinné knize aplikace Strom",
   "story.done": "strom story set {id} se všemi údaji, o které se opírá (--fact) – koncept, dokud ho uživatel neschválí",
   "review.research": "Revize: {name}",
+  "review.unproven.research": "Osoby bez vlastního záznamu",
   "review.more": " (a po nich dalších {count})",
   "review.mentions.what": "Co už rodokmen říká o osobě {name} mimo její údaje: {list}{more}",
   "review.mentions.why": "prameny, poznámky nebo deník osobu {name} jmenují, ale v jejích údajích to není – nejlevnější nálezy revize ({research})",
@@ -290,6 +291,18 @@
   "ui.review.pick": "Kterého?",
   "ui.review.family": "I s manželem či manželkou a dětmi?",
   "ui.review.run": "Nechat na tom agenta pracovat hned, samostatně? (úkolů: {n})",
+  "ui.menu.unproven": "Osoby bez vlastního záznamu ({n})",
+  "ui.unproven.title": "Tyto osoby zatím nedokládá žádný jejich vlastní záznam:",
+  "ui.unproven.named": "jmenuje je jiný záznam",
+  "ui.unproven.leads": "jen vodítka",
+  "ui.unproven.none": "bez záznamu",
+  "ui.unproven.tasks": "už se na nich pracuje",
+  "ui.unproven.living": "Nejspíš žijící (narození před méně než {years} lety) — to ví rodina, bez úkolů: {names}",
+  "ui.unproven.how": "Co má agent udělat?",
+  "ui.unproven.all": "Všechny, postupně (vždy {n} najednou)",
+  "ui.unproven.pick": "Jen ty, které vyberu",
+  "ui.unproven.numbers": "Jejich čísla ze seznamu (např. 1 3 5-7, nebo jejich ID; Enter nebo 0 zpět)",
+  "ui.unproven.bad": "V seznamu není: {x}",
   "ui.o.reread": "druhé čtení",
   "ui.o.reread.offer": "{n} údajů stojí jen na čtení jiným modelem ({models}); uživatel teď čte modelem {model} – jednou to nabídni, jednou větou: strom review <koho> --reread (úkol na osobu; rozhodne uživatel)",
   "ui.o.stories": "vyprávění",
@@ -327,6 +340,7 @@
   "ui.update.downloading": "Stahuji strom {version}…",
   "ui.update.failed": "Aktualizace se nepovedla: {detail}. strom zůstává, jak byl.",
   "ui.update.done": "✓ strom je aktualizovaný: {previous} → {version}.",
+  "ui.update.restart": "strom je aktualizovaný — tahle nabídka ale ještě běží ve staré verzi. Spusťte strom znovu (nebo zástupce „{shortcut}“) a poběží nová verze.",
   "ui.o.update": "aktualizace",
   "ui.o.update.new": "vyšla {version} (tato je {current}) – řekni to uživateli; strom update ji s jeho souhlasem nainstaluje",
   "ui.app.drag": "Aplikace Strom se otevřela. Přetáhněte do jejího okna soubor {file}{shown} – poprvé z něj bude nový rodokmen, příště se tentýž rodokmen aktualizuje. S Chrome nebo Edge na tomto počítači ho strom předá sám.",
@@ -447,6 +461,60 @@
   "ui.browse.plan": "Co agent udělá dál",
   "ui.review.new": "{name} — nových úkolů: {n}",
   "ui.review.nothing": "{name} — nic nového k revizi",
+  "ui.sync.title": "{file}: změn proti výzkumu: {n}",
+  "ui.sync.base": "Porovnáno s tím, co výzkum dal aplikaci Strom ({head}): za vaši úpravu se počítá jen to, co se od té doby změnilo.",
+  "ui.sync.nobase": "Soubor neříká, ze které verze výzkumu je: přidání se berou, rozdíly se jen ukážou (vyberete je přes --only).",
+  "ui.sync.headmissing": "Verzi výzkumu {head}, ze které soubor je, historie nemá: přidání se berou, rozdíly se jen ukážou (vyberete je přes --only).",
+  "ui.sync.partial": "Soubor má mnohem méně osob, než kolik dostal: nic se nebere jako smazané.",
+  "ui.sync.strangers": "Tato ID nepatří osobám toho jména ve výzkumu — berou se jako nové osoby: {ids}",
+  "ui.sync.nothing": "{file}: nic nového — výzkum má všechno, co v něm je.",
+  "ui.sync.person.new": "{n}. nová osoba: {name}",
+  "ui.sync.fact.new": "{n}. {who}: nové — {fact}",
+  "ui.sync.fact.changed": "{n}. {who}: {kind} změněno — {was} → {now}",
+  "ui.sync.fact.differs": "{n}. {who}: {kind} se liší — výzkum {was}, soubor {now}",
+  "ui.sync.fact.gone": "{n}. {who}: už v něm není — {fact}",
+  "ui.sync.name.new": "{n}. {who}: další jméno — {text}",
+  "ui.sync.sex.changed": "{n}. {who}: pohlaví {text}",
+  "ui.sync.note.new": "{n}. {who}: poznámka — „{text}“",
+  "ui.sync.family.new": "{n}. nová rodina: {who}{kids}",
+  "ui.sync.child.new": "{n}. {who}: dítě — {child}",
+  "ui.sync.child.gone": "{n}. {who}: už to není jejich dítě — {child}",
+  "ui.sync.person.gone": "{n}. už v něm není: {name}",
+  "ui.sync.do.add": "přidá se jako vodítko",
+  "ui.sync.do.correct": "opraví vodítko výzkumu",
+  "ui.sync.do.conflict": "rozpor k rozhodnutí (výzkum to má ze záznamu)",
+  "ui.sync.do.user": "platí vaše úprava (údaj ze záznamu se stáhne s důvodem)",
+  "ui.sync.do.pick": "jen když ho vyberete (--only)",
+  "ui.sync.do.report": "nic se nemění — řekněte agentovi, co jste tím mysleli",
+  "ui.sync.edits": "Vaše úpravy údajů doložených záznamem: {mode} (strom config set sync.edits conflict|user)",
+  "ui.sync.mode.conflict": "rozpor k rozhodnutí",
+  "ui.sync.mode.user": "platí vaše úprava",
+  "ui.sync.next": "Zapsat: strom sync {file} --apply · jen některé: --apply --only 1,3",
+  "ui.sync.done": "Zapsáno změn z {file}: {n} ({input}) — vrátit: strom sync undo {input}",
+  "ui.sync.undone": "Synchronizace {input} vrácena: kroků {n}.",
+  "ui.sync.wasundone": "Synchronizace {input} už vrácená je.",
+  "ui.sync.bridge.large": "strom je na poslání moc velký — vyexportujte ho jako GEDCOM a načtěte ho ve výzkumu (strom sync <soubor>)",
+  "ui.sync.bridge.other": "tento strom patří jinému výzkumu",
+  "ui.sync.bridge.foreign": "tohle nevypadá jako rodokmen tohoto výzkumu — vyexportujte ho a načtěte ve výzkumu jako jiný rodokmen",
+  "ui.sync.bridge.empty": "strom přišel prázdný nebo nečitelný",
+  "ui.sync.wait": "Otevírá se aplikace Strom s tímto výzkumem — vyberte v ní, který strom poslat, a potvrďte. Čekám na něj (nejvýš {min} min; Ctrl+C přeruší) …",
+  "ui.sync.waited": "Aplikace Strom strom do {min} min neposlala — zkuste to znovu: strom sync --app, nebo ho vyexportujte jako GEDCOM: strom sync <soubor>",
+  "ui.sync.got": "Aplikace Strom strom poslala.",
+  "ui.sync.nothing.unchanged": "Aplikace Strom nic neposlala: strom se od posledního načtení z výzkumu nezměnil.",
+  "ui.sync.nothing.cancelled": "Z aplikace Strom se nic neposlalo (zrušeno v ní).",
+  "ui.sync.nothing.no-tree": "Aplikace Strom strom tohoto výzkumu nemá — nejdřív ho v ní otevřete (v menu Aplikace Strom), nebo strom vyexportujte a načtěte soubor.",
+  "ui.sync.nosend": "Tato verze aplikace Strom strom ještě poslat neumí (přijde s novější verzí) — vyexportujte ho v aplikaci jako GEDCOM a načtěte: strom sync <soubor>",
+  "ui.sync.from": "Odkud?",
+  "ui.sync.from.app": "Přímo z aplikace Strom (pošle strom sama)",
+  "ui.sync.from.file": "Ze souboru (.ged, .json)",
+  "ui.sync.again": "Tento soubor výzkum už načetl ({input}) — znovu: --again",
+  "ui.sync.source.app": "Úpravy v aplikaci Strom ({file}, {day})",
+  "ui.sync.source.file": "Rodokmen {file} ({day})",
+  "ui.review.living": "{who}: nejspíš žijící (narození před méně než {years} lety, úmrtí nezapsané). Víc ví rodina než matriky a ty z posledních let bývají uzavřené. Přesto revidovat?",
+  "ui.review.living.no": "Nic se nepřidalo.",
+  "ui.review.unproven.none": "Každý ve stromu stojí na vlastním záznamu — nebo pro ty ostatní strom už nemá co navrhnout (strom person list --unproven).",
+  "ui.review.unproven.left": "dalších {n} bez vlastního záznamu: strom review --unproven znovu vezme další, až budou tihle hotoví",
+  "ui.review.unproven.left.human": "Dalších {n} osob čeká bez vlastního záznamu — přijdou na řadu, až budou tihle hotoví.",
   "ui.review.would": "  přidal by: {level} · {what}",
   "ui.review.dry": "(zkouška nanečisto — nic se nezapsalo)",
   "ui.review.covered": "  {name}: už to pokrývá {task} ({state}) — {what}",
@@ -506,10 +574,19 @@
   "ui.consent.hook.on": "Nechat hook „{name}“, aby se dozvídal všechno, co se uloží do vašich výzkumů? Je to program na tomto počítači a udělá s tím, k čemu byl napsán.",
   "ui.consent.hook.off": "Přestat hooku „{name}“ hlásit, co se ukládá?",
   "ui.run.others": "⚠ V tomto rodokmenu už pracuje jiný běh (od {since}): tento si vezme jiné úkoly – náklady se sčítají.",
-  "ui.menu.more": "Rozšířit výzkum: podklady, nový směr, revize osoby",
+  "ui.menu.more": "Rozšířit výzkum: podklady, nový směr, revize osoby, jiný rodokmen",
+  "ui.menu.more.app": "Rozšířit výzkum: podklady, nový směr, revize osoby, úpravy z aplikace Strom",
   "ui.more.title": "Rozšířit výzkum",
   "ui.more.intake": "Přidat podklady: dokumenty, fotky, rodokmen z jiného programu, co víte",
   "ui.more.research": "Nový směr výzkumu: předkové nebo potomci někoho dalšího, nebo jedna otázka",
+  "ui.more.sync": "Načíst úpravy z aplikace Strom nebo z jiného rodokmenu (.ged, .json)",
+  "ui.more.sync.noapp": "Načíst změny z jiného rodokmenu (.ged, .json)",
+  "ui.sync.path.noapp": "Přetáhněte sem soubor s rodokmenem (.ged nebo .json), nebo napište cestu (Enter nebo 0 zpět)",
+  "ui.sync.path": "Přetáhněte sem soubor vyexportovaný z aplikace Strom (.ged nebo .json), nebo napište cestu (Enter nebo 0 zpět)",
+  "ui.sync.how": "Zapsat to do výzkumu?",
+  "ui.sync.all": "Ano, všechno, jak je vypsané",
+  "ui.sync.some": "Jen ty, které vyberu",
+  "ui.sync.app": "Otevřete výzkum znovu v aplikaci Strom (v menu Aplikace Strom): zeptá se, jestli strom aktualizovat — pak v něm budou vaše úpravy tak, jak je výzkum přijal.",
   "ui.intake.what": "Co přinášíte?",
   "ui.intake.files": "Soubory nebo složku z počítače",
   "ui.intake.text": "Co víte – jména, data, místa, rodinné vzpomínky",

package/assets/lang/de.json

@@ -259,6 +259,7 @@
   "story.why": "{count} Angaben aus Einträgen erzählen das Leben (Generation {generation} der Forschung {research}); die Familie liest es im Familienbuch der Strom-App",
   "story.done": "strom story set {id} mit jeder Angabe, auf der sie beruht (--fact) – ein Entwurf, bis der Benutzer sie freigibt",
   "review.research": "Durchsicht: {name}",
+  "review.unproven.research": "Personen ohne eigenen Eintrag",
   "review.more": " (und danach {count} weitere)",
   "review.mentions.what": "Was der Stammbaum außerhalb der Angaben über {name} schon sagt: {list}{more}",
   "review.mentions.why": "Quellen, Notizen oder das Tagebuch nennen {name}, die Angaben zeigen es aber nicht – die günstigsten Funde einer Durchsicht ({research})",
@@ -290,6 +291,18 @@
   "ui.review.pick": "Welche Person?",
   "ui.review.family": "Mit Ehepartner und Kindern?",
   "ui.review.run": "Den Agenten jetzt allein daran arbeiten lassen? ({n} Aufgaben)",
+  "ui.menu.unproven": "Personen ohne eigenen Eintrag ({n})",
+  "ui.unproven.title": "Diese Personen belegt noch kein eigener Eintrag:",
+  "ui.unproven.named": "in einem anderen Eintrag genannt",
+  "ui.unproven.leads": "nur Hinweise",
+  "ui.unproven.none": "kein Eintrag",
+  "ui.unproven.tasks": "daran wird schon gearbeitet",
+  "ui.unproven.living": "Wahrscheinlich lebend (vor weniger als {years} Jahren geboren) — das weiß die Familie, keine Aufgaben: {names}",
+  "ui.unproven.how": "Was soll der Agent tun?",
+  "ui.unproven.all": "Alle, nach und nach (jeweils {n})",
+  "ui.unproven.pick": "Nur die, die ich auswähle",
+  "ui.unproven.numbers": "Ihre Nummern aus der Liste (z. B. 1 3 5-7, oder ihre IDs; Enter oder 0 zurück)",
+  "ui.unproven.bad": "Nicht in der Liste: {x}",
   "ui.o.reread": "zweite Lesung",
   "ui.o.reread.offer": "{n} Angaben beruhen nur auf Lesungen eines anderen Modells ({models}); der Nutzer liest jetzt mit {model} – biete es einmal an, in einem Satz: strom review <wen> --reread (eine Aufgabe je Person; der Nutzer entscheidet)",
   "ui.o.stories": "Geschichten",
@@ -327,6 +340,7 @@
   "ui.update.downloading": "strom {version} wird heruntergeladen…",
   "ui.update.failed": "Die Aktualisierung hat nicht geklappt: {detail}. strom bleibt, wie er war.",
   "ui.update.done": "✓ strom ist aktualisiert: {previous} → {version}.",
+  "ui.update.restart": "strom ist aktualisiert — dieses Menü läuft aber noch in der alten Version. Starten Sie strom neu (oder die Verknüpfung „{shortcut}“), dann läuft die neue Version.",
   "ui.o.update": "Update",
   "ui.o.update.new": "{version} ist da (diese ist {current}) – sag es dem Benutzer; strom update installiert sie mit seiner Zustimmung",
   "ui.app.drag": "Die Strom-App ist geöffnet. Ziehen Sie die Datei {file}{shown} in ihr Fenster – beim ersten Mal wird daraus ein neuer Stammbaum, danach wird derselbe Stammbaum aktualisiert. Mit Chrome oder Edge auf diesem Computer übergibt strom sie selbst.",
@@ -447,6 +461,60 @@
   "ui.browse.plan": "Was der Agent als Nächstes tut",
   "ui.review.new": "{name} — neue Aufgaben: {n}",
   "ui.review.nothing": "{name} — nichts Neues zu prüfen",
+  "ui.sync.title": "{file}: {n} Änderung(en) gegenüber der Forschung",
+  "ui.sync.base": "Verglichen mit dem, was die Forschung der Strom-App gab ({head}): nur was seitdem geändert wurde, gilt als Ihre Änderung.",
+  "ui.sync.nobase": "Die Datei sagt nicht, aus welchem Stand der Forschung sie stammt: Ergänzungen werden übernommen, Unterschiede nur gezeigt (auswählen mit --only).",
+  "ui.sync.headmissing": "Den Stand {head}, den die Datei nennt, hat die Geschichte der Forschung nicht: Ergänzungen werden übernommen, Unterschiede nur gezeigt (auswählen mit --only).",
+  "ui.sync.partial": "Die Datei hat viel weniger Personen, als sie bekam: nichts gilt als gelöscht.",
+  "ui.sync.strangers": "Diese IDs gehören nicht den Personen dieses Namens in der Forschung — als neue Personen übernommen: {ids}",
+  "ui.sync.nothing": "{file}: nichts Neues — die Forschung hat alles, was darin steht.",
+  "ui.sync.person.new": "{n}. neue Person: {name}",
+  "ui.sync.fact.new": "{n}. {who}: neu — {fact}",
+  "ui.sync.fact.changed": "{n}. {who}: {kind} geändert — {was} → {now}",
+  "ui.sync.fact.differs": "{n}. {who}: {kind} weicht ab — Forschung {was}, Datei {now}",
+  "ui.sync.fact.gone": "{n}. {who}: nicht mehr darin — {fact}",
+  "ui.sync.name.new": "{n}. {who}: ein weiterer Name — {text}",
+  "ui.sync.sex.changed": "{n}. {who}: Geschlecht {text}",
+  "ui.sync.note.new": "{n}. {who}: eine Notiz — „{text}“",
+  "ui.sync.family.new": "{n}. eine neue Familie: {who}{kids}",
+  "ui.sync.child.new": "{n}. {who}: ein Kind — {child}",
+  "ui.sync.child.gone": "{n}. {who}: nicht mehr ihr Kind — {child}",
+  "ui.sync.person.gone": "{n}. nicht mehr darin: {name}",
+  "ui.sync.do.add": "als Hinweis übernommen",
+  "ui.sync.do.correct": "berichtigt den Hinweis der Forschung",
+  "ui.sync.do.conflict": "ein Widerspruch zum Entscheiden (die Forschung hat es aus einem Eintrag)",
+  "ui.sync.do.user": "Ihre Änderung gilt (die Angabe aus dem Eintrag wird mit Grund zurückgezogen)",
+  "ui.sync.do.pick": "nur wenn Sie sie auswählen (--only)",
+  "ui.sync.do.report": "nichts ändert sich — sagen Sie dem Agenten, was Sie meinten",
+  "ui.sync.edits": "Ihre Änderungen an Angaben, die ein Eintrag belegt: {mode} (strom config set sync.edits conflict|user)",
+  "ui.sync.mode.conflict": "ein Widerspruch zum Entscheiden",
+  "ui.sync.mode.user": "Ihre Änderung gilt",
+  "ui.sync.next": "Schreiben: strom sync {file} --apply · nur einige: --apply --only 1,3",
+  "ui.sync.done": "{n} Änderung(en) aus {file} geschrieben ({input}) — zurücknehmen: strom sync undo {input}",
+  "ui.sync.undone": "Abgleich {input} zurückgenommen: {n} Schritt(e).",
+  "ui.sync.wasundone": "Abgleich {input} ist schon zurückgenommen.",
+  "ui.sync.bridge.large": "der Stammbaum ist zu groß zum Senden — exportieren Sie ihn als GEDCOM und laden Sie ihn in der Forschung (strom sync <Datei>)",
+  "ui.sync.bridge.other": "dieser Stammbaum gehört zu einer anderen Forschung",
+  "ui.sync.bridge.foreign": "das sieht nicht wie der Stammbaum dieser Forschung aus — exportieren Sie ihn und laden Sie ihn als anderen Stammbaum",
+  "ui.sync.bridge.empty": "der Stammbaum kam leer oder unlesbar an",
+  "ui.sync.wait": "Die Strom-App öffnet sich mit dieser Forschung — wählen Sie dort, welcher Stammbaum gesendet wird, und bestätigen Sie. Warte darauf (höchstens {min} Min.; Strg+C bricht ab) …",
+  "ui.sync.waited": "Die Strom-App hat den Stammbaum nicht innerhalb von {min} Min. gesendet — erneut: strom sync --app, oder als GEDCOM exportieren: strom sync <Datei>",
+  "ui.sync.got": "Die Strom-App hat den Stammbaum gesendet.",
+  "ui.sync.nothing.unchanged": "Die Strom-App sendet nichts: der Stammbaum hat sich seit dem letzten Laden aus der Forschung nicht geändert.",
+  "ui.sync.nothing.cancelled": "Aus der Strom-App wurde nichts gesendet (dort abgebrochen).",
+  "ui.sync.nothing.no-tree": "Die Strom-App hat keinen Stammbaum dieser Forschung — öffnen Sie ihn dort zuerst (Menüpunkt Strom-App) oder exportieren Sie ihn und laden die Datei.",
+  "ui.sync.nosend": "Diese Version der Strom-App kann den Stammbaum noch nicht senden (kommt mit einer neueren Version) — exportieren Sie ihn in der App als GEDCOM und laden Sie ihn: strom sync <Datei>",
+  "ui.sync.from": "Woher?",
+  "ui.sync.from.app": "Direkt aus der Strom-App (sie sendet den Stammbaum selbst)",
+  "ui.sync.from.file": "Aus einer Datei (.ged, .json)",
+  "ui.sync.again": "Diese Datei hat die Forschung schon übernommen ({input}) — noch einmal: --again",
+  "ui.sync.source.app": "Änderungen in der Strom-App ({file}, {day})",
+  "ui.sync.source.file": "Stammbaum {file} ({day})",
+  "ui.review.living": "{who}: wahrscheinlich lebend (vor weniger als {years} Jahren geboren, kein Tod eingetragen). Die Familie weiß mehr als die Register, und die der letzten Jahrzehnte sind meist gesperrt. Trotzdem durchsehen?",
+  "ui.review.living.no": "Nichts hinzugefügt.",
+  "ui.review.unproven.none": "Jede Person im Stammbaum stützt sich auf einen eigenen Eintrag — oder strom hat für die übrigen nichts mehr vorzuschlagen (strom person list --unproven).",
+  "ui.review.unproven.left": "{n} weitere ohne eigenen Eintrag: strom review --unproven nimmt erneut die nächsten, wenn diese erledigt sind",
+  "ui.review.unproven.left.human": "{n} weitere Personen warten ohne eigenen Eintrag — sie kommen dran, wenn diese erledigt sind.",
   "ui.review.would": "  würde hinzufügen: {level} · {what}",
   "ui.review.dry": "(Probelauf — nichts geschrieben)",
   "ui.review.covered": "  {name}: schon abgedeckt durch {task} ({state}) — {what}",
@@ -506,10 +574,19 @@
   "ui.consent.hook.on": "Den Hook „{name}“ über alles informieren, was in Ihre Forschungen gespeichert wird? Er ist ein Programm auf diesem Computer und tut damit, wofür er geschrieben wurde.",
   "ui.consent.hook.off": "Dem Hook „{name}“ nicht mehr melden, was gespeichert wird?",
   "ui.run.others": "⚠ In diesem Stammbaum arbeitet schon ein anderer Lauf (seit {since}): dieser nimmt andere Aufgaben – die Kosten addieren sich.",
-  "ui.menu.more": "Die Forschung erweitern: Unterlagen, eine neue Richtung, eine Person prüfen",
+  "ui.menu.more": "Die Forschung erweitern: Unterlagen, eine neue Richtung, eine Person prüfen, ein anderer Stammbaum",
+  "ui.menu.more.app": "Die Forschung erweitern: Unterlagen, eine neue Richtung, eine Person prüfen, Änderungen aus der Strom-App",
   "ui.more.title": "Die Forschung erweitern",
   "ui.more.intake": "Unterlagen der Familie: Dokumente, Fotos, ein Stammbaum aus einem anderen Programm, was Sie wissen",
   "ui.more.research": "Eine neue Richtung: die Vorfahren oder Nachkommen einer weiteren Person, oder eine Frage",
+  "ui.more.sync": "Änderungen aus der Strom-App oder einem anderen Stammbaum übernehmen (.ged, .json)",
+  "ui.more.sync.noapp": "Änderungen aus einem anderen Stammbaum übernehmen (.ged, .json)",
+  "ui.sync.path.noapp": "Ziehen Sie die Stammbaum-Datei (.ged oder .json) hierher oder geben Sie den Pfad ein (Enter oder 0 zurück)",
+  "ui.sync.path": "Ziehen Sie die aus der Strom-App exportierte Datei (.ged oder .json) hierher oder geben Sie den Pfad ein (Enter oder 0 zurück)",
+  "ui.sync.how": "In die Forschung schreiben?",
+  "ui.sync.all": "Ja, alles wie angezeigt",
+  "ui.sync.some": "Nur die, die ich auswähle",
+  "ui.sync.app": "Öffnen Sie die Forschung erneut in der Strom-App (Menüpunkt Strom-App): Sie fragt, ob der Stammbaum aktualisiert werden soll — dann enthält er Ihre Änderungen, wie die Forschung sie übernommen hat.",
   "ui.intake.what": "Was bringen Sie mit?",
   "ui.intake.files": "Dateien oder einen Ordner von diesem Computer",
   "ui.intake.text": "Was Sie wissen – Namen, Daten, Orte, Erinnerungen der Familie",

package/dist/agents/files.js

@@ -87,7 +87,14 @@ they ask.
   about her", after a new model): \`strom review <whom>\` — strom proposes
   the work as tasks (what the tree already says of them elsewhere, entries to
   read whole, facts to check); tell them how many and what a session costs,
-  and they choose: here with you, or the agent alone.
+  and they choose: here with you, or the agent alone. Several people:
+  \`strom review P… P…\`; those no record of their own proves ("who has no
+  source?"): \`strom person list --unproven\`, then \`strom review --unproven\`
+  (a batch at a time).
+- **Their edits in the Strom app** ("I fixed grandma's birthday in the
+  app", a .ged or .json they exported): \`strom sync <file>\` shows what it
+  would take — tell them, write it on their yes (\`--apply\`); a sync is
+  undone with \`strom sync undo I…\`.
 - **What waits for them** (\`strom\` shows it): tell them plainly what to do
   and where, one thing at a time.
 - **Results and the Strom app**: \`output/tree-strom.ged\` is the family tree

package/dist/cli/menu-parts.js

@@ -32,7 +32,10 @@ export async function subMenu(ctx, lang, build) {
         const i = await ctx.choose(title ?? "", all.map((it) => ({ key: it.key === "0" ? "0" : String(++n), label: it.label })), all.length - 1);
         if (i === undefined)
             return;
-        if ((await guarded(ctx, lang, all[i].act)) === true)
+        const done = await guarded(ctx, lang, all[i].act);
+        if (done === "quit")
+            return "quit";
+        if (done === true)
             return;
     }
 }

package/dist/cli/menu-research.js

@@ -4,9 +4,13 @@
 // agent takes it up in the next conversation or run.
 import fs from "node:fs";
 import path from "node:path";
-import { agentReady, droppedPaths, pause, pickPerson, subMenu, translator } from "./menu-parts.js";
+import { agentReady, droppedPaths, outOfAnswers, pause, pickPerson, subMenu, translator } from "./menu-parts.js";
 import { Tree } from "../core/tree.js";
-import { displayName } from "../core/people.js";
+import { displayName, lifespan } from "../core/people.js";
+import { DEATH_AFTER_YEARS, unprovenPeople } from "../core/review.js";
+import { planSync, readTreeFile, receivedSince } from "../core/sync.js";
+import { appSendsChanges, stromAppState } from "../core/stromapp.js";
+import { UNPROVEN_BATCH } from "../commands/research.js";
 import { expandHome } from "../core/paths.js";
 import { collectFiles } from "../core/media.js";
 import { BOOK_OF_SCANS, IMAGE_EXT } from "../commands/intake.js";
@@ -17,8 +21,15 @@ export async function addToResearch(ctx, run, lang, root) {
             { key: "1", label: t("ui.more.intake"), act: async () => void (await addMaterial(ctx, run, lang, root)) },
             { key: "2", label: t("ui.more.research"), act: async () => void (await newResearch(ctx, run, lang, root)) },
         ];
-        if (Tree.open(root, ctx.env).count("person") > 0)
+        const tree = Tree.open(root, ctx.env);
+        if (tree.count("person") > 0) {
             items.push({ key: "3", label: t("ui.menu.review"), act: async () => void (await reviewPerson(ctx, run, lang, root)) });
+            items.push({ key: "4", label: t(noApp(ctx) ? "ui.more.sync.noapp" : "ui.more.sync"), act: async () => void (await syncTree(ctx, run, lang, root)) });
+        }
+        // only when there are some: the people no record of their own proves — last, it shows only sometimes
+        const unproven = unprovenPeople(tree).filter((u) => !u.living).length;
+        if (unproven)
+            items.push({ key: "5", label: t("ui.menu.unproven", { n: unproven }), act: async () => void (await reviewUnproven(ctx, run, lang, root)) });
         return { title: t("ui.more.title"), items };
     });
 }
@@ -176,6 +187,154 @@ async function newResearch(ctx, run, lang, root) {
     ctx.io.stdout(t("ui.research.done", { name: made.name }) + "\n");
     await offerChat(ctx, run, lang, root, t("ui.research.chat"), t("ui.research.say", { name: made.name }));
 }
+/** The person said no to the Strom app: it is not named. */
+const noApp = (ctx) => stromAppState(ctx.settings) === "no";
+/** A family tree coming back (the Strom app, another program): what changed in it, shown, then written on the person's word. */
+async function syncTree(ctx, run, lang, root) {
+    const t = translator(lang);
+    let file;
+    // straight from the Strom app, where it can send the tree (and the person wants it)
+    if (!noApp(ctx) && appSendsChanges(ctx.settings)) {
+        const from = await ctx.choose(t("ui.sync.from"), [{ label: t("ui.sync.from.app") }, { label: t("ui.sync.from.file") }], 0, { back: t("ui.browse.back") });
+        if (from === undefined)
+            return;
+        if (from === 0) {
+            const since = Date.now();
+            if ((await run(["sync", "--app"])) !== 0)
+                return pause(ctx, lang);
+            file = receivedSince(root, since);
+            if (!file)
+                return pause(ctx, lang);
+            return confirmSync(ctx, run, lang, root, file);
+        }
+    }
+    for (;;) {
+        if (outOfAnswers(ctx))
+            return;
+        const answer = (await ctx.ask(t(noApp(ctx) ? "ui.sync.path.noapp" : "ui.sync.path"))).trim();
+        if (!answer || answer === "0")
+            return;
+        const resolve = (p) => path.resolve(ctx.cwd, expandHome(p, ctx.env));
+        const dropped = droppedPaths(answer).map(resolve);
+        file = [dropped[0], resolve(answer)].find((p) => !!p && fs.existsSync(p) && fs.statSync(p).isFile());
+        if (file)
+            break;
+        ctx.io.stdout(t("ui.intake.missing", { path: answer }) + "\n");
+    }
+    // what it would take, asked first: nothing to write — nothing asked
+    let count;
+    try {
+        const tree = Tree.open(root, ctx.env);
+        count = planSync(tree, readTreeFile(file), ctx.settings.syncEdits(tree.config)).changes.length;
+    }
+    catch {
+        count = 0;
+    }
+    if ((await run(["sync", file])) !== 0 || !count)
+        return pause(ctx, lang);
+    return confirmSync(ctx, run, lang, root, file, count);
+}
+/** What the tree brings is shown: written on the person's word — all, or the ones they pick. */
+async function confirmSync(ctx, run, lang, root, file, known) {
+    const t = translator(lang);
+    let count = known ?? 0;
+    if (known === undefined)
+        try {
+            const tree = Tree.open(root, ctx.env);
+            count = planSync(tree, readTreeFile(file), ctx.settings.syncEdits(tree.config)).changes.length;
+        }
+        catch {
+            count = 0;
+        }
+    if (!count)
+        return pause(ctx, lang);
+    const how = await ctx.choose(t("ui.sync.how"), [{ label: t("ui.sync.all") }, { label: t("ui.sync.some") }], 0, { back: t("ui.browse.back") });
+    if (how === undefined)
+        return;
+    let only = [];
+    if (how === 1) {
+        const picked = await pickNumbers(ctx, lang, Array.from({ length: count }, (_, i) => String(i + 1)));
+        if (!picked?.length)
+            return;
+        only = ["--only", picked.map((i) => i + 1).join(",")];
+    }
+    if ((await run(["sync", file, "--apply", ...only])) === 0 && !noApp(ctx))
+        ctx.io.stdout(t("ui.sync.app") + "\n");
+    await pause(ctx, lang);
+}
+/** The people no record of their own proves: listed, then all of them a batch at a time, or the ones picked by number. */
+async function reviewUnproven(ctx, run, lang, root) {
+    const t = translator(lang);
+    const out = (line) => ctx.io.stdout(line + "\n");
+    const tree = Tree.open(root, ctx.env);
+    const found = unprovenPeople(tree);
+    const all = found.filter((u) => !u.living);
+    const living = found.filter((u) => u.living);
+    const open = tree.list("task").filter((x) => ["open", "doing", "parked", "waiting"].includes(x.state));
+    out(t("ui.unproven.title"));
+    all.forEach((u, i) => {
+        const busy = open.some((x) => x.subject.includes(u.person.id));
+        const life = lifespan(u.person);
+        out(`  ${String(i + 1).padStart(2)}. ${u.person.id} ${displayName(u.person)}${life ? ` (${life})` : ""} — ${t(`ui.unproven.${u.kind}`)}${busy ? ` · ${t("ui.unproven.tasks")}` : ""}`);
+    });
+    if (living.length)
+        out(t("ui.unproven.living", { years: DEATH_AFTER_YEARS, names: living.map((u) => `${u.person.id} ${displayName(u.person)}`).join(", ") }));
+    const how = await ctx.choose(t("ui.unproven.how"), [{ label: t("ui.unproven.all", { n: UNPROVEN_BATCH }) }, { label: t("ui.unproven.pick") }], 0, { back: t("ui.browse.back") });
+    if (how === undefined)
+        return;
+    let argv;
+    if (how === 0)
+        argv = ["review", "--unproven"];
+    else {
+        const picked = await pickNumbers(ctx, lang, all.map((u) => u.person.id));
+        if (!picked?.length)
+            return;
+        argv = ["review", ...picked.map((i) => all[i].person.id)];
+    }
+    if ((await run(argv)) !== 0)
+        return pause(ctx, lang);
+    const after = Tree.open(root, ctx.env);
+    const ids = argv.slice(1).filter((a) => a.startsWith("P"));
+    const research = after
+        .list("research")
+        .find((r) => r.direction === "person" && r.state === "active" && (ids.length ? r.review?.people?.length === ids.length && ids.every((id) => r.review.people.includes(id)) : r.review?.unproven));
+    const waiting = research ? after.list("task").filter((x) => x.research === research.id && x.state === "open").length : 0;
+    if (research && waiting && (await ctx.confirm(t("ui.review.run", { n: waiting }), false)))
+        await run(["run", "--research", research.id, "--max", String(waiting)]);
+    await pause(ctx, lang);
+}
+/** Numbers of a list as a person types them: "1 3 5-7", "2,4", or the IDs shown ("P0012"); each once, in their order. Undefined: back. */
+async function pickNumbers(ctx, lang, ids) {
+    const count = ids.length;
+    const t = translator(lang);
+    for (;;) {
+        const answer = (await ctx.ask(t("ui.unproven.numbers"))).trim();
+        if (!answer || answer === "0")
+            return undefined;
+        const out = [];
+        const bad = [];
+        for (const part of answer.split(/[\s,;]+/u).filter(Boolean)) {
+            const id = ids.indexOf(part.toUpperCase());
+            if (id >= 0) {
+                if (!out.includes(id))
+                    out.push(id);
+                continue;
+            }
+            const m = /^(\d+)(?:\s*[-–]\s*(\d+))?$/u.exec(part);
+            const from = m ? Number(m[1]) : NaN;
+            const to = m?.[2] ? Number(m[2]) : from;
+            if (!m || from < 1 || to > count || to < from)
+                bad.push(part);
+            else
+                for (let i = from; i <= to; i++)
+                    if (!out.includes(i - 1))
+                        out.push(i - 1);
+        }
+        if (!bad.length)
+            return out;
+        ctx.io.stdout(t("ui.unproven.bad", { x: bad.join(", ") }) + "\n");
+    }
+}
 /** One person, looked at again: what the tree says of them elsewhere, what to read whole, what to check. */
 async function reviewPerson(ctx, run, lang, root) {
     const t = translator(lang);
@@ -186,7 +345,7 @@ async function reviewPerson(ctx, run, lang, root) {
     if ((await run(["review", person.id, ...(family ? ["--scope", "family"] : [])])) !== 0)
         return pause(ctx, lang);
     const tree = Tree.open(root, ctx.env);
-    const research = tree.list("research").find((r) => r.direction === "person" && r.focus === person.id && r.review);
+    const research = tree.list("research").find((r) => r.direction === "person" && r.focus === person.id && r.review && !r.review.people);
     const open = research ? tree.list("task").filter((x) => x.research === research.id && x.state === "open").length : 0;
     if (research && open && (await ctx.confirm(t("ui.review.run", { n: open }), false)))
         await run(["run", "--research", research.id, "--max", String(open)]);

package/dist/cli/menu-settings.js

@@ -5,7 +5,9 @@
 // the person at the terminal does, through the ordinary commands.
 import path from "node:path";
 import { claudeHere, pause, subMenu, translator } from "./menu-parts.js";
-import { Tree } from "../core/tree.js";
+import { Tree, VERSION } from "../core/tree.js";
+import { replacedOnDisk } from "../core/self.js";
+import { shortcutName } from "./wizard.js";
 import { DEFAULT_RUN_MINUTES } from "../core/config.js";
 import { askGate, ensureGatesDir, listGates, loadGate } from "../core/gate.js";
 import { ensureHooksDir, hooksDir, listHooks } from "../core/hooks.js";
@@ -16,7 +18,7 @@ import { loadLogins } from "../core/logins.js";
 import { claudeRemoteAtStartup } from "../agents/global.js";
 export async function settingsMenu(ctx, run, lang, root, newer) {
     const t = translator(lang);
-    await subMenu(ctx, lang, () => {
+    return subMenu(ctx, lang, () => {
         ctx.settings.reload();
         const shared = ctx.settings.shared()?.value;
         const tree = root ? Tree.open(root, ctx.env).config : undefined;
@@ -62,7 +64,19 @@ export async function settingsMenu(ctx, run, lang, root, newer) {
             });
         }
         if (newer)
-            items.push({ key: "7", label: t("ui.menu.update", { version: newer }), act: async () => void (await run(["update"])) });
+            items.push({
+                key: "7",
+                label: t("ui.menu.update", { version: newer }),
+                act: async () => {
+                    if ((await run(["update"])) !== 0)
+                        return;
+                    // this menu is still the old strom: the new one starts with the next strom
+                    if (!replacedOnDisk(VERSION))
+                        return;
+                    ctx.io.stdout(t("ui.update.restart", { shortcut: shortcutName(lang) }) + "\n");
+                    return "quit";
+                },
+            });
         return { title: t("ui.settings.title"), items };
     });
 }

package/dist/cli/menu.js

@@ -219,7 +219,8 @@ export async function runMenu(ctx, run) {
                 },
             }, {
                 key: "4",
-                label: t("ui.menu.more"),
+                // the Strom app named only for someone who has not said no to it
+                label: t(stromAppState(ctx.settings) === "no" ? "ui.menu.more" : "ui.menu.more.app"),
                 act: async () => addToResearch(ctx, run, lang, root),
             }, {
                 key: "4",
@@ -283,7 +284,7 @@ export async function runMenu(ctx, run) {
         if (i === undefined)
             return;
         const quit = await guarded(ctx, lang, items[i].act);
-        if (quit === true) {
+        if (quit === true || quit === "quit") {
             out(t("ui.menu.bye"));
             return;
         }