strom-research 1.5.0 → 1.6.0

package/assets/lang/cs.json

@@ -38,6 +38,7 @@
   "ui.yes": "a",
   "ui.no": "n",
   "ui.enter": "Stiskněte Enter pro návrat do nabídky.",
+  "ui.enter.close": "Stiskněte Enter pro zavření okna.",
   "ui.choose": "Vyberte",
   "ui.bad.choice": "Napište prosím jedno z čísel.",
   "ui.dialog.title": "Strom výzkum",
@@ -109,6 +110,8 @@
   "ui.setup.level.sure": "Opravdu povolit všechno?",
   "ui.setup.shortcut": "Vytvořit na ploše zástupce „Strom výzkum“?",
   "ui.setup.shortcut.done": "✓ Zástupce: {file}",
+  "ui.setup.links": "Dovolit aplikaci Strom spouštět výzkum na tomto počítači? (Jedním klikem pošle úpravy zpět, otevře výřez v plné kvalitě, agenta nebo prověření osoby – vždy se tu nejdřív zeptá.)",
+  "ui.setup.links.done": "✓ Odkazy z aplikace Strom vedou do výzkumu na tomto počítači.",
   "ui.setup.skill": "✓ {agent} teď strom zná v jakékoli složce.",
   "ui.setup.app": "✓ Na počítači je aplikace Strom – menu v ní otevře výzkum, a když agent pracuje, aplikace ho sleduje živě.",
   "ui.setup.done": "Hotovo.",
@@ -199,6 +202,10 @@
   "ui.doc.level": "agent smí",
   "ui.doc.model": "model",
   "ui.doc.shortcut": "zástupce na ploše",
+  "ui.doc.links": "odkazy z aplikace Strom",
+  "ui.doc.links.ours": "ano",
+  "ui.doc.links.other": "vedou do jiného programu (nebo tam, kde strom býval)",
+  "ui.doc.links.none": "žádné",
   "ui.doc.app": "aplikace Strom",
   "ui.doc.tree": "tento rodokmen",
   "ui.doc.innode": "strom {version} v Node {node}",
@@ -316,6 +323,7 @@
   "ui.setup.stories.no": "Ne – jen rodokmen a prameny",
   "ui.uninstall.agent": "co o stromu ví {agent}",
   "ui.uninstall.shortcut": "zástupce",
+  "ui.uninstall.links": "odkazy z aplikace Strom",
   "ui.uninstall.git": "vlastní git stromu",
   "ui.uninstall.path": "záznam instalátoru v PATH",
   "ui.uninstall.program": "program",
@@ -498,6 +506,7 @@
   "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.wait.open": "V aplikaci se nic neukázalo (už byla otevřená)? Otevřete tuto adresu v prohlížeči, ve kterém ji máte: {url}",
   "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.",
@@ -580,6 +589,79 @@
   "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.link.ok": "OK",
+  "ui.link.bad": "Tento odkaz z aplikace Strom nešel použít ({why}). Nic se nestalo.",
+  "ui.link.notree": "Výzkum, pro který odkaz je, na tomto počítači není (nebo strom nezná jeho složku). Nic se nestalo.",
+  "ui.link.which": "Tento výzkum je tu vícekrát. Který má úpravy přijmout?",
+  "ui.link.noclip": "Tento výřez pramene {source} už ve výzkumu není (byl udělán znovu nebo odebrán). Otevřete aplikaci Strom z výzkumu znovu, dostane aktuální výřezy.",
+  "ui.link.noscan": "Sken tohoto výřezu pramene {source} na tomto počítači není a výzkum nezná ani jeho stránku v online archivu.",
+  "ui.link.noterminal": "strom nemohl otevřít okno terminálu. Spusťte strom a zvolte: {item} — Přímo z aplikace Strom.",
+  "ui.link.on.done": "✓ Odkazy z aplikace Strom vedou do výzkumu na tomto počítači.",
+  "ui.link.on.failed": "Odkazy z aplikace Strom se na tomto počítači nepodařilo nastavit.",
+  "ui.link.off.done": "Odkazy z aplikace Strom už do výzkumu na tomto počítači nevedou.",
+  "ui.link.off.failed": "Odkazy z aplikace Strom se z tohoto počítače nepodařilo odebrat.",
+  "ui.link.which.one": "Tento výzkum je tu vícekrát. Který?",
+  "ui.link.noterminal.any": "strom nemohl otevřít okno terminálu. Spusťte strom (výzkum {name}) a pokračujte z jeho nabídky.",
+  "ui.link.noterminal.new": "strom nemohl otevřít okno terminálu. Spusťte strom a pak to zkuste z aplikace Strom znovu.",
+  "ui.link.asks": "Aplikace Strom žádá: {what}\nVýzkum: {name}",
+  "ui.link.go": "Pokračovat?",
+  "ui.link.cost": "Agent pracuje na vaše předplatné nebo kredit AI.",
+  "ui.link.tasks": "Výzkum zapíše úkoly pro agenta – teď se nic nehledá a nic se neplatí.",
+  "ui.link.what.chat": "rozhovor s agentem ({agent}) o výzkumu.",
+  "ui.link.what.chat.person": "rozhovor s agentem ({agent}) o osobě {person}.",
+  "ui.link.chat.say": "Podívejme se na osobu {person}: řekni mi krátce, co o ní výzkum ví, a zeptej se mě, co chci zjistit.",
+  "ui.link.what.review.person": "prověřit znovu osobu {person}.",
+  "ui.link.what.review.family": "prověřit znovu osobu {person} i s partnery a dětmi.",
+  "ui.link.what.review.line": "prověřit znovu osobu {person} i s předky.",
+  "ui.link.what.research.ancestors": "hledat předky osoby {person} (nový směr výzkumu).",
+  "ui.link.what.research.descendants": "hledat potomky osoby {person} (nový směr výzkumu).",
+  "ui.link.noperson": "Osoba {person} v tomto výzkumu není (nebo z něj byla vyřazena). Nic se nestalo.",
+  "ui.link.notask": "Tento úkol už na vás nečeká (odpověď už má, nebo ho převzal agent). Nic se nestalo.",
+  "ui.link.task.none": "Úkol {task} v tomto výzkumu není. Nic se nestalo.",
+  "ui.link.task.cannot": "Tento úkol teď takhle změnit nejde (mezitím se změnil). Nic se nestalo.",
+  "ui.link.what.task.park": "odložit úkol: {what}",
+  "ui.link.what.task.drop": "vzdát úkol: {what}",
+  "ui.link.what.task.wake": "vrátit úkol do fronty: {what}",
+  "ui.link.task.why": "Proč? (pár slov, zůstane u úkolu)",
+  "ui.link.task.park.default": "Odloženo v aplikaci Strom.",
+  "ui.link.task.drop.default": "Vzdáno v aplikaci Strom.",
+  "ui.link.task.park.done": "✓ Úkol je odložený.",
+  "ui.link.task.drop.done": "✓ Úkol je vzdaný (zůstává i s důvodem).",
+  "ui.link.task.wake.done": "✓ Úkol je zpět ve frontě agenta.",
+  "ui.link.sessions.title": "Sezení agenta – {name}",
+  "ui.link.sessions.none": "Agent na tomto výzkumu zatím nepracoval.",
+  "ui.link.sessions.month": "Tento měsíc: sezení {n}, {cost}",
+  "ui.link.sessions.more": "… a dalších {n} dříve",
+  "ui.link.conflict.none": "Rozpor {id} v tomto výzkumu není. Nic se nestalo.",
+  "ui.link.conflict.decided": "Tento rozpor už je rozhodnutý: {resolution}",
+  "ui.link.what.conflict.decide": "rozhodnout rozpor: {title}",
+  "ui.link.what.conflict.agent": "nechat rozpor na agentovi ({agent}): {title}",
+  "ui.link.conflict.pick": "Co platí?",
+  "ui.link.conflict.other": "Něco jiného (napíšu sám)",
+  "ui.link.conflict.own": "Co platí?",
+  "ui.link.conflict.why": "Proč? (co rozhoduje)",
+  "ui.link.conflict.by": "{why} (rozhodnutí uživatele)",
+  "ui.link.conflict.done": "✓ Rozpor je rozhodnutý.",
+  "ui.link.conflict.say": "Podívej se na rozpor {id} ({title}): zvaž prameny, rozhodni ho přes strom conflict resolve a pak mi řekni, k čemu jsi došel a proč.",
+  "ui.link.story.none": "Osoba {person} zatím nemá vyprávění. Nic se nestalo.",
+  "ui.link.story.final": "Vyprávění osoby {person} už je schválené.",
+  "ui.link.what.story": "schválit vyprávění osoby {person}, jak je (už nebude návrh).",
+  "ui.link.story.done": "✓ Vyprávění je schválené. Až výzkum v aplikaci Strom otevřete znovu, bude tam 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.",
+  "ui.link.what.sync": "vrátit, co výzkum převzal z aplikace Strom {day} (změn: {n}).",
+  "ui.link.new.title": "Aplikace Strom chce začít výzkum s jedním svým rodokmenem.",
+  "ui.link.new.name": "Název výzkumu (rodina, např. Novákovi)",
+  "ui.link.new.exists": "Výzkum „{name}“ už tu je, i s osobami. Zvolte jiný název.",
+  "ui.link.new.wait": "Čekám, až aplikace Strom strom předá – potvrďte to v ní (nejvýš {min} min; Ctrl+C přeruší).",
+  "ui.link.new.none": "Aplikace Strom žádný strom nepředala. Výzkum „{name}“ tu je, zatím prázdný: začněte znovu z aplikace, nebo do něj přidejte v nabídce stromu.",
+  "ui.link.new.waited": "Z aplikace Strom do {min} min žádný strom nepřišel. Výzkum „{name}“ tu je, zatím prázdný.",
+  "ui.link.new.empty": "Strom, který aplikace Strom poslala, nemá žádné osoby – není co zkoumat. Výzkum „{name}“ tu je, zatím prázdný.",
+  "ui.link.new.failed": "Aplikace Strom strom předat nemohla. Výzkum „{name}“ tu je, zatím prázdný: zkuste to z aplikace znovu.",
+  "ui.link.new.taken": "✓ Rodokmen je ve výzkumu „{name}“: osob {persons}, rodin {families} – jako vodítka; co doloží záznamy, najde agent.",
+  "ui.link.new.back": "Aplikace Strom teď strom ukazuje jako strom výzkumu.",
+  "ui.link.new.chat": "Začít teď rozhovor s agentem?",
+  "ui.link.new.say": "Předal(a) jsem náš rodokmen z aplikace Strom – podívej se, co v něm je, a navrhni, čím začít.",
   "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)",

package/assets/lang/de.json

@@ -38,6 +38,7 @@
   "ui.yes": "j",
   "ui.no": "n",
   "ui.enter": "Drücken Sie Enter, um zum Menü zurückzukehren.",
+  "ui.enter.close": "Drücken Sie Enter, um dieses Fenster zu schließen.",
   "ui.choose": "Auswahl",
   "ui.bad.choice": "Bitte geben Sie eine der Zahlen ein.",
   "ui.dialog.title": "Strom Ahnenforschung",
@@ -109,6 +110,8 @@
   "ui.setup.level.sure": "Wirklich alles erlauben?",
   "ui.setup.shortcut": "Eine Verknüpfung „Strom Ahnenforschung“ auf dem Desktop anlegen?",
   "ui.setup.shortcut.done": "✓ Verknüpfung: {file}",
+  "ui.setup.links": "Der Strom-App erlauben, die Forschung auf diesem Computer zu starten? (Ein Klick schickt Ihre Änderungen zurück, öffnet einen Ausschnitt in voller Qualität, den Agenten oder die Prüfung einer Person – jeweils erst hier gefragt.)",
+  "ui.setup.links.done": "✓ Links aus der Strom-App führen hier zur Forschung.",
   "ui.setup.skill": "✓ {agent} kennt strom jetzt in jedem Ordner.",
   "ui.setup.app": "✓ Die Strom-App ist auf diesem Computer – das Menü öffnet die Forschung darin, und während der Agent arbeitet, verfolgt die App sie live.",
   "ui.setup.done": "Fertig.",
@@ -199,6 +202,10 @@
   "ui.doc.level": "der Agent darf",
   "ui.doc.model": "Modell",
   "ui.doc.shortcut": "Desktop-Verknüpfung",
+  "ui.doc.links": "Links aus der Strom-App",
+  "ui.doc.links.ours": "ja",
+  "ui.doc.links.other": "führen zu einem anderen Programm (oder dorthin, wo strom früher war)",
+  "ui.doc.links.none": "keine",
   "ui.doc.app": "Strom-App",
   "ui.doc.tree": "dieser Stammbaum",
   "ui.doc.innode": "strom {version} in Node {node}",
@@ -316,6 +323,7 @@
   "ui.setup.stories.no": "Nein – nur der Stammbaum und seine Quellen",
   "ui.uninstall.agent": "was {agent} über strom weiß",
   "ui.uninstall.shortcut": "die Verknüpfung",
+  "ui.uninstall.links": "die Links aus der Strom-App",
   "ui.uninstall.git": "strom's eigenes git",
   "ui.uninstall.path": "der PATH-Eintrag des Installationsprogramms",
   "ui.uninstall.program": "das Programm",
@@ -498,6 +506,7 @@
   "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.wait.open": "In der App erscheint nichts (sie war schon offen)? Öffnen Sie diese Adresse in dem Browser, in dem Sie sie haben: {url}",
   "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.",
@@ -580,6 +589,79 @@
   "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.link.ok": "OK",
