strom-research 1.16.0-beta.1 → 1.16.0-beta.2

package/CHANGELOG.cs.md

@@ -7,11 +7,19 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 
 ## 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

package/CHANGELOG.de.md

@@ -7,11 +7,21 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 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

package/CHANGELOG.md

@@ -7,11 +7,19 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 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

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}",

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/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.16.0-beta.1";
+export const VERSION = "1.16.0-beta.2";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.16.0-beta.1",
+  "version": "1.16.0-beta.2",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {