strom-research 1.15.0 → 1.16.0-beta.2

package/CHANGELOG.cs.md

@@ -5,6 +5,23 @@
 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.16.0
+
+- **Terminál pro okna výzkumu (macOS).** Co aplikace Strom otevírá v terminálu a rozhovor předaný do nového okna
+  se může otevírat v iTerm2 místo v terminálu systému: první položka nastavení, průvodce, když jsou tu oba, nebo
+  `strom config set terminal iterm2`. Když zvolený terminál chybí, otevře se terminál systému a okno to řekne;
+  `strom doctor` ukáže, který je zvolený. Na Windows terminál určuje systém.
+- **Každá osoba na kraji stromu s vlastními variantami.** Když se otevřená hypotéza napojuje na strom u více osob,
+  každá nese varianty, které ji jmenují, a rodinu mimo strom, ke které patří; aplikace Strom tak může ukázat všechny,
+  ne jen první.
+- **Kraj stromu osobu po osobě.** `strom edge --json` vypíše každou osobu, na kterou hypotéza navazuje, s variantami
+  a rodinou každé z nich.
+- **Příjmení po sňatku oběma směry s aplikací Strom.** Jméno po sňatku, které aplikace Strom pošle zpět, se zapíše
+  jako jméno po sňatku, nikdy jako přejmenování ani jako další tvar rodného jména; stejné příjmení je stejné jméno,
+  ať s ním jde jakékoli křestní. Když se v aplikaci změní nebo smaže, staré zmizí tam, kde ho daly jen úpravy
+  v aplikaci; jméno doložené záznamem zůstává. `strom intake` čte `_MARNM` jiných programů jako jméno po sňatku.
+- **Linie výzkumu.** České texty všude říkají „linie výzkumu“, nikde už „směry“.
+
 ## 1.15.0
 
 *16. 10. 2026 · patří k aplikaci Strom 3.12.0.*

package/CHANGELOG.de.md

@@ -5,6 +5,25 @@
 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.16.0
+
+- **Das Terminal für die Fenster der Forschung (macOS).** Was die Strom-App in einem Terminal öffnet, und ein an ein
+  neues Fenster übergebenes Gespräch, kann sich in iTerm2 statt im Terminal des Systems öffnen: der erste Punkt der
+  Einstellungen, die Einrichtung, wenn beide da sind, oder `strom config set terminal iterm2`. Ein nicht installiertes
+  Terminal fällt auf das des Systems zurück und sagt es im Fenster; `strom doctor` nennt das gewählte. Unter Windows
+  bestimmt es das System.
+- **Jede Person am Rand des Stammbaums mit eigenen Varianten.** Wenn eine offene Hypothese den Stammbaum bei mehreren
+  Personen anschließt, trägt jede die Varianten, die sie nennen, und die Familie außerhalb des Stammbaums, zu der sie
+  gehört; so kann die Strom-App alle zeigen, nicht nur die erste.
+- **Der Rand des Stammbaums, Person für Person.** `strom edge --json` nennt jede Person, an die eine Hypothese
+  anschließt, mit den Varianten und der Familie jeder einzelnen.
+- **Der Familienname nach der Heirat, in beide Richtungen mit der Strom-App.** Ein Name nach der Heirat, den die
+  Strom-App zurückschickt, kommt als Name nach der Heirat an, nie als Umbenennung oder als weitere Form des
+  Geburtsnamens; derselbe Familienname ist derselbe Name, mit welchem Vornamen auch immer. In der App geändert oder
+  entfernt, geht der alte dort, wo ihn nur Änderungen in der App gaben; einer, den ein Eintrag belegt, bleibt.
+  `strom intake` liest `_MARNM` anderer Programme als Namen nach der Heirat.
+- **Forschungslinien auf Tschechisch.** Die tschechischen Texte sagen jetzt überall „linie výzkumu“ (Forschungslinien).
+
 ## 1.15.0
 
 *16.10.2026 · gehört zur Strom-App 3.12.0.*

package/CHANGELOG.md

@@ -5,6 +5,23 @@ 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.16.0
+
+- **The terminal for the research's windows (macOS).** What the Strom app opens in a terminal, and a conversation
+  handed over to a new window, can open in iTerm2 instead of the system's terminal: the settings' first item, the
+  setup when both are here, or `strom config set terminal iterm2`. A terminal not installed falls back to the
+  system's and says so in the window; `strom doctor` names the one chosen. On Windows the system decides it.
+- **Each person where the tree ends, with its own variants.** When an open hypothesis joins the tree at several
+  people, each of them carries the variants that name it and the family off the tree it belongs to, so the Strom app
+  can show all of them, not only the first.
+- **Where the tree ends, person by person.** `strom edge --json` lists each person a hypothesis joins, with the
+  variants and the family of each one.
+- **The surname after a marriage, both ways with the Strom app.** A name after a marriage the Strom app sends back
+  comes in as a name of the married kind, never as a rename or another form of the birth name; the same surname is
+  the same name whatever first name goes with it. Changed or taken off in the app, the old one goes where only edits
+  in the app gave it; one a record gives stays. `strom intake` reads `_MARNM` of other programs as a married name.
+- **Lines of research in Czech.** The Czech texts say „linie výzkumu“ (lines of research) everywhere now.
+
 ## 1.15.0
 
 *2026-10-16 · goes with the Strom app 3.12.0.*

package/assets/lang/cs.json

@@ -1123,6 +1123,10 @@
   "ui.sync.cause": "příčina {x}",
   "ui.sync.name.new": "{n}. {who}: další jméno — {text}",
   "ui.sync.name.changed": "{n}. {who}: změněné jméno — {old} → {new}",
+  "ui.sync.name.married": "{n}. {who}: jméno po sňatku — {text}",
+  "ui.sync.name.gone": "{n}. {who}: jméno po sňatku už v něm není — {text}",
+  "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.name.title": "{n}. {who}: {title} — {old} → {new}",
   "ui.sync.do.title": "doplní se ke jménu s odkazem na strom z aplikace",
@@ -1581,6 +1585,20 @@
   "ui.settings.archives": "Archivy: přihlášení, souhlas se stahováním",
   "ui.settings.wizard.what": "Co nastavit?",
   "ui.settings.wizard.all": "Všechno, krok za krokem (průvodce nastavením)",
+  "ui.settings.terminal": "Terminál pro okna výzkumu (z aplikace Strom, předaný rozhovor): {state}",
+  "ui.settings.terminal.archive": "Terminál pro okna výzkumu (z aplikace Strom): {state}",
+  "ui.terminal.system": "výchozí systému ({name})",
+  "ui.terminal.system.plain": "výchozí systému",
+  "ui.terminal.name.terminal": "Terminál",
+  "ui.terminal.name.iterm2": "iTerm2",
+  "ui.terminal.notHere": "{name} (tu není nainstalovaný: otevře se výchozí systému)",
+  "ui.terminal.bySystem": "určuje systém",
+  "ui.terminal.windows": "Na Windows terminál určuje systém: Nastavení → Systém → Pro vývojáře → Terminál.",
+  "ui.terminal.pick": "Ve kterém terminálu otevírat okna výzkumu?",
+  "ui.terminal.missing": "{name} tu není nainstalovaný, okno se otevřelo ve výchozím terminálu.",
+  "ui.doc.terminal": "terminál pro okna",
+  "ui.doc.terminal.missing": "zvolený {name} tu není nainstalovaný: okna se otevírají ve výchozím systému",
+  "ui.doc.terminal.unknown": "terminál „{value}“ tu strom nezná: okna se otevírají ve výchozím systému",
   "ui.settings.maintenance": "Údržba: kontrola instalace, místo na disku",
   "ui.settings.maintenance.tidy": "Údržba: kontrola instalace, místo na disku (jde uvolnit {size})",
   "ui.settings.maintenance.update": "Údržba: kontrola instalace, místo na disku, aktualizace na {version}",
@@ -1920,7 +1938,7 @@
   "ui.error.fs.no-permission": "chybí oprávnění{where}",
   "ui.error.fs.no-permission.hint": "vybrat složku, do které lze zapisovat",
   "ui.task.none": "Žádné úkoly.",
-  "ui.research.none": "Žádné směry výzkumu.",
+  "ui.research.none": "Žádné linie výzkumu.",
   "ui.person.none": "Žádné osoby.",
   "ui.person.nomatch": "Žádná osoba neodpovídá.",
   "ui.person.leadsonly": "jen vodítka",

package/assets/lang/de.json

@@ -1123,6 +1123,10 @@
   "ui.sync.cause": "Ursache {x}",
   "ui.sync.name.new": "{n}. {who}: ein weiterer Name — {text}",
   "ui.sync.name.changed": "{n}. {who}: Name geändert — {old} → {new}",
+  "ui.sync.name.married": "{n}. {who}: Name nach der Heirat — {text}",
+  "ui.sync.name.gone": "{n}. {who}: Name nach der Heirat nicht mehr darin — {text}",
+  "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.name.title": "{n}. {who}: {title} — {old} → {new}",
   "ui.sync.do.title": "wird dem Namen hinzugefügt, mit Verweis auf den eigenen Stammbaum",
@@ -1581,6 +1585,20 @@
   "ui.settings.archives": "Archive: Anmeldungen, Zustimmung zum Herunterladen",
   "ui.settings.wizard.what": "Was einstellen?",
   "ui.settings.wizard.all": "Alles, Schritt für Schritt (die Einrichtung)",
+  "ui.settings.terminal": "Terminal für die Fenster der Forschung (aus der Strom-App, ein übergebenes Gespräch): {state}",
+  "ui.settings.terminal.archive": "Terminal für die Fenster der Forschung (aus der Strom-App): {state}",
+  "ui.terminal.system": "Standard des Systems ({name})",
+  "ui.terminal.system.plain": "Standard des Systems",
+  "ui.terminal.name.terminal": "Terminal",
+  "ui.terminal.name.iterm2": "iTerm2",
+  "ui.terminal.notHere": "{name} (hier nicht installiert: der Standard des Systems öffnet sich)",
+  "ui.terminal.bySystem": "bestimmt das System",
+  "ui.terminal.windows": "Unter Windows bestimmt das System das Terminal: Einstellungen → System → Für Entwickler → Terminal.",
+  "ui.terminal.pick": "In welchem Terminal sollen sich die Fenster der Forschung öffnen?",
+  "ui.terminal.missing": "{name} ist hier nicht installiert; das Fenster wurde im Standardterminal geöffnet.",
+  "ui.doc.terminal": "Terminal für die Fenster",
+  "ui.doc.terminal.missing": "{name} gewählt, hier nicht installiert: die Fenster öffnen sich im Standard des Systems",
+  "ui.doc.terminal.unknown": "das Terminal „{value}“ kennt strom hier nicht: die Fenster öffnen sich im Standard des Systems",
   "ui.settings.maintenance": "Wartung: Prüfung der Installation, Speicherplatz",
   "ui.settings.maintenance.tidy": "Wartung: Prüfung der Installation, Speicherplatz ({size} lassen sich freigeben)",
   "ui.settings.maintenance.update": "Wartung: Prüfung der Installation, Speicherplatz, Aktualisierung auf {version}",

package/dist/cli/menu-settings.js

@@ -23,6 +23,7 @@ import { agentsHere } from "../core/apps.js";
 import { mb, tidyPlan, TIDY_SAID } from "../core/tidy.js";
 import { calibrationOffer, viewSizesFor } from "../core/viewsizes.js";
 import { archivePermissions, archiveState, browserOnlyHere } from "./menu-archives.js";
+import { chooseTerminal, terminalState } from "./terminals.js";
 export async function settingsMenu(ctx, run, lang, root, newer) {
     const t = translator(lang);
     return subMenu(ctx, lang, () => {
@@ -46,14 +47,22 @@ export async function settingsMenu(ctx, run, lang, root, newer) {
                 key: "1",
                 label: t(archive ? "ui.settings.wizard.archive" : "ui.settings.wizard"),
                 act: async () => {
-                    // the setup's model step alone, or the whole setup (Enter); 0 back with nothing changed
+                    // the setup's model step alone, the terminal for the research's windows, or the whole setup (Enter); 0 back
+                    // with nothing changed (the menu has nine items: these are steps of the setup)
+                    const parts = [];
                     if (modelShown) {
                         const kept = ctx.settings.resolve("model.lead", tree, agent);
-                        const i = await ctx.choose(t("ui.settings.wizard.what"), [{ label: t("ui.settings.wizard.all") }, { label: t("ui.settings.model", { agent: PROFILES[agent].name, model: kept ? String(kept.value) : t("ui.settings.model.own") }) }], 0, { back: t("ui.browse.back") });
+                        parts.push({ label: t("ui.settings.model", { agent: PROFILES[agent].name, model: kept ? String(kept.value) : t("ui.settings.model.own") }), act: () => modelStep(ctx, run, lang, agent, tree) });
+                    }
+                    // macOS: the terminal chosen here; Windows: the system decides it, said where
+                    if (process.platform === "darwin" || process.platform === "win32")
+                        parts.push({ label: t(archive ? "ui.settings.terminal.archive" : "ui.settings.terminal", { state: terminalState(ctx, lang) }), act: () => terminalStep(ctx, run, lang) });
+                    if (parts.length) {
+                        const i = await ctx.choose(t("ui.settings.wizard.what"), [{ label: t("ui.settings.wizard.all") }, ...parts.map((p) => ({ label: p.label }))], 0, { back: t("ui.browse.back") });
                         if (i === undefined)
                             return;
-                        if (i === 1)
-                            return void (await modelStep(ctx, run, lang, agent, tree));
+                        if (i > 0)
+                            return void (await parts[i - 1].act());
                     }
                     // After the wizard the menu starts afresh: the research may be in another folder now.
                     await run(["setup"]);
@@ -130,6 +139,18 @@ export async function settingsMenu(ctx, run, lang, root, newer) {
         return { title: t("ui.settings.title"), items };
     }, { fixed: true });
 }
+/** The terminal for the research's windows: picked among those here (0 back, nothing changed); Windows: where the system decides it. */
+async function terminalStep(ctx, run, lang) {
+    if (process.platform === "win32") {
+        ctx.io.stdout(translator(lang)("ui.terminal.windows") + "\n");
+        return pause(ctx, lang);
+    }
+    const now = ctx.settings.terminal() ?? "system";
+    const picked = await chooseTerminal(ctx, lang, now, { back: translator(lang)("ui.browse.back") });
+    if (picked === undefined || picked === now)
+        return;
+    await run(picked === "system" ? ["config", "unset", "terminal"] : ["config", "set", "terminal", picked], true);
+}
 /** Maintenance: the check of the installation, what strom keeps beside the research (disk space), the newer strom when one is out. */
 async function maintenance(ctx, run, lang, root, newer) {
     const t = translator(lang);

package/dist/cli/terminals.js

@@ -0,0 +1,50 @@
+// The terminal for the research's windows as a person sees and picks it (the setting terminal, core/terminal.ts): the
+// system's default with its name first, then the terminals found on this computer — macOS; Windows decides it itself.
+import { ui } from "./ui.js";
+import { systemTerminal, terminalHere, terminalOfMark, terminalsHere } from "../core/terminal.js";
+/** A terminal's name, as a person reads it. */
+export function terminalName(lang, choice) {
+    return ui(lang, `ui.terminal.name.${choice}`);
+}
+/** The system's default, with its name when the system says. */
+export function systemLabel(env, lang, platform = process.platform) {
+    const sys = systemTerminal(env, platform);
+    const name = sys?.choice ? terminalName(lang, sys.choice) : sys?.name;
+    return name ? ui(lang, "ui.terminal.system", { name }) : ui(lang, "ui.terminal.system.plain");
+}
+/** What holds now, in a few words: the one chosen (said when it is not here), else the system's default. */
+export function terminalState(ctx, lang, platform = process.platform) {
+    if (platform === "win32")
+        return ui(lang, "ui.terminal.bySystem");
+    const chosen = ctx.settings.terminal();
+    if (!chosen)
+        return systemLabel(ctx.env, lang, platform);
+    return terminalHere(chosen, ctx.env, platform) ? terminalName(lang, chosen) : ui(lang, "ui.terminal.notHere", { name: terminalName(lang, chosen) });
+}
+/** The choices offered: the system's default, then the terminals found here (the one chosen too, though it is gone). */
+function terminalOptions(ctx, lang, platform) {
+    const found = terminalsHere(ctx.env, platform);
+    const chosen = ctx.settings.terminal();
+    return [
+        { value: "system", label: systemLabel(ctx.env, lang, platform) },
+        ...found.map((v) => ({ value: v, label: terminalName(lang, v) })),
+        ...(chosen && !found.includes(chosen) ? [{ value: chosen, label: ui(lang, "ui.terminal.notHere", { name: terminalName(lang, chosen) }) }] : []),
+    ];
+}
+/**
+ * The terminal the setup suggests: the one chosen; none, the one the setup runs in (TERM_PROGRAM) — the system's
+ * default when that is the same one.
+ */
+export function suggestedTerminal(ctx, platform = process.platform) {
+    const chosen = ctx.settings.terminal();
+    if (chosen)
+        return chosen;
+    const here = terminalOfMark(ctx.env.TERM_PROGRAM);
+    return !here || systemTerminal(ctx.env, platform)?.choice === here ? "system" : here;
+}
+/** The person picks the terminal (Enter: `suggested`): its value (system: the system's default); undefined: back. */
+export async function chooseTerminal(ctx, lang, suggested, opts = {}, platform = process.platform) {
+    const options = terminalOptions(ctx, lang, platform);
+    const i = await ctx.choose(ui(lang, "ui.terminal.pick"), options.map((o) => ({ label: o.label })), Math.max(0, options.findIndex((o) => o.value === suggested)), opts);
+    return i === undefined ? undefined : options[i].value;
+}

package/dist/cli/ui.js

@@ -1027,6 +1027,10 @@ export const UI = {
     "ui.sync.cause": "cause {x}",
     "ui.sync.name.new": "{n}. {who}: another name — {text}",
     "ui.sync.name.changed": "{n}. {who}: name changed — {old} → {new}",
+    "ui.sync.name.married": "{n}. {who}: a name after the marriage — {text}",
+    "ui.sync.name.gone": "{n}. {who}: a name after the marriage no longer in it — {text}",
+    "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.name.title": "{n}. {who}: {title} — {old} → {new}",
     "ui.sync.do.title": "added to the name, citing the tree sent",
@@ -1494,6 +1498,20 @@ export const UI = {
     "ui.settings.archives": "Archives: logins, downloaders asking first",
     "ui.settings.wizard.what": "What to set up?",
     "ui.settings.wizard.all": "Everything, step by step (the setup)",
+    "ui.settings.terminal": "Terminal for the research's windows (from the Strom app, a conversation handed over): {state}",
+    "ui.settings.terminal.archive": "Terminal for the research's windows (from the Strom app): {state}",
+    "ui.terminal.system": "the system's default ({name})",
+    "ui.terminal.system.plain": "the system's default",
+    "ui.terminal.name.terminal": "Terminal",
+    "ui.terminal.name.iterm2": "iTerm2",
+    "ui.terminal.notHere": "{name} (not installed here: the system's default opens)",
+    "ui.terminal.bySystem": "decided by the system",
+    "ui.terminal.windows": "On Windows the system decides the terminal: Settings → System → For developers → Terminal.",
+    "ui.terminal.pick": "Which terminal should the research's windows open in?",
+    "ui.terminal.missing": "{name} is not installed here; the window opened in the default terminal.",
+    "ui.doc.terminal": "terminal for the windows",
+    "ui.doc.terminal.missing": "{name} chosen, not installed here: the windows open in the system's default",
+    "ui.doc.terminal.unknown": "the terminal \"{value}\" is not one strom knows here: the windows open in the system's default",
     "ui.settings.maintenance": "Maintenance: the check of the installation, disk space",
     "ui.settings.maintenance.tidy": "Maintenance: the check of the installation, disk space ({size} can be freed)",
     "ui.settings.maintenance.update": "Maintenance: the check of the installation, disk space, the update to {version}",

package/dist/cli/wizard.js

@@ -11,6 +11,8 @@ import { gitVersion } from "../core/git.js";
 import { fixGit, offerAgent } from "./fixes.js";
 import { agentsHere, suggestedWay, waysHere, whereToTalk } from "../core/apps.js";
 import { chooseWay, wayName } from "./ways.js";
+import { chooseTerminal, suggestedTerminal } from "./terminals.js";
+import { terminalsHere } from "../core/terminal.js";
 import { chooseEffort, chooseModel } from "./model-choice.js";
 import { ADDON_SWITCHES, PROFILES } from "../agents/profiles.js";
 import { writeStored, PERMISSION_LEVELS } from "../core/config.js";
@@ -238,6 +240,19 @@ export async function setupWizard(ctx, opts = {}) {
         await settleFromApp(ctx, lang);
     else if (stromAppState(s) !== "no" && appOpensLinks(s))
         await offerLinks(ctx, lang);
+    // 10. The terminal for the research's windows (a link from the Strom app, a conversation handed over): asked only on a
+    // Mac with more than one — the one the setup runs in suggested (run again: the one chosen); this computer's alone
+    if (process.platform === "darwin" && terminalsHere(ctx.env).length > 1) {
+        const now = s.terminal() ?? "system";
+        const picked = await chooseTerminal(ctx, lang, suggestedTerminal(ctx), keep);
+        if (picked !== undefined && picked !== now) {
+            if (picked === "system")
+                delete cfg.terminal;
+            else
+                cfg.terminal = picked;
+            s.save();
+        }
+    }
     out();
     out(`${ui(lang, "ui.setup.done")}  (${langName(lang, lang)} · ${ctx.display(home)})`);
     return { home, lang, ...(agent ? { agent } : {}), permissions: level };

package/dist/commands/links.js

@@ -47,6 +47,15 @@ function keepAnswer(ctx, answer) {
     ctx.settings.config.links = answer;
     ctx.settings.save();
 }
+/** The window a link opens: in the terminal the person chose (this computer's setting, never the link's), said in their language. */
+function windowOf(ctx) {
+    const terminal = ctx.settings.terminal();
+    return { ...(terminal ? { terminal } : {}), lang: ctx.uiLang() };
+}
+/** The chosen terminal not here: the window opened in the system's (said in it). */
+function fellBack(opened) {
+    return opened === "fallback" ? { terminal: "fallback" } : {};
+}
 /** macOS: the terminal program this runs in, by its mark (TERM_PROGRAM). */
 const TERMINALS = { Apple_Terminal: "Terminal", "iTerm.app": "iTerm", WezTerm: "WezTerm", ghostty: "Ghostty" };
 /**
@@ -404,8 +413,8 @@ register({
         if (link.action === "menu") {
             const where = ctx.settings.home()?.value ?? configDir(ctx.env);
             fs.mkdirSync(where, { recursive: true });
-            openInNewTerminal([], where, ctx.env);
-            return { text: "", data: { done: true, action: "menu" } };
+            const opened = openInNewTerminal([], where, ctx.env, process.platform, windowOf(ctx));
+            return { text: "", data: { done: true, action: "menu", ...fellBack(opened) } };
         }
         // a tree of the app becomes a research: always in a terminal (it asks the name, waits for the app)
         if (link.action === "new") {
@@ -419,9 +428,10 @@ register({
             }
             const where = ctx.settings.home()?.value ?? configDir(ctx.env);
             fs.mkdirSync(where, { recursive: true });
-            if (openInNewTerminal(["link", "open", linkText(link, linkScheme(ctx.env))], where, ctx.env) === false)
+            const opened = openInNewTerminal(["link", "open", linkText(link, linkScheme(ctx.env))], where, ctx.env, process.platform, windowOf(ctx));
+            if (opened === false)
                 return say(ctx, "ui.link.noterminal.new");
-            return { text: "", data: { done: true, action: "new" } };
+            return { text: "", data: { done: true, action: "new", ...fellBack(opened) } };
         }
         if (link.action === "media") {
             // an original the app sent: the file itself, in the viewer of the system; nothing written
@@ -452,12 +462,12 @@ register({
             const quiet = await withoutTerminal(ctx, link, copies[0].root);
             if (quiet)
                 return quiet;
-            const opened = openInNewTerminal(["link", "open", linkText(link, linkScheme(ctx.env))], copies[0].root, ctx.env);
+            const opened = openInNewTerminal(["link", "open", linkText(link, linkScheme(ctx.env))], copies[0].root, ctx.env, process.platform, windowOf(ctx));
             if (opened === false)
                 return link.action === "send"
                     ? say(ctx, "ui.link.noterminal", { item: `${ui(ctx.uiLang(), "ui.more.title")} → ${ui(ctx.uiLang(), "ui.more.sync")}` })
                     : say(ctx, "ui.link.noterminal.any", { name: copies[0].name });
-            return { text: "", data: { done: true, action: link.action, tree: copies[0].root } };
+            return { text: "", data: { done: true, action: link.action, tree: copies[0].root, ...fellBack(opened) } };
         }
         const got = excerptOf(ctx, link);
         if ("file" in got) {

package/dist/commands/setup.js

@@ -1,4 +1,6 @@
 // setup · doctor · config — the environment around the trees.
+import { terminalHere } from "../core/terminal.js";
+import { terminalName, terminalState } from "../cli/terminals.js";
 import { refusedHosts } from "../core/terms.js";
 import { gitSize, lastCompacted } from "../core/history.js";
 import fs from "node:fs";
@@ -410,6 +412,21 @@ function diagnose(ctx) {
         add("appurl", "fail", t(appUrl.source === "env" ? "ui.doc.appurl.env" : "ui.doc.appurl.config", { value: appUrl.value }), appUrl.source === "env"
             ? t("ui.doc.appurl.env.fix", { web: appWebPages(ctx.env) })
             : placeholders(lang, "strom config set strom.app.url <address> · strom config unset strom.app.url"));
+    // The terminal strom opens its windows in (a link from the Strom app, a conversation handed over): the one chosen
+    // (macOS), gone: said with the way back to the system's; Windows: the system decides it. A value this system does not
+    // take (by hand, a newer strom's, another system's) counts as the system's: said with the way back too
+    const unknownTerm = ctx.settings.terminalUnknown();
+    if (unknownTerm !== undefined)
+        add("terminal", "warn", t("ui.doc.terminal.unknown", { value: unknownTerm.replace(/\p{Cc}/gu, "").slice(0, 40) }), "strom config unset terminal");
+    else if (process.platform === "darwin") {
+        const term = ctx.settings.terminal();
+        if (term && !terminalHere(term, ctx.env))
+            add("terminal", "warn", t("ui.doc.terminal.missing", { name: terminalName(lang, term) }), "strom config unset terminal");
+        else
+            add("terminal", "ok", terminalState(ctx, lang));
+    }
+    else if (process.platform === "win32")
+        add("terminal", "ok", t("ui.terminal.windows"));
     // …and whether it may start the research here (strom-research:// links): only while the app is wanted
     if (app !== "no" && appOpensLinks(ctx.settings)) {
         const links = linkHandlerState(ctx.env);

package/dist/commands/start.js

@@ -189,10 +189,15 @@ register({
         // In a terminal: a new window, not a conversation inside this one.
         if (agentHere && !opts.print) {
             const say = about ? ["--task", about.id] : said ? ["--say", said] : [];
-            const opened = openInNewTerminal(["chat", "--agent", agent, "--where", "terminal", ...say], tree.root, ctx.env);
+            // in the terminal the person chose (this computer's setting), said in the research's language
+            const terminal = ctx.settings.terminal();
+            const opened = openInNewTerminal(["chat", "--agent", agent, "--where", "terminal", ...say], tree.root, ctx.env, process.platform, { ...(terminal ? { terminal } : {}), lang });
             if (opened === "recent")
                 return { text: ui(lang, "ui.chat.handover.recent", { agent: profile.name }), data: { agent, handover: "recent", cwd: tree.root } };
-            return { text: ui(lang, opened ? "ui.chat.handover" : "ui.chat.handover.failed", { agent: profile.name }), data: { agent, handover: opened ? "window" : "none", cwd: tree.root } };
+            return {
+                text: ui(lang, opened ? "ui.chat.handover" : "ui.chat.handover.failed", { agent: profile.name }),
+                data: { agent, handover: opened ? "window" : "none", cwd: tree.root, ...(opened === "fallback" ? { terminal: "fallback" } : {}) },
+            };
         }
         const base = {
             root: tree.root,

package/dist/commands/sync.js

@@ -124,7 +124,9 @@ function changeLine(tree, c, incoming, lang) {
         ? "ui.sync.place.located"
         : c.kind === "fact.part"
             ? `ui.sync.fact.part${!c.part ? ".gone" : c.wasPart && c.wasPart.role !== c.part.role ? ".role" : c.wasPart ? ".link" : ""}`
-            : `ui.sync.${c.kind}`;
+            : c.kind === "name.new" && c.married
+                ? "ui.sync.name.married"
+                : `ui.sync.${c.kind}`;
     // the app's sources and what a fact takes from them: said what becomes of them (a reading of a record, or a lead)
     const does = c.kept
         ? "ui.sync.do.kept"
@@ -136,21 +138,23 @@ function changeLine(tree, c, incoming, lang) {
                     ? "ui.sync.do.parents"
                     : c.kind === "name.changed" && c.action === "user"
                         ? "ui.sync.do.name.user"
-                        : 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.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"
-                                                    : `ui.sync.do.${c.action}`;
+                        : 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.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"
+                                                        : `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)}`;

package/dist/core/config.js

@@ -17,6 +17,7 @@ import { acquireLock } from "./lock.js";
 import { defaultAppUrl, isAppVersion, isStromAppOrigin, STROM_APP_BETA_URL, STROM_APP_URL } from "./stromapp.js";
 import { updateChannel } from "./update.js";
 import { WEB_PER_HOST, WEB_SOFT } from "./metrics.js";
+import { TERMINAL_CHOICES, terminalChoices } from "./terminal.js";
 export const PERMISSION_LEVELS = ["ask", "auto", "full"];
 /** Earlier names of the levels, still understood. */
 const PERMISSION_ALIASES = { list: "auto", bypass: "full" };
@@ -88,6 +89,9 @@ export const SETTINGS = [
     { key: "updates", env: "STROM_UPDATES", tree: false, kind: "choice", choices: ["check", "off"], description: "look for new versions of strom: check (default — at most once a day, one small file from the project's releases; strom says so, strom update installs it) or off" },
     { key: "strom.app", env: "", tree: false, kind: "choice", choices: ["yes", "no"], description: "you use the Strom app: yes (strom says which file to import into it), no (strom never mentions it) — unset: strom notices it itself" },
     { key: "app.browser", env: "STROM_APP_BROWSER", tree: false, kind: "choice", choices: ["chrome", "edge", "brave", "opera", "firefox", "chromium"], description: "the browser strom opens the Strom app in — the one its tree came from (strom keeps it), or yours: chrome, edge, brave, opera, firefox, chromium (another Chromium: Vivaldi, Arc). The Strom app installed from a browser always comes first (from this one when it is installed from several); without one, a tab of this browser — unset: of the default browser when the app reaches strom from it, else of the first such browser here" },
+    // This computer's alone (never a research's strom.json: a research is packed and shared, its folder would choose the
+    // program that runs) and never from a link; fixed values only, each a fixed bundle ID (core/terminal.ts).
+    { key: "terminal", env: "STROM_TERMINAL", tree: false, kind: "choice", choices: TERMINAL_CHOICES, description: "the terminal strom opens its windows in (a link from the Strom app, a conversation handed over): system (default: what opens .command files), terminal, iterm2 — macOS; one not installed: the system's (said in the window). Windows: the system's default terminal application decides" },
     // Measured, never typed: strom media calibrate (a person starts it) keeps it per agent and model; unset: the defaults.
     { key: "views.size", env: "", tree: false, kind: "views", description: "the size of the scan views for the research's agent and model: find (a whole image, to find an entry; default 1400 px) and read (a half, a crop, a reader's view; default what the model takes) — set by strom media calibrate, which a person starts; strom config unset views.size returns to the defaults" },
     { key: "tune.transcripts", env: "STROM_TUNE_TRANSCRIPTS", tree: false, kind: "choice", choices: ["on", "off"], description: "the transcripts Claude Code keeps on this computer of the sessions strom started, read to tune how scans are read (the context cleared, files opened again, what each reader cost): on (default — only the tokens of each request, the names of the tools and the files read, never the conversation; nothing leaves this computer) or off (nothing read)" },
@@ -211,8 +215,10 @@ export function checkValue(def, raw, resolvePath, env = {}) {
             return def.key === "model.effort" ? v.toLowerCase() : v;
         case "choice": {
             const c = def.key === "agent.permissions" ? (PERMISSION_ALIASES[v.toLowerCase()] ?? v.toLowerCase()) : v.toLowerCase();
-            if (!def.choices?.includes(c))
-                throw new UsageError(`invalid ${def.key} "${raw}"`, { hint: def.choices?.join(", ") });
+            // the terminal: what this system takes (macOS its terminals, elsewhere the system's alone)
+            const choices = def.key === "terminal" ? terminalChoices() : def.choices;
+            if (!choices?.includes(c))
+                throw new UsageError(`invalid ${def.key} "${raw}"`, { hint: choices?.join(", ") });
             return c;
         }
         case "pace": {
@@ -474,6 +480,19 @@ export class Settings {
         const r = this.resolve("app.browser");
         return r ? String(r.value) : undefined;
     }
+    /**
+     * The terminal strom opens its windows in, if the person chose one (env, else the config; never a tree's). A value of
+     * the config this system does not take (written by hand, by a newer strom, on another system) counts as the system's.
+     */
+    terminal(platform = process.platform) {
+        const r = this.resolve("terminal");
+        return r && r.value !== "system" && terminalChoices(platform).includes(String(r.value)) ? String(r.value) : undefined;
+    }
+    /** The terminal in the config this system does not take (doctor says it, with the way back): none when it takes it. */
+    terminalUnknown(platform = process.platform) {
+        const v = readStored(this.config, "terminal", "");
+        return v !== undefined && !this.env.STROM_TERMINAL && !this.flagOf("terminal") && !terminalChoices(platform).includes(String(v)) ? String(v) : undefined;
+    }
     /** Where the user wants to talk with the agent, if they said (env, else the config); see whereToTalk. */
     agentWhere() {
         const r = this.resolve("agent.where");

package/dist/core/edge.js

@@ -289,12 +289,18 @@ export function treeEdges(tree, opts = {}) {
             const isle = joins.length && onTree ? isles.get(joins[0]) : undefined;
             // the variants that would make the join: those that name the people off the tree
             const variants = joins.length ? joiningVariants(tree, h, onTree ? joins : (isles.get(p.id)?.people ?? [p.id])) : [];
+            const each = joins.map((j) => {
+                const named = joiningVariants(tree, h, [j]);
+                const own = onTree ? isles.get(j) : undefined;
+                return { person: j, ...(named.length ? { variants: named } : {}), ...(own ? { island: { people: own.people.length, held: own.held } } : {}) };
+            });
             return {
                 id: h.id,
                 question: h.question,
                 joins,
                 ...(isle ? { island: { people: isle.people.length, held: isle.held } } : {}),
                 ...(variants.length ? { variants } : {}),
+                ...(each.length ? { each } : {}),
                 // a task about it, or one whose words name it ("the baptism … (H0007 B)")
                 tests: tasks.filter((t) => LIVE.has(t.state) && (t.subject.includes(h.id) || namesId(t.what, h.id))).map((t) => t.id),
             };

package/dist/core/import.js

@@ -173,6 +173,30 @@ export function readGedName(n, file) {
     const nameless = file.app && !surn && (file.unknownIsNoSurname ? /^\?\s*\/\s*(?:Unknown\s*)?\/$/u : /^\?\s*\/\s*\/$/u).test(n.value.trim());
     return { name, nameless };
 }
+/**
+ * The married names a file gives as _MARNM (Legacy, PAF and other programs): under a NAME (2 _MARNM) of that name's
+ * given name, under the person (1 _MARNM) of their first name's. A value with slashes is a whole name, else a surname.
+ * Read the same way by strom intake and strom sync.
+ */
+export function marnmNames(r, givenOf) {
+    const out = [];
+    const add = (value, given) => {
+        const v = value.replace(/\s+/g, " ").trim();
+        if (!v)
+            return;
+        const n = v.includes("/") ? parseName(v) : { given: "", surname: v };
+        const name = { given: n.given || given, surname: n.surname, kind: "married" };
+        if ((name.given || name.surname) && !out.some((x) => sameName(x, name)))
+            out.push(name);
+    };
+    const names = children(r, "NAME");
+    for (const n of names)
+        for (const m of children(n, "_MARNM"))
+            add(m.value, givenOf(n));
+    for (const m of children(r, "_MARNM"))
+        add(m.value, names[0] ? givenOf(names[0]) : "");
+    return out;
+}
 export function importGedcom(tree, text, opts) {
     const { records, problems } = parseGedcomText(text);
     /** A file of the Strom app (its HEAD: 1 SOUR STROM): its own ways of writing are read as it means them. */
@@ -334,16 +358,21 @@ export function importGedcom(tree, text, opts) {
             tree.put(rec, op);
             return true;
         };
-        const namesOf = (r) => children(r, "NAME")
-            .map((n) => {
-            const found = readGedName(n, fromApp).name;
-            // a word that describes the person in place of a name (stillborn, son): the name is "?", the word goes to a note
-            if (notAName(found.given))
-                found.given = "?";
-            // a slash inside a name ("/⟨K/Č⟩emenská/") is kept as "|": the name stays one GEDCOM can write
-            return { ...found, given: found.given.replace(/\//g, "|"), surname: found.surname.replace(/\//g, "|") };
-        })
-            .map((n) => (n.given || n.surname ? n : { ...n, given: "?", surname: "" }));
+        const namesOf = (r) => {
+            const names = children(r, "NAME")
+                .map((n) => {
+                const found = readGedName(n, fromApp).name;
+                // a word that describes the person in place of a name (stillborn, son): the name is "?", the word goes to a note
+                if (notAName(found.given))
+                    found.given = "?";
+                // a slash inside a name ("/⟨K/Č⟩emenská/") is kept as "|": the name stays one GEDCOM can write
+                return { ...found, given: found.given.replace(/\//g, "|"), surname: found.surname.replace(/\//g, "|") };
+            })
+                .map((n) => (n.given || n.surname ? n : { ...n, given: "?", surname: "" }));
+            // a married name other programs give apart (_MARNM): a name of the married kind, unless the person has it already
+            const given = (n) => (notAName(readGedName(n, fromApp).name.given) ? "" : readGedName(n, fromApp).name.given.replace(/\//g, "|"));
+            return [...names, ...marnmNames(r, given).filter((m) => !names.some((n) => sameName(n, m)))];
+        };
         /** The Strom app keeps what a birth or death entry adds in the person's note ("Úmrtí: Věk: 61 let"): back to the fact; the other lines are returned. */
         const factNotes = (r, personEvents) => {
             const personNotes = [];

package/dist/core/live.js

@@ -679,7 +679,7 @@ function idsOf(applied, known) {
     return Object.keys(ids.persons).length || Object.keys(ids.sources).length ? { ids } : {};
 }
 /** What the bridge does that an app may ask about (each added once, never taken away). */
-export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes", "hypothesis.links", "status.recent", "spend.readers", "hypothesis.intree", "archive.permission", "task.check", "waiting.groups", "waiting.sent", "waiting.note", "batch.kept", "live.end", "whats.new"];
+export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes", "hypothesis.links", "status.recent", "spend.readers", "hypothesis.intree", "archive.permission", "task.check", "waiting.groups", "waiting.sent", "waiting.note", "batch.kept", "live.end", "whats.new", "terminal.choice", "person.marriedSurname"];
 /** /status recent, when it is ready. */
 function recentOf(root, env, head) {
     const recent = head ? recentNow(root, env, head) : undefined;

package/dist/core/shortcut.js

@@ -9,6 +9,8 @@ import { configDir, desktopDir, userHome } from "./paths.js";
 import { stromLauncher } from "./self.js";
 import { isAgentMark } from "./which.js";
 import { assetPath } from "./assets.js";
+import { macTerminal } from "./terminal.js";
+import { ui } from "../cli/ui.js";
 /** Strom Research's icon, as each system takes it. */
 export const ICON = { png: assetPath("icon", "icon-512.png"), ico: assetPath("icon", "icon.ico") };
 /** Where the Windows shortcut's command file lives (the desktop has the .lnk with the icon). */
@@ -97,7 +99,11 @@ export function createShortcut(name, env, platform = process.platform) {
  */
 /** One handover window at a time: another asked within this long is not opened. */
 export const HANDOVER_GAP_MS = 15_000;
-export function openInNewTerminal(argv, cwd, env, platform = process.platform) {
+/**
+ * `terminal`: the one the person chose (core/terminal.ts; macOS) — opened by its bundle ID; not installed: the system's,
+ * the window saying so first in `lang` ("fallback").
+ */
+export function openInNewTerminal(argv, cwd, env, platform = process.platform, opts = {}) {
     if (env.STROM_NO_OPEN === "1")
         return false;
     const { command, args } = stromLauncher();
@@ -129,6 +135,23 @@ export function openInNewTerminal(argv, cwd, env, platform = process.platform) {
     const body = ["#!/bin/sh", 'rm -f -- "$0"', ...(marks.length ? [`unset ${marks.join(" ")}`] : []), ...own.map(([k, v]) => `export ${k}=${q(v)}`), "export STROM_HANDOVER=1", `cd ${q(cwd)}`, `exec ${[command, ...args, ...argv].map(q).join(" ")}`, ""];
     fs.writeFileSync(file, body.join("\n"), { mode: 0o755 });
     fs.chmodSync(file, 0o755);
+    // macOS, a terminal chosen: opened by its bundle ID (LaunchServices, as a double-click: no permission asked); not
+    // installed (open says so), the system's — the window says it first, then goes on
+    const chosen = macTerminal(opts.terminal, platform);
+    if (chosen) {
+        const r = spawnSync("open", ["-b", chosen.id, file], { stdio: "ignore", timeout: 15_000, env: env });
+        if (r.status === 0 || (r.status === null && r.error?.code !== "ENOENT"))
+            return true;
+        if (r.status === null)
+            return false; // no open here
+        const lang = opts.lang ?? "en";
+        const said = ui(lang, "ui.terminal.missing", { name: ui(lang, `ui.terminal.name.${opts.terminal}`) });
+        fs.writeFileSync(file, [body[0], body[1], `printf '%s\\n\\n' ${q(said)}`, ...body.slice(2)].join("\n"), { mode: 0o755 });
+        const o = spawn("open", [file], { detached: true, stdio: "ignore", env: env });
+        o.on("error", () => undefined);
+        o.unref();
+        return "fallback";
+    }
     // macOS: a .command file opens in Terminal. Linux: the desktop's terminal, when there is one.
     const how = platform === "darwin"
         ? [["open", [file]]]

package/dist/core/sync.js

@@ -27,7 +27,7 @@ import { phrase } from "./phrases.js";
 import { addChild, addEvent, addFamily, addName, addNote, editEvent, editPerson, retractEvent, retractPerson } from "./actions.js";
 import { exportGedcom, REFN_TYPE } from "../gedcom/export.js";
 import { children, parseGedcomText, val } from "../gedcom/parse.js";
-import { fromFlexDate, houseOf, importDate, readGedName, readGedSex, stromAppFile } from "./import.js";
+import { fromFlexDate, houseOf, importDate, marnmNames, readGedName, readGedSex, stromAppFile } from "./import.js";
 import { humanAge, normalizeAge } from "./age.js";
 import { dateYears } from "./gdate.js";
 import { create, update } from "./records.js";
@@ -42,7 +42,7 @@ import { now, Tree, typeOfId } from "./tree.js";
 import { actsAsArchive } from "./state.js";
 import { appSides } from "./conflicts.js";
 import { APP_DATA_SEX_UNKNOWN, isAppVersion } from "./stromapp.js";
-import { cleanTitle, familiesAsPartner, formatName, foundTitles, gedcomTitledName, primaryName, titledName } from "./people.js";
+import { cleanTitle, familiesAsPartner, formatName, foundTitles, gedcomTitledName, parseName, primaryName, sameName as sameWords, titledName } from "./people.js";
 /** The words of a _STAT (the Strom app's own, also Legacy's and FTM's) as a union, or nothing it names. */
 function unionOfStat(value) {
     const v = (value ?? "").trim().toLowerCase();
@@ -532,9 +532,17 @@ export function readGedcom(text) {
         const titles = named[0] ? titlesFrom(named[0].name.prefix, named[0].name.suffix) : undefined;
         // (the research's own person: no name at all, as the research writes it — never another name, never a rename);
         // what stands for no name ("N/A /Chrpa/", "N.N.") is the research's "?" (T08)
-        const names = named
-            .filter(({ nameless }) => !(ours && nameless))
-            .map(({ name, nameless }, i) => (nameless ? "? //" : gedcomTitledName(i === 0 && titles ? { given: name.given, surname: name.surname } : name)));
+        const kept = named.filter(({ nameless }) => !(ours && nameless));
+        const names = kept.map(({ name, nameless }, i) => (nameless ? "? //" : gedcomTitledName(i === 0 && titles ? { given: name.given, surname: name.surname } : name)));
+        // the names after a marriage (TYPE married; another program's _MARNM, a name of its own), never the one shown
+        const married = names.filter((_, i) => i > 0 && kept[i].name.kind === "married");
+        for (const m of names.length ? marnmNames(r, (n) => readGedName(n, fromApp).name.given) : []) {
+            const line = gedcomTitledName(m);
+            if (names.some((n) => nameKey(n) === nameKey(line)))
+                continue;
+            names.push(line);
+            married.push(line);
+        }
         // a placeholder of the Strom app (an unknown parent drawn in the tree): nobody
         if (!ours && !names.length)
             continue;
@@ -557,6 +565,7 @@ export function readGedcom(text) {
             said: allNotes(r, noteText),
             ...(cites.length ? { cites } : {}),
             ...(titles ? { titles } : {}),
+            ...(married.length ? { married } : {}),
         });
     }
     // how a child belongs to a family (the child's FAMC + PEDI: adopted, foster, step): none said is birth
@@ -778,10 +787,16 @@ export function readStromJson(data) {
         }
         const cites = citesOf(p.sourceIds);
         const titles = titlesFrom(p.titleBefore, p.titleAfter);
+        // the surname after the marriage (spec 010) with the person's first name: a name of the married kind, after the one
+        // shown and before the other forms (as the app's GEDCOM gives it)
+        const marriedSurname = typeof p.marriedSurname === "string" ? p.marriedSurname.replace(/[/\s]+/g, " ").trim() : "";
+        const married = marriedSurname ? `${p.firstName ?? ""} /${marriedSurname}/`.trim() : undefined;
+        const names = [name, ...(married ? [married] : []), ...(p.nameVariants ?? [])].filter((n) => n.replace(/[/?\s]/g, ""));
         persons.set(key, {
             key,
             ...(titles ? { titles } : {}),
-            names: [name, ...(p.nameVariants ?? [])].filter((n) => n.replace(/[/?\s]/g, "")),
+            names: names.filter((n, i) => n !== married || names.findIndex((m) => nameKey(m) === nameKey(n)) === i),
+            ...(married && names.findIndex((n) => nameKey(n) === nameKey(married)) > 0 ? { married: [married] } : {}),
             // the sex left unknown a value like the others (U01): the app's gender unknown from its data version 12, the
             // research's unknown standing beside its stand-in (research.sexU) before it; else male and female only — a gender
             // missing says nothing of it (B5-d)
@@ -2091,6 +2106,48 @@ export function planSync(tree, incoming, edits, opts = {}) {
                 push({ kind: "note.new", action: "add", ...owner, text: out.join("\n") });
         }
     };
+    /**
+     * The names after a marriage (spec 010; the Strom app keeps one, the last, with its own first name): the same by its
+     * surname — "Marie /Nováková/" of the app is the research's "Maria /Nováková/". One the research lacks is added of
+     * the married kind (a name of the research the file now says is one after a marriage: that kind); one the app was
+     * given and no longer has (taken off, or changed: the new one added) goes where only the user's edits or other
+     * family trees gave it, a record's stays (said) — never the name they are shown by.
+     */
+    const marriedDiff = (id, name, p, o, b) => {
+        const surname = (n) => exact(/\/([^/]*)\//.exec(n)?.[1] ?? "");
+        const same = (n, list) => list.some((m) => nameKey(m) === nameKey(n) || (!!surname(n) && surname(m) === surname(n)));
+        const person = tree.get(id);
+        if (!person)
+            return;
+        const ofResearch = (n) => person.names.find((m) => nameKey(gedcomName(m)) === nameKey(n));
+        const shown = o.names[0] ?? "";
+        for (const n of p.married ?? []) {
+            if (same(n, o.married ?? []))
+                continue;
+            const has = ofResearch(n);
+            if (has) {
+                // the research's own words of another kind: the file says they are a name after a marriage
+                if (!has.kind && nameKey(n) !== nameKey(shown))
+                    push({ kind: "name.new", action: "add", person: id, name, text: n, married: true });
+                continue;
+            }
+            // the research took it off since the app was given it: that stays
+            if (b && (b.married ?? []).some((m) => nameKey(m) === nameKey(n)))
+                continue;
+            push({ kind: "name.new", action: "add", person: id, name, text: n, married: true });
+        }
+        if (!b || partial)
+            return;
+        for (const g of b.married ?? []) {
+            // still in the file (as a name after a marriage by its surname, or as another form), or no longer the research's
+            if (p.names.some((n) => nameKey(n) === nameKey(g)) || same(g, p.married ?? []))
+                continue;
+            const mine = ofResearch(g);
+            if (!mine || mine.kind !== "married" || nameKey(g) === nameKey(shown))
+                continue;
+            push({ kind: "name.gone", action: nameBacked(tree, mine) ? "report" : "remove", person: id, name, text: gedcomName(mine) });
+        }
+    };
     // people
     for (const [key, p] of incoming.persons) {
         const name = p.names[0] ?? "?";
@@ -2099,7 +2156,7 @@ export function planSync(tree, incoming, edits, opts = {}) {
             factsDiff({ person: key, name }, p.facts, [], undefined, false);
             citesDiff({ person: key, name }, p.cites, undefined, undefined);
             for (const n of p.names.slice(1))
-                push({ kind: "name.new", action: "add", person: key, name, text: n });
+                push({ kind: "name.new", action: "add", person: key, name, text: n, ...(p.married?.includes(n) ? { married: true } : {}) });
             for (const t of p.notes)
                 push({ kind: "note.new", action: "add", person: key, name, text: t });
             continue;
@@ -2127,9 +2184,11 @@ export function planSync(tree, incoming, edits, opts = {}) {
             const shown = primaryName(tree.get(id));
             push({ kind: "name.changed", action: renamed && !nameBacked(tree, shown) ? "correct" : edits === "user" ? "user" : "conflict", person: id, name, text: now, wasName: mine });
         }
+        const theirMarried = new Set(p.married ?? []);
         for (const n of p.names)
-            if (!((renamed || both) && n === now) && !ourNames.has(nameKey(n)) && !baseNames.has(nameKey(n)))
+            if (!theirMarried.has(n) && !((renamed || both) && n === now) && !ourNames.has(nameKey(n)) && !baseNames.has(nameKey(n)))
                 push({ kind: "name.new", action: "add", person: id, name, text: n });
+        marriedDiff(id, name, p, o, b);
         // the titles of the name they are shown by (T07), each apart and never as a change of the name itself: the user's
         // edit where the file's differs from what the app was given — one the name lacks added, a lead's corrected, a
         // record's name the user's to decide (or their word: sync.edits user, an archive); the research's changed since
@@ -3446,9 +3505,30 @@ export function applySync(tree, plan, incoming, source, only) {
                 case "name.new": {
                     if (!owner || !c.text)
                         break;
+                    // a name of the research the file says is one after a marriage: of that kind now, citing the sync (undo: as it was)
+                    const had = c.married ? tree.get(owner)?.names.find((n) => sameWords(n, parseName(c.text))) : undefined;
                     // beside the name the person is shown by, always last: what the app shows does not move
-                    const { name } = addName(tree, owner, { name: c.text, citation: cite("name"), other: true });
-                    applied.push({ do: "name.add", id: owner, before: exact(`${name.given}|${name.surname}`) });
+                    const { name } = addName(tree, owner, { name: c.text, citation: cite("name"), other: true, ...(c.married ? { kind: "married" } : {}) });
+                    if (had)
+                        applied.push({ do: "name.edit", id: owner, before: JSON.stringify({ name: had, now: exact(`${name.given}|${name.surname}`) }) });
+                    else
+                        applied.push({ do: "name.add", id: owner, before: exact(`${name.given}|${name.surname}`) });
+                    break;
+                }
+                case "name.gone": {
+                    // a name after a marriage taken off in the app that only the user's edits or other family trees gave: off,
+                    // where it stood kept for an undo (a record's stays: only said)
+                    const p = owner && c.action === "remove" && c.text ? tree.get(owner) : undefined;
+                    const at = p ? p.names.findIndex((n) => n.kind === "married" && n !== primaryName(p) && nameKey(gedcomName(n)) === nameKey(c.text) && !nameBacked(tree, n)) : -1;
+                    if (!p || at < 0)
+                        break;
+                    const gone = p.names[at];
+                    update(tree, p.id, "person", (x) => ({ ...x, names: x.names.filter((_, i) => i !== at) }), {
+                        op: "name.remove",
+                        summary: `${p.id} name ${gedcomName(gone)} removed: ${phrase(tree.lang, "archive.removed")}`,
+                        reason: `${phrase(tree.lang, "archive.removed")}: ${reason}`,
+                    });
+                    applied.push({ do: "name.drop", id: p.id, before: JSON.stringify({ name: gone, at }) });
                     break;
                 }
                 case "name.changed": {

package/dist/core/terminal.js

@@ -0,0 +1,70 @@
+// The terminal strom opens its windows in (a link from the Strom app, a
+// conversation handed over): the system's — what opens a .command file — unless
+// the person chose another (terminal, a setting of this computer alone: never a
+// research's strom.json, never a link). macOS only for now: each choice maps to
+// a fixed bundle ID, opened with `open -b`; one not installed: the system's.
+// Windows decides it itself (its default terminal application), Linux keeps its
+// order (core/shortcut.ts).
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { userHome } from "./paths.js";
+export const MAC_TERMINALS = {
+    terminal: { id: "com.apple.Terminal", app: "Terminal.app", name: "Terminal", mark: "Apple_Terminal" },
+    iterm2: { id: "com.googlecode.iterm2", app: "iTerm.app", name: "iTerm2", mark: "iTerm.app" },
+};
+/** Every value of the setting, on any system (the help names them). */
+export const TERMINAL_CHOICES = ["system", ...Object.keys(MAC_TERMINALS)];
+/** The values this system takes: macOS its terminals, elsewhere the system's alone. */
+export function terminalChoices(platform = process.platform) {
+    return platform === "darwin" ? [...TERMINAL_CHOICES] : ["system"];
+}
+/** The chosen terminal of macOS (none: the system's) — one of its own keys only, never one of an object's prototype. */
+export function macTerminal(choice, platform = process.platform) {
+    return platform === "darwin" && choice && Object.hasOwn(MAC_TERMINALS, choice) ? MAC_TERMINALS[choice] : undefined;
+}
+/** The folders apps lie in (STROM_APP_DIRS: folders to look in instead — tests). */
+function appDirs(env) {
+    if (env.STROM_APP_DIRS !== undefined)
+        return env.STROM_APP_DIRS.split(path.delimiter).filter(Boolean);
+    return ["/Applications", "/Applications/Utilities", "/System/Applications/Utilities", path.join(userHome(env), "Applications")];
+}
+/** Ask the system (JXA) — nothing when tests give folders of their own. */
+function jxa(env, js, args = []) {
+    if (env.STROM_APP_DIRS !== undefined)
+        return undefined;
+    const r = spawnSync("osascript", ["-l", "JavaScript", "-e", js, ...args], { encoding: "utf8", timeout: 10_000 });
+    return r.status === 0 ? r.stdout.trim() : undefined;
+}
+/** The terminals of macOS on this computer, in strom's order: by their bundle ID (NSWorkspace), else in the app folders. */
+export function terminalsHere(env, platform = process.platform) {
+    if (platform !== "darwin")
+        return [];
+    const keys = Object.keys(MAC_TERMINALS);
+    const js = 'function run(a){ObjC.import("AppKit");return a.map(function(id){var u=$.NSWorkspace.sharedWorkspace.URLForApplicationWithBundleIdentifier(id);return u.isNil()?"":"y"}).join(",")}';
+    const said = jxa(env, js, keys.map((k) => MAC_TERMINALS[k].id))?.split(",");
+    return keys.filter((k, i) => said?.[i] === "y" || appDirs(env).some((d) => fs.existsSync(path.join(d, MAC_TERMINALS[k].app))));
+}
+/** Is the chosen terminal on this computer? (the system's always is) */
+export function terminalHere(choice, env, platform = process.platform) {
+    return !macTerminal(choice, platform) || terminalsHere(env, platform).includes(choice);
+}
+/** What opens a .command file here (the system's terminal), when the system says: one of the choices, else its name. */
+export function systemTerminal(env, platform = process.platform) {
+    if (platform !== "darwin")
+        return undefined;
+    const js = 'ObjC.import("CoreServices");ObjC.import("AppKit");var r=$.LSCopyDefaultRoleHandlerForContentType($("com.apple.terminal.shell-script"),$.kLSRolesAll);var id=r?ObjC.castRefToObject(r):$();var s=id.isNil()?"":id.js;var u=s?$.NSWorkspace.sharedWorkspace.URLForApplicationWithBundleIdentifier(s):$();s+"\\n"+(s&&!u.isNil()?$.NSFileManager.defaultManager.displayNameAtPath(u.path).js:"")';
+    const said = jxa(env, js);
+    if (!said)
+        return undefined;
+    const [id, shown] = said.split("\n");
+    const choice = Object.keys(MAC_TERMINALS).find((k) => MAC_TERMINALS[k].id.toLowerCase() === id?.toLowerCase());
+    if (choice)
+        return { choice, name: MAC_TERMINALS[choice].name };
+    const name = shown?.replace(/\.app$/u, "");
+    return name ? { name } : undefined;
+}
+/** The terminal a window runs in, by its mark (TERM_PROGRAM): one of the choices, else none. */
+export function terminalOfMark(mark) {
+    return Object.keys(MAC_TERMINALS).find((k) => MAC_TERMINALS[k].mark === mark);
+}

package/dist/core/tree.js

@@ -27,7 +27,7 @@ import { lastBackup } from "./backup.js";
 export const TREE_FILE = "strom.json";
 // between releases the candidate being made (a bridge run from the sources says what it is: the Strom app goes by it);
 // at a release the release's own (package.json)
-export const VERSION = "1.15.0";
+export const VERSION = "1.16.0-beta.2";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/dist/gedcom/export.js

@@ -725,8 +725,18 @@ export function exportGedcom(tree, opts = {}) {
             w.line(2, "_TRIED", id);
         for (const h of e.hypotheses) {
             w.line(2, "_HYPO", h.id);
-            for (const j of h.joins)
-                w.line(3, "_JOIN", j);
+            for (const j of h.each ?? []) {
+                w.line(3, "_JOIN", j.person);
+                // each join on its own: the variants that name the person, the family off the tree it belongs to (an older app
+                // passes level 4 by and takes the numbers of the hypothesis, those of the first join)
+                if (opts.hypothesisLinks)
+                    for (const v of j.variants ?? [])
+                        w.line(4, "_VAR", v);
+                if (j.island) {
+                    w.line(4, "_ISLAND", String(j.island.people));
+                    w.line(4, "_HELD", String(j.island.held));
+                }
+            }
             // which variant would make the join (an app that shows what a hypothesis would connect)
             if (opts.hypothesisLinks)
                 for (const v of h.variants ?? [])

package/dist/gedcom/validate.js

@@ -29,6 +29,8 @@ const CHILDREN = {
     "INDI._STROM_SEARCHED": ["TITL", "DATE", "RESN", "_AT"],
     "INDI._STROM_EDGE": ["_SCOPE", "_RESEARCH", "_GEN", "_END", "_NEXT", "_EST", "DATE", "_RECORDS", "_BOOK", "_COVERED", "_NORECORDS", "_TASK", "_TRIED", "_HYPO", "_CONFLICT", "_SEARCHES", "_SESSIONS", "_LAST"],
     "INDI._STROM_ISLAND": ["_HYPO", "_HELD"],
+    // one join of a hypothesis at the edge: the variants that name the person, the family off the tree it belongs to
+    "_STROM_EDGE._JOIN": ["_VAR", "_ISLAND", "_HELD"],
     // a value of a conflict the app decides by side: its side, a sex as M, F or U
     _STROM_VALUE: ["SOUR", "_STROM_SIDE", "_STROM_RAW"],
     "INDI.NAME": ["TYPE", "GIVN", "SURN", "NPFX", "NSFX", "NICK", "SPFX", "SOUR", "NOTE"],
@@ -90,6 +92,8 @@ function contextOf(anc) {
         return "_LINK";
     if (parent === "_INTREE" && anc[2] === "_VAR")
         return "_INTREE";
+    if (parent === "_JOIN" && anc[1] === "_STROM_EDGE" && anc[2] === "_HYPO")
+        return "_STROM_EDGE._JOIN";
     if (parent === "ADDR")
         return "ADDR";
     if (parent === "DATA" && anc[depth - 2] === "SOUR")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.15.0",
+  "version": "1.16.0-beta.2",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {
@@ -48,5 +48,8 @@
   "devDependencies": {
     "@types/node": "^22.20.4",
     "typescript": "^7.0.2"
+  },
+  "publishConfig": {
+    "tag": "beta"
   }
 }