+  "ui.link.bad": "Dieser Link aus der Strom-App ließ sich nicht verwenden ({why}). Es ist nichts geschehen.",
+  "ui.link.notree": "Die Forschung, für die dieser Link ist, ist nicht auf diesem Computer (oder strom kennt ihren Ordner nicht). Es ist nichts geschehen.",
+  "ui.link.which": "Diese Forschung ist hier mehrmals. Welche soll die Änderungen übernehmen?",
+  "ui.link.noclip": "Dieser Ausschnitt der Quelle {source} ist nicht mehr in der Forschung (neu gemacht oder entfernt). Öffnen Sie die Strom-App erneut aus der Forschung, dann bekommt sie die aktuellen.",
+  "ui.link.noscan": "Der Scan dieses Ausschnitts der Quelle {source} ist nicht auf diesem Computer, und die Forschung kennt auch keine Seite davon im Online-Archiv.",
+  "ui.link.noterminal": "strom konnte kein Terminalfenster öffnen. Starten Sie strom und wählen Sie: {item} — Direkt aus der Strom-App.",
+  "ui.link.on.done": "✓ Links aus der Strom-App führen hier zur Forschung.",
+  "ui.link.on.failed": "Die Links aus der Strom-App ließen sich auf diesem Computer nicht einrichten.",
+  "ui.link.off.done": "Links aus der Strom-App führen hier nicht mehr zur Forschung.",
+  "ui.link.off.failed": "Die Links aus der Strom-App ließen sich von diesem Computer nicht entfernen.",
+  "ui.link.which.one": "Diese Forschung ist hier mehrmals vorhanden. Welche?",
+  "ui.link.noterminal.any": "strom konnte kein Terminalfenster öffnen. Starten Sie strom (die Forschung {name}) und machen Sie in seinem Menü weiter.",
+  "ui.link.noterminal.new": "strom konnte kein Terminalfenster öffnen. Starten Sie strom und versuchen Sie es dann erneut aus der Strom-App.",
+  "ui.link.asks": "Die Strom-App bittet um: {what}\nForschung: {name}",
+  "ui.link.go": "Fortfahren?",
+  "ui.link.cost": "Der Agent arbeitet auf Ihr Abonnement oder KI-Guthaben.",
+  "ui.link.tasks": "Die Forschung schreibt Aufgaben für den Agenten – jetzt wird nichts gesucht und nichts bezahlt.",
+  "ui.link.what.chat": "ein Gespräch mit dem Agenten ({agent}) über die Forschung.",
+  "ui.link.what.chat.person": "ein Gespräch mit dem Agenten ({agent}) über {person}.",
+  "ui.link.chat.say": "Schauen wir uns {person} an: Sag mir kurz, was die Forschung über diese Person weiß, und frag mich, was ich herausfinden möchte.",
+  "ui.link.what.review.person": "{person} erneut prüfen.",
+  "ui.link.what.review.family": "{person} erneut prüfen, mit Partnern und Kindern.",
+  "ui.link.what.review.line": "{person} erneut prüfen, mit den Vorfahren.",
+  "ui.link.what.research.ancestors": "die Vorfahren von {person} suchen (eine neue Richtung der Forschung).",
+  "ui.link.what.research.descendants": "die Nachkommen von {person} suchen (eine neue Richtung der Forschung).",
+  "ui.link.noperson": "{person} ist nicht in dieser Forschung (oder wurde aus ihr entfernt). Es ist nichts geschehen.",
+  "ui.link.notask": "Diese Aufgabe wartet nicht mehr auf Sie (sie ist beantwortet, oder ein Agent hat sie übernommen). Es ist nichts geschehen.",
+  "ui.link.task.none": "Aufgabe {task} ist nicht in dieser Forschung. Es ist nichts geschehen.",
+  "ui.link.task.cannot": "Diese Aufgabe lässt sich jetzt so nicht ändern (sie hat sich inzwischen geändert). Es ist nichts geschehen.",
+  "ui.link.what.task.park": "die Aufgabe zurückstellen: {what}",
+  "ui.link.what.task.drop": "die Aufgabe aufgeben: {what}",
+  "ui.link.what.task.wake": "die Aufgabe zurück in die Warteschlange: {what}",
+  "ui.link.task.why": "Warum? (ein paar Worte, bleiben bei der Aufgabe)",
+  "ui.link.task.park.default": "In der Strom-App zurückgestellt.",
+  "ui.link.task.drop.default": "In der Strom-App aufgegeben.",
+  "ui.link.task.park.done": "✓ Die Aufgabe ist zurückgestellt.",
+  "ui.link.task.drop.done": "✓ Die Aufgabe ist aufgegeben (bleibt mit dem Grund erhalten).",
+  "ui.link.task.wake.done": "✓ Die Aufgabe ist zurück in der Warteschlange des Agenten.",
+  "ui.link.sessions.title": "Sitzungen des Agenten – {name}",
+  "ui.link.sessions.none": "Der Agent hat an dieser Forschung noch nicht gearbeitet.",
+  "ui.link.sessions.month": "Diesen Monat: {n} Sitzungen, {cost}",
+  "ui.link.sessions.more": "… und {n} frühere",
+  "ui.link.conflict.none": "Widerspruch {id} ist nicht in dieser Forschung. Es ist nichts geschehen.",
+  "ui.link.conflict.decided": "Dieser Widerspruch ist bereits entschieden: {resolution}",
+  "ui.link.what.conflict.decide": "den Widerspruch entscheiden: {title}",
+  "ui.link.what.conflict.agent": "den Widerspruch dem Agenten überlassen ({agent}): {title}",
+  "ui.link.conflict.pick": "Was stimmt?",
+  "ui.link.conflict.other": "Etwas anderes (ich schreibe es)",
+  "ui.link.conflict.own": "Was stimmt?",
+  "ui.link.conflict.why": "Warum? (was entscheidet)",
+  "ui.link.conflict.by": "{why} (Entscheidung des Nutzers)",
+  "ui.link.conflict.done": "✓ Der Widerspruch ist entschieden.",
+  "ui.link.conflict.say": "Schau dir den Widerspruch {id} an ({title}): wäge die Quellen ab, entscheide ihn mit strom conflict resolve und sag mir dann, wozu du gekommen bist und warum.",
+  "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.story.done": "✓ Die Erzählung ist freigegeben. Öffnen Sie die Forschung in der Strom-App erneut, dann 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.",
+  "ui.link.what.sync": "zurücknehmen, was die Forschung am {day} aus der Strom-App übernommen hat ({n} Änderungen).",
+  "ui.link.new.title": "Die Strom-App möchte eine Forschung mit einem ihrer Stammbäume beginnen.",
+  "ui.link.new.name": "Name der Forschung (die Familie, z. B. Novák)",
+  "ui.link.new.exists": "Eine Forschung „{name}“ gibt es hier schon, mit Personen. Wählen Sie einen anderen Namen.",
+  "ui.link.new.wait": "Ich warte, bis die Strom-App den Stammbaum übergibt – bestätigen Sie es dort (höchstens {min} Min.; Strg+C bricht ab).",
+  "ui.link.new.none": "Die Strom-App hat keinen Stammbaum übergeben. Die Forschung „{name}“ ist hier, noch leer: beginnen Sie erneut aus der App, oder fügen Sie im Menü von strom etwas hinzu.",
+  "ui.link.new.waited": "Innerhalb von {min} Min. kam kein Stammbaum aus der Strom-App. Die Forschung „{name}“ ist hier, noch leer.",
+  "ui.link.new.empty": "Der Stammbaum, den die Strom-App geschickt hat, hat keine Personen – es gibt nichts zu erforschen. Die Forschung „{name}“ ist hier, noch leer.",
+  "ui.link.new.failed": "Die Strom-App konnte den Stammbaum nicht übergeben. Die Forschung „{name}“ ist hier, noch leer: versuchen Sie es erneut aus der App.",
+  "ui.link.new.taken": "✓ Der Stammbaum ist in der Forschung „{name}“: {persons} Personen, {families} Familien – als Hinweise; was Quellen belegen, findet der Agent.",
+  "ui.link.new.back": "Die Strom-App zeigt den Stammbaum jetzt als Stammbaum der Forschung.",
+  "ui.link.new.chat": "Jetzt das Gespräch mit dem Agenten beginnen?",
+  "ui.link.new.say": "Ich habe unseren Stammbaum aus der Strom-App übergeben – schau dir an, was darin ist, und schlag vor, womit wir beginnen.",
   "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)",

package/assets/method/narrate.md

@@ -10,4 +10,5 @@ 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
   --fact E… --fact E… --note "what is inferred"`: every fact it leans on goes
   in --fact. A couple's story goes on the family (F…).
-- It stays a draft; `--final` only when the user approved it.
+- It stays a draft; when the user says it is right: `strom story approve P…`
+  (the Strom app asks them too).

package/assets/method/recording.md

@@ -56,7 +56,9 @@ without --dry-run. `#name` labels what a line creates, `@name` uses it later.
 - What a finding means for other tasks: `strom task edit T… --note "…"`.
 - Records about one person disagree (a name, a date, an age): record both
   claims and your reasoning — `strom conflict add "<question>" --about P…
-  --claim "S…:<what it says>" --claim "S…:<what the other says>"`. Records
+  --fact BIRT --claim "S…:<what it says>" --claim "S…:<what the other says>"`
+  (`--fact`: the fact's tag — BIRT, DEAT, NAME, SEX… — the Strom app shows the
+  conflict there). Records
   that give different parents are first two people (see core); they are one
   person with a conflict only once something else proves it. What would decide
   it, if not at hand, is a task about it: `strom task add … --about X…` (or H…).

package/dist/agents/files.js

@@ -94,7 +94,7 @@ they ask.
 - **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…\`.
+  undone with \`strom sync undo I…\`. Straight from the app: \`strom sync --app\`.
 - **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/human.js

@@ -4,6 +4,7 @@
 // they are shown.
 import { MONTHS } from "../core/gdate.js";
 import { ui } from "./ui.js";
+import { displayName } from "../core/people.js";
 /**
  * English reads "31 Aug 1830"; the others their own numeric form ("31. 8. 1830", "31.8.1830"). A month and
  * year alone are named ("srpen 1830") — after a word ("před 3/1853") in numbers, which no grammatical case bends.
@@ -114,3 +115,20 @@ export function humanPlace(place, house, lang) {
         return place ?? "";
     return ui(lang, "ui.card.house", { place: place ?? "", house }).replace(/^[,\s]+/, "");
 }
+/** What the agent wrote into a task, for the user: the records it names by ID by their names ("S0001" → its title). */
+export function humanTask(tree, text, lang) {
+    const name = (id) => {
+        const r = tree.get(id);
+        if (!r)
+            return id;
+        if (r.type === "session")
+            return ui(lang, "ui.plan.session", { day: humanDay(r.started, lang) });
+        if (r.type === "person")
+            return `${displayName(r)} [${r.id}]`;
+        if (r.type === "family")
+            return r.partners.map((x) => tree.get(x)).filter((x) => !!x).map(displayName).join(" & ") || id;
+        return r.title;
+    };
+    // A list of IDs as a list of names, each once (two sessions of one day read as one).
+    return text.replace(/\b[PFSBN]\d{4,}\b(?:, [PFSBN]\d{4,}\b)*/g, (ids) => [...new Set(ids.split(", ").map(name))].join(", "));
+}

package/dist/cli/main.js

@@ -14,6 +14,7 @@ import { isAgent } from "../core/which.js";
 import { noticeStromApp } from "../core/stromapp.js";
 import { isNewer } from "../core/update.js";
 import { refreshGlobal } from "../agents/global.js";
+import { linkFiles, linkHandlerState, registerLinks } from "../core/links.js";
 import { clockLine } from "../core/clock.js";
 import { currentSession } from "../core/session.js";
 import { checkArgs, GroupOnly, parseOptions, resolveCommand, splitPassthrough } from "./execute.js";
@@ -139,6 +140,14 @@ export async function main(argv, io, env, cwd) {
         const last = ctx.settings.config.lastVersion;
         if (ctx.settings.home() && (!last || isNewer(VERSION, last))) {
             refreshGlobal(env);
+            // …and the links from the Strom app lead to this strom again (where strom made them)
+            try {
+                if (linkFiles(env).length && linkHandlerState(env) !== "ours")
+                    registerLinks(env);
+            }
+            catch {
+                // strom doctor says so
+            }
             ctx.settings.config.lastVersion = VERSION;
             ctx.settings.save();
         }

package/dist/cli/menu-links.js

@@ -0,0 +1,249 @@
+// What the Strom app's menus ask through strom-research:// links (the app's
+// second wave): a task put aside, given up or back in the queue, the agent's
+// sessions and what they cost, a conflict decided, a story approved, a sending
+// taken back — and a tree of the app that becomes a new research. Each is said
+// in the research's terminal and done on the person's word, as the menu does.
+import fs from "node:fs";
+import path from "node:path";
+import { outOfAnswers, translator } from "./menu-parts.js";
+import { offerChat } from "./menu-research.js";
+import { humanCost, humanDay, humanTask } from "./human.js";
+import { lines, truncate } from "./format.js";
+import { Tree } from "../core/tree.js";
+import { monthSpend } from "../core/session.js";
+import { adoptFailedSince, adoptedSince, awaitAdoption, nothingSince } from "../core/sync.js";
+import { startLive } from "../core/live.js";
+import { adoptAppUrl } from "../core/stromapp.js";
+import { isValidLang } from "../core/lang.js";
+import { agentsHere } from "../core/apps.js";
+import { PROFILES } from "../agents/profiles.js";
+import { foldText, safeFolderName } from "../core/text.js";
+import { StromError } from "../core/errors.js";
+/** What the Strom app asks, said before anything is done; true when the person goes on. */
+export async function asks(ctx, lang, root, what, note) {
+    const name = Tree.open(root, ctx.env).config.name;
+    ctx.io.stdout(lines(translator(lang)("ui.link.asks", { what, name }), note, "") + "\n");
+    return ctx.confirm(translator(lang)("ui.link.go"), true);
+}
+const out = (ctx, line) => ctx.io.stdout(line + "\n");
+/** What stopped it, said; nothing was done. */
+function stop(ctx, line) {
+    out(ctx, line);
+    return false;
+}
+/** A task put aside, given up (each with the person's reason) or back in the queue. */
+export async function taskDo(ctx, run, lang, root, id, what) {
+    const t = translator(lang);
+    const tree = Tree.open(root, ctx.env);
+    const task = tree.get(id);
+    if (!task || task.retracted)
+        return stop(ctx, t("ui.link.task.none", { task: id }));
+    const can = { park: ["open"], drop: ["open", "parked", "waiting"], wake: ["parked", "waiting"] }[what];
+    if (!can.includes(task.state))
+        return stop(ctx, t("ui.link.task.cannot"));
+    if (!(await asks(ctx, lang, root, t(`ui.link.what.task.${what}`, { what: humanTask(tree, task.what, lang) }))))
+        return false;
+    let reason = [];
+    if (what !== "wake") {
+        const why = (await ctx.ask(t("ui.link.task.why"), t(`ui.link.task.${what}.default`))).trim();
+        if (why === "0")
+            return false;
+        reason = [`--reason=${why || t(`ui.link.task.${what}.default`)}`];
+    }
+    if ((await run(["task", what, id, ...reason], true)) !== 0)
+        return false;
+    out(ctx, t(`ui.link.task.${what}.done`));
+    return true;
+}
+/** The agent's sessions, the latest first, and what this month's cost. */
+export function sessionsView(ctx, lang, root) {
+    const t = translator(lang);
+    const tree = Tree.open(root, ctx.env);
+    const all = tree.list("session").sort((a, b) => b.started.localeCompare(a.started));
+    out(ctx, t("ui.link.sessions.title", { name: tree.config.name }));
+    if (!all.length)
+        return void out(ctx, `  ${t("ui.link.sessions.none")}`);
+    const month = monthSpend(tree, new Date().toISOString().slice(0, 7));
+    out(ctx, t("ui.link.sessions.month", { n: month.sessions, cost: humanCost(month.amount, lang) }));
+    out(ctx, "");
+    const shown = all.slice(0, 15);
+    for (const s of shown) {
+        const task = s.task ? tree.get(s.task) : undefined;
+        const agent = PROFILES[s.agent ?? ""]?.name ?? s.agent ?? "";
+        const what = truncate(humanTask(tree, task?.what ?? s.summary ?? "", lang), 80);
+        const cost = s.metrics?.costUsd !== undefined ? `${humanCost(s.metrics.costUsd, lang)}${s.metrics.costPartial ? "+" : ""}` : "";
+        out(ctx, `  ${humanDay(s.started, lang)}  ${[agent, what, cost].filter(Boolean).join(" · ")}`);
+    }
+    if (all.length > shown.length)
+        out(ctx, `  ${t("ui.link.sessions.more", { n: all.length - shown.length })}`);
+}
+/** A conflict the person decides: which claim holds (or their own words), and why. */
+export async function decideConflict(ctx, run, lang, root, id) {
+    const t = translator(lang);
+    const tree = Tree.open(root, ctx.env);
+    const c = tree.get(id);
+    if (!c || c.type !== "conflict")
+        return stop(ctx, t("ui.link.conflict.none", { id }));
+    if (c.state === "resolved")
+        return stop(ctx, t("ui.link.conflict.decided", { resolution: c.resolution ?? "" }));
+    if (!(await asks(ctx, lang, root, t("ui.link.what.conflict.decide", { title: c.title }))))
+        return false;
+    const claim = (x) => `${x.value}${x.source ? ` — ${tree.get(x.source)?.title ?? x.source}` : ""}`;
+    const i = await ctx.choose(t("ui.link.conflict.pick"), [...c.claims.map((x) => ({ label: claim(x) })), { label: t("ui.link.conflict.other") }], 0, { back: t("ui.browse.back") });
+    if (i === undefined)
+        return false;
+    let resolution = i < c.claims.length ? `${c.claims[i].value}${c.claims[i].source ? ` (${c.claims[i].source})` : ""}` : "";
+    if (!resolution) {
+        resolution = (await ctx.ask(t("ui.link.conflict.own"))).trim();
+        if (!resolution || resolution === "0")
+            return false;
+    }
+    let why = "";
+    while (!why) {
+        why = (await ctx.ask(t("ui.link.conflict.why"))).trim();
+        if (why === "0" || outOfAnswers(ctx))
+            return false;
+    }
+    if ((await run(["conflict", "resolve", id, `--resolution=${resolution}`, `--reasoning=${t("ui.link.conflict.by", { why })}`], true)) !== 0)
+        return false;
+    out(ctx, t("ui.link.conflict.done"));
+    return true;
+}
+/** A story the person read and approves: no longer a draft. */
+export async function approveStory(ctx, run, lang, root, person, who) {
+    const t = translator(lang);
+    const st = person.story;
+    if (!st)
+        return stop(ctx, t("ui.link.story.none", { person: who }));
+    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 }))))
+        return false;
+    if ((await run(["story", "approve", person.id], true)) !== 0)
+        return false;
+    out(ctx, t("ui.link.story.done"));
+    return true;
+}
+/** What the research took from the Strom app, taken back on the person's word. */
+export async function undoSending(ctx, run, lang, root, id) {
+    const t = translator(lang);
+    const input = Tree.open(root, ctx.env).get(id);
+    if (!input || input.type !== "input" || !input.sync)
+        return stop(ctx, t("ui.link.sync.none", { input: id }));
+    if (input.sync.undone)
+        return stop(ctx, t("ui.link.sync.was"));
+    if (!(await asks(ctx, lang, root, t("ui.link.what.sync", { day: humanDay(input.created, lang), n: input.sync.applied.length }))))
+        return false;
+    return (await run(["sync", "undo", id])) === 0;
+}
+/**
+ * A tree of the Strom app becomes a new research (strom-research://new?app=<its mark>): named, its language and
+ * agent chosen, made; the app opened to hand the tree over (?adopt=<the bridge>), the tree taken in as leads,
+ * the research sent back to the app — then the conversation offered.
+ */
+export async function newFromApp(ctx, runIn, token, openAt, forward) {
+    // strom not set up yet (the app is how this person came): the setup first
+    if (!ctx.settings.home()?.value) {
+        await (await runIn(undefined))(["setup"]);
+        ctx.settings.reload();
+        if (!ctx.settings.home()?.value)
+            return false;
+    }
+    let lang = ctx.uiLang();
+    let t = translator(lang);
+    out(ctx, t("ui.link.new.title"));
+    out(ctx, "");
+    // the name; an empty research of that name (a handover that did not come) is taken again
+    let name = "";
+    let root;
+    for (;;) {
+        name = (await ctx.ask(t("ui.link.new.name"))).trim().replace(/\s+/gu, " ");
+        if (!name || name === "0")
+            return false;
+        const same = ctx.knownTrees().find((k) => foldText(k.name) === foldText(name) || path.basename(k.root) === safeFolderName(name));
+        if (!same)
+            break;
+        if (Tree.open(same.root, ctx.env).count("person") === 0) {
+            root = same.root;
+            break;
+        }
+        out(ctx, t("ui.link.new.exists", { name }));
+        if (outOfAnswers(ctx))
+            return false;
+    }
+    for (;;) {
+        const a = (await ctx.ask(t("ui.setup.lang"), lang)).trim().toLowerCase();
+        if (a === "0")
+            return false;
+        if (isValidLang(a)) {
+            lang = a;
+            t = translator(lang);
+            break;
+        }
+        if (outOfAnswers(ctx))
+            return false;
+    }
+    const here = agentsHere(ctx.env).map((a) => a.id);
+    const mine = ctx.settings.agent().value;
+    let agent = mine;
+    if (here.length > 1) {
+        const i = await ctx.choose(t("ui.setup.agent.pick"), here.map((id) => ({ label: PROFILES[id].name })), Math.max(0, here.indexOf(mine)), { back: t("ui.browse.back") });
+        if (i === undefined)
+            return false;
+        agent = here[i];
+    }
+    if (!root) {
+        let said = "";
+        const code = await (await runIn(undefined))(["init", name, "--lang", lang, "--json"], true, (s) => (said += s));
+        if (code !== 0)
+            return false;
+        root = JSON.parse(said).root;
+    }
+    const run = await runIn(root);
+    if (agent !== mine)
+        await run(["agents", "use", agent, "--for-tree"], true);
+    // the app hands its tree over to the bridge of this research
+    awaitAdoption(root, token);
+    const info = startLive(root, ctx.env, { current: true });
+    if (!info)
+        throw new StromError("the bridge did not start", { hint: "strom live serve shows why" });
+    const url = adoptAppUrl(info.url, ctx.settings);
+    const since = Date.now();
+    const waitMs = Number(ctx.env.STROM_ADOPT_WAIT_MS ?? 30 * 60_000);
+    const minutes = Math.max(1, Math.round(waitMs / 60_000));
+    out(ctx, openAt(url) ? `${t("ui.link.new.wait", { min: minutes })}\n${t("ui.sync.wait.open", { url })}` : t("ui.app.url", { url }));
+    let file;
+    while (Date.now() < since + waitMs) {
+        file = adoptedSince(root, since);
+        if (file)
+            break;
+        const failed = adoptFailedSince(root, since);
+        if (failed) {
+            forward();
+            return stop(ctx, t(failed === "empty" ? "ui.link.new.empty" : "ui.link.new.failed", { name }));
+        }
+        if (nothingSince(root, since)) {
+            forward();
+            out(ctx, t("ui.link.new.none", { name }));
+            return false;
+        }
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    forward();
+    if (!file)
+        return stop(ctx, t("ui.link.new.waited", { name, min: minutes }));
+    // the family's tree, as leads (without the images written into it: the research keeps its own)
+    const { withoutImages } = await import("../commands/sync.js");
+    const kept = path.join(path.dirname(file), `${safeFolderName(name)}.ged`);
+    fs.writeFileSync(kept, withoutImages(fs.readFileSync(file, "utf8")));
+    if ((await run(["intake", kept], true)) !== 0)
+        return false;
+    const tree = Tree.open(root, ctx.env);
+    out(ctx, t("ui.link.new.taken", { name, persons: tree.count("person"), families: tree.count("family") }));
+    // the research as it is now back into the app's window: the same tree, now of the research
+    if ((await run(["app"], true)) === 0)
+        out(ctx, t("ui.link.new.back"));
+    await offerChat(ctx, run, lang, root, t("ui.link.new.chat"), t("ui.link.new.say"));
+    return true;
+}

package/dist/cli/menu-parts.js

@@ -11,9 +11,9 @@ export function outOfAnswers(ctx) {
     return ctx.io.answers !== undefined && ctx.io.answers.length === 0;
 }
 /** "Press Enter to go back to the menu." — unless there is nobody to press it. */
-export async function pause(ctx, lang) {
+export async function pause(ctx, lang, enter = "ui.enter") {
     if (!outOfAnswers(ctx))
-        await ctx.ask(ui(lang, "ui.enter"));
+        await ctx.ask(ui(lang, enter));
 }
 /**
  * A submenu: its items (built afresh each time, so what they say is current), numbered in the order shown, 0 back.