strom-research 1.13.0-beta.4 → 1.13.0-beta.5

package/assets/lang/cs.json

@@ -278,6 +278,7 @@
   "ui.doc.appurl": "adresa aplikace Strom",
   "ui.doc.appurl.config": "nastavení strom.app.url „{value}“ není adresa aplikace Strom – strom app nic neotevře, dokud se neopraví nebo neodebere",
   "ui.doc.appurl.env": "proměnná STROM_APP_URL „{value}“ není adresa aplikace Strom – strom app nic neotevře, dokud se neopraví nebo neodebere",
+  "ui.doc.appurl.env.fix": "proměnnou STROM_APP_URL nastavit na adresu aplikace Strom ({web}, nebo její kopie na tomto počítači http://127.0.0.1:<port>/), nebo odebrat",
   "ui.doc.tree.ok": "{name}: data v pořádku a zapečetěná",
   "ui.doc.tree.bad": "{name}: problémů {n}",
   "ui.doc.allok": "Všechno potřebné je na místě.",
@@ -849,11 +850,12 @@
   "ui.live.app": "  aplikace Strom ho sleduje na adrese: {url}",
   "ui.live.stophow": "  zastavit: strom live stop",
   "ui.live.none": "most neběží – strom live start (nebo strom app --live)",
-  "ui.live.moved": "  má novou adresu (starý port byl obsazený): aplikace Strom ji najde, až v ní výzkum znovu otevře – strom app --live",
+  "ui.live.moved": "  má novou adresu: aplikace Strom ji najde, až v ní výzkum znovu otevře – strom app --live",
   "ui.live.stopped": "most se zastavil",
   "ui.live.killed": "most neskončil, když byl požádán: byl ukončen natvrdo",
   "ui.live.noneran": "žádný most neběžel",
   "ui.live.forgotten": "jeho adresa je zapomenutá: další most dostane novou",
+  "ui.live.newsecret": "  další most dostane novou tajnou adresu: aplikace Strom ji dostane při dalším otevření výzkumu – strom app",
   "ui.live.ended": "most skončil",
   "ui.guide.archive": "Tento rodokmen je archiv: data přicházejí z aplikace Strom. Co v něm je: strom stats · strom person card <kdo> · strom pedigree <kdo> · strom recent. Výzkum zapíná jen uživatel: strom mode research (nebo menu).",
   "ui.setup.links.archive": "Dovolit aplikaci Strom otevírat archiv na tomto počítači? (Jedním klikem pošle úpravy zpět nebo otevře výřez v plné kvalitě – vždy se tu nejdřív zeptá.)",

package/assets/lang/de.json

@@ -278,6 +278,7 @@
   "ui.doc.appurl": "Adresse der Strom-App",
   "ui.doc.appurl.config": "die Einstellung strom.app.url „{value}“ ist keine Adresse der Strom-App – strom app öffnet nichts, bis sie berichtigt oder entfernt ist",
   "ui.doc.appurl.env": "die Variable STROM_APP_URL „{value}“ ist keine Adresse der Strom-App – strom app öffnet nichts, bis sie berichtigt oder entfernt ist",
+  "ui.doc.appurl.env.fix": "die Variable STROM_APP_URL auf eine Adresse der Strom-App setzen ({web}, oder eine Kopie auf diesem Computer http://127.0.0.1:<port>/) oder entfernen",
   "ui.doc.tree.ok": "{name}: Daten in Ordnung und versiegelt",
   "ui.doc.tree.bad": "{name}: Probleme: {n}",
   "ui.doc.allok": "Alles Nötige ist vorhanden.",
@@ -849,11 +850,12 @@
   "ui.live.app": "  die Strom-App folgt ihr unter: {url}",
   "ui.live.stophow": "  anhalten: strom live stop",
   "ui.live.none": "die Brücke läuft nicht – strom live start (oder strom app --live)",
-  "ui.live.moved": "  sie hat eine neue Adresse (der alte Port war belegt): die Strom-App findet sie, wenn die Forschung darin wieder geöffnet wird – strom app --live",
+  "ui.live.moved": "  sie hat eine neue Adresse: die Strom-App findet sie, wenn die Forschung darin wieder geöffnet wird – strom app --live",
   "ui.live.stopped": "die Brücke ist angehalten",
   "ui.live.killed": "die Brücke endete nicht auf Bitte: sie wurde hart beendet",
   "ui.live.noneran": "keine Brücke lief",
   "ui.live.forgotten": "ihre Adresse ist vergessen: die nächste Brücke bekommt eine neue",
+  "ui.live.newsecret": "  die nächste Brücke bekommt eine neue geheime Adresse: die Strom-App bekommt sie beim nächsten Öffnen der Forschung – strom app",
   "ui.live.ended": "die Brücke ist beendet",
   "ui.guide.archive": "Dieser Stammbaum ist ein Archiv: die Daten kommen aus der Strom-App. Was er enthält: strom stats · strom person card <wer> · strom pedigree <wer> · strom recent. Die Forschung schaltet nur der Benutzer ein: strom mode research (oder das Menü).",
   "ui.setup.links.archive": "Der Strom-App erlauben, das Archiv auf diesem Computer zu öffnen? (Ein Klick schickt die Änderungen zurück oder öffnet einen Ausschnitt in voller Qualität – jeweils erst hier gefragt.)",

package/dist/agents/files.js

@@ -12,12 +12,15 @@ import { writeFileAtomic } from "../core/json.js";
 import { PROFILES, SELF_READING } from "./profiles.js";
 import { isArchive } from "../core/mode.js";
 import { Settings } from "../core/config.js";
+import { agentAppUrl, appSite } from "../core/stromapp.js";
 import { configDir } from "../core/paths.js";
 import { agentBrowser } from "../core/connector.js";
 import { CHROME_ALLOW, CHROME_DENY, chromeDomain } from "../core/browser.js";
 export const MARKER = "<!-- strom: generated above this line (strom agents sync); your own notes below are kept -->";
 function agentsMd(tree) {
     const lang = langName(tree.config.lang);
+    // the Strom app's address as strom app opens it now (the beta its beta, strom.app.url where it says another)
+    const app = agentAppUrl(tree.env);
     return `# Family research: ${tree.config.name}
 
 This folder is a family tree researched with **strom**, a command-line tool
@@ -99,12 +102,12 @@ they ask.
 - **What waits for them** (\`strom\` shows it): tell them plainly what to do
   and where, one thing at a time.
 - **Results and the Strom app**: \`output/tree-strom.ged\` is the family tree
-  for the Strom app (https://stromapp.info) — strom's companion: a free family
+  for the Strom app (${appSite(app)}) — strom's companion: a free family
   tree app, no account, their data stay on their computer; it shows the tree,
   the sources, a map, a family book. When they want to see the results, or
   when \`strom\` says to offer it (it does once, not in every conversation),
   suggest it gently, in a sentence or two: best installed as an app from the browser, from
-  https://stromapp.info/run/ — \`strom app install\` opens it there and says
+  ${app} — \`strom app install\` opens it there and says
   where to click; it works offline then; \`strom app\` opens it, with this
   research when the app can take it — run by you, the app then follows the
   research live, what you record shows there by itself (else in the app:

package/dist/agents/global.js

@@ -16,9 +16,11 @@ import path from "node:path";
 import { isolated, userHome } from "../core/paths.js";
 import { writeFileAtomic } from "../core/json.js";
 import { installation } from "../core/self.js";
+import { agentAppUrl, appSite } from "../core/stromapp.js";
 const BEGIN = "<!-- strom: begin (strom agents install; removed by strom agents uninstall) -->";
 const END = "<!-- strom: end -->";
-export const GLOBAL_TEXT = `# strom — family history research
+/** What the agents are taught; app: the Strom app's address it names — the one `strom app` opens when it is written (agentAppUrl). */
+export const globalText = (app) => `# strom — family history research
 
 strom (the \`strom\` command) is installed on this computer: a tool for
 researching a family's history with you as the researcher — people, parish
@@ -57,11 +59,11 @@ mentions strom, a family tree or the Strom app.
 8. Scans come through strom. An archive the research needs has no
    downloader (connector) yet: build one yourself, unasked
    (\`strom connector new\`), and tell the user in a sentence.
-9. The Strom app (https://stromapp.info) is strom's companion: a free family
+9. The Strom app (${appSite(app)}) is strom's companion: a free family
    tree app, no account, the data stay on the user's computer. The research's
    result (\`output/tree-strom.ged\`) opens in it. When the user wants to see
    the tree (or \`strom\` says to offer it — once), suggest it gently — best installed as an app from the browser,
-   from https://stromapp.info/run/ (\`strom app install\` opens it there; it
+   from ${app} (\`strom app install\` opens it there; it
    then works offline); \`strom app\` opens it — with the research, followed
    live while you work, when the app can take it. Without it, the user can ask
    you about anyone in the tree: answer from \`strom person show\` and the like.
@@ -149,7 +151,9 @@ export function globalTargets(env) {
     if (isolated(env))
         return [];
     const home = userHome(env);
-    return [
+    // the app's address as strom app opens it now: a run of another channel (its first) writes the texts again
+    const app = agentAppUrl(env);
+    const targets = [
         { agent: "claude", file: path.join(env.CLAUDE_CONFIG_DIR ?? path.join(home, ".claude"), "skills", "strom", "SKILL.md"), kind: "own" },
         { agent: "claude", file: path.join(env.CLAUDE_CONFIG_DIR ?? path.join(home, ".claude"), "settings.json"), kind: "allow" },
         { agent: "codex", file: path.join(env.CODEX_HOME ?? path.join(home, ".codex"), "AGENTS.md"), kind: "block" },
@@ -161,13 +165,14 @@ export function globalTargets(env) {
         { agent: "grok", file: path.join(grokDir(env), "skills", "strom", "SKILL.md"), kind: "own" },
         { agent: "grok", file: path.join(grokDir(env), "config.toml"), kind: "allow" },
     ];
+    return targets.map((t) => ({ ...t, app }));
 }
-const SKILL = `---
+const skill = (app) => `---
 name: strom
 description: Family history and genealogy research with the strom command — ancestors, family trees, parish registers and archives, evidence, GEDCOM and the Strom app. Use when the user wants to research their family or mentions strom or the Strom app.
 ---
 
-${GLOBAL_TEXT}`;
+${globalText(app)}`;
 function read(file) {
     try {
         return fs.readFileSync(file, "utf8");
@@ -282,10 +287,10 @@ export function installGlobal(t) {
         next = JSON.stringify(s, null, 2) + "\n";
     }
     else if (t.kind === "own")
-        next = t.agent === "claude" || t.agent === "grok" ? SKILL : GLOBAL_TEXT;
+        next = t.agent === "claude" || t.agent === "grok" ? skill(t.app) : globalText(t.app);
     else {
         const rest = cur ? withoutBlock(cur).replace(/\s+$/, "") : "";
-        next = `${rest ? `${rest}\n\n` : ""}${BEGIN}\n${GLOBAL_TEXT}${END}\n`;
+        next = `${rest ? `${rest}\n\n` : ""}${BEGIN}\n${globalText(t.app)}${END}\n`;
     }
     if (cur === next)
         return false;

package/dist/cli/context.js

@@ -16,7 +16,7 @@ import { readJsonIfExists } from "../core/json.js";
 import { foldText } from "../core/text.js";
 import { currentSession } from "../core/session.js";
 import { isAgent } from "../core/which.js";
-import { systemDialog, WAIT_SECONDS } from "../core/dialog.js";
+import { canShowDialog, systemDialog, WAIT_SECONDS } from "../core/dialog.js";
 import { UI, ui } from "./ui.js";
 export class Context {
     env;
@@ -179,7 +179,8 @@ export class Context {
         const agent = isAgent(this.env);
         if (this.interactive && !agent)
             return "terminal";
-        if (this.env.STROM_NONINTERACTIVE !== "1" && opts.window !== false) {
+        // a window only where one can be shown (the test's own answer stands for one): else nothing said to wait in it
+        if (this.env.STROM_NONINTERACTIVE !== "1" && opts.window !== false && (this.io.dialog || canShowDialog(this.env))) {
             const lang = this.uiLang();
             const text = { title: ui(lang, "ui.dialog.title"), question: says ?? question, yes: ui(lang, "ui.dialog.yes"), no: ui(lang, "ui.dialog.no") };
             // said first where it runs: a window can be behind others, and the command waits for it without a word

package/dist/cli/ui.js

@@ -245,6 +245,7 @@ export const UI = {
     "ui.doc.appurl": "address of the Strom app",
     "ui.doc.appurl.config": "the setting strom.app.url \"{value}\" is no address of the Strom app — strom app opens nothing until it is set right or removed",
     "ui.doc.appurl.env": "the variable STROM_APP_URL \"{value}\" is no address of the Strom app — strom app opens nothing until it is set right or removed",
+    "ui.doc.appurl.env.fix": "the variable STROM_APP_URL set to an address of the Strom app ({web}, or a copy on this computer http://127.0.0.1:<port>/), or removed",
     "ui.doc.tree.ok": "{name}: data consistent and sealed",
     "ui.doc.tree.bad": "{name}: {n} problem(s)",
     "ui.doc.allok": "Everything needed is in place.",
@@ -765,11 +766,12 @@ export const UI = {
     "ui.live.app": "  the Strom app following it: {url}",
     "ui.live.stophow": "  stop: strom live stop",
     "ui.live.none": "the bridge does not run — strom live start (or strom app --live)",
-    "ui.live.moved": "  its address is new (its old port was taken): the Strom app finds it when the research is opened in it again — strom app --live",
+    "ui.live.moved": "  its address is new: the Strom app finds it when the research is opened in it again — strom app --live",
     "ui.live.stopped": "the bridge stopped",
     "ui.live.killed": "the bridge did not end when asked: it was ended for good",
     "ui.live.noneran": "no bridge ran",
     "ui.live.forgotten": "its address is forgotten: the next bridge gets a new one",
+    "ui.live.newsecret": "  the next bridge gets a new secret address: the Strom app gets it when the research is opened in it again — strom app",
     "ui.live.ended": "the bridge ended",
     "ui.guide.archive": "This family tree is an archive: the data come from the Strom app. What it holds: strom stats · strom person card <who> · strom pedigree <who> · strom recent. Research is switched on by the user alone: strom mode research (or the menu).",
     "ui.setup.links.archive": "Let the Strom app open the archive on this computer? (One click sends the edits back or opens an excerpt in full quality — each asked here first.)",

package/dist/commands/guide.js

@@ -3,7 +3,9 @@
 // sessions and costs tokens every time. Every command in it must exist
 // (test/cli/examples.test.ts checks them against the registry).
 import { langName } from "../core/lang.js";
-export function guideText(lang) {
+import { appSite } from "../core/stromapp.js";
+/** The guide; appUrl: the Strom app's address it names — the one `strom app` opens (appUrlShown). */
+export function guideText(lang, appUrl) {
     const language = lang
         ? `The research language of this tree is ${langName(lang)} (${lang}): talk to the user in ${langName(lang)} and write notes, tasks and stories in ${langName(lang)}. Keep transcripts of records in their original language.`
         : "Talk to the user in their language. Set it as the research language: strom setup --lang <code> (cs, en, de, pl, …).";
@@ -181,11 +183,11 @@ output/tree-strom.ged (for the Strom app) — both from the same evidence, also
 Changes are committed automatically; you never run git yourself.
 
 THE STROM APP — where the user sees the result
-  The Strom app (https://stromapp.info) is strom's companion: a free family tree app, no account,
+  The Strom app (${appSite(appUrl)}) is strom's companion: a free family tree app, no account,
   the family's data stay on their computer; it shows the tree, the sources, a map, a family book.
   When the user wants to see the results, or when strom says to offer it (once, not in every
   conversation), suggest it gently, in a sentence or two — best installed as an app from the browser, then it works offline:
-  https://stromapp.info/run/   the app itself: opened in the browser, installed from there (the
+  ${appUrl}   the app itself: opened in the browser, installed from there (the
                         install icon at the end of the address bar; Safari: File → Add to Dock)
   strom app install     opens it there and says where to click
   strom app             opens it — with this research when the app can take it (strom says so), and

package/dist/commands/meta.js

@@ -209,7 +209,7 @@ register({
             const said = ui(ctx.tree().lang, "ui.guide.archive");
             return { text: said, data: { guide: said, lang, archive: true } };
         }
-        const text = guideText(lang);
+        const text = guideText(lang, appUrlShown(ctx.settings).url);
         return { text, data: { guide: text, lang } };
     },
 }, {

package/dist/commands/setup.js

@@ -5,7 +5,7 @@ import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { APP_URL_INVALID_SETTING, register } from "../cli/registry.js";
 import { lines, table } from "../cli/format.js";
-import { checkValue, configFile, DEFAULT_BUDGET, DEFAULT_RUN_MINUTES, OTHER_ENV, SETTINGS, settingDef, writeStored } from "../core/config.js";
+import { appWebPages, checkValue, configFile, DEFAULT_BUDGET, DEFAULT_RUN_MINUTES, OTHER_ENV, SETTINGS, settingDef, settingDescription, writeStored } from "../core/config.js";
 import { syncAgentFiles } from "../agents/files.js";
 import { gitVersion } from "../core/git.js";
 import { linuxGitCommand } from "../core/deps.js";
@@ -361,7 +361,9 @@ function diagnose(ctx) {
     // settings) is a problem said with its way out — doctor never fails on it (strom app refuses to open it)
     const appUrl = appUrlSetting(ctx.settings).invalid;
     if (appUrl)
-        add("appurl", "fail", t(appUrl.source === "env" ? "ui.doc.appurl.env" : "ui.doc.appurl.config", { value: appUrl.value }), appUrl.source === "env" ? undefined : placeholders(lang, "strom config set strom.app.url <address> · strom config unset strom.app.url"));
+        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"));
     // …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);
@@ -762,7 +764,7 @@ register({
     run(ctx) {
         const rows = SETTINGS.map((def) => {
             const r = effective(ctx, def);
-            return { key: def.key, value: r.value, source: r.source, env: def.env, tree: def.tree, description: def.description, ...(r.invalid ? { invalid: true } : {}) };
+            return { key: def.key, value: r.value, source: r.source, env: def.env, tree: def.tree, description: settingDescription(def, ctx.env), ...(r.invalid ? { invalid: true } : {}) };
         });
         const invalid = rows.filter((r) => r.invalid).map((r) => r.key);
         const text = lines(table(rows.map((r) => [r.key, `${display(ctx, settingDef(r.key), r.value)}${r.invalid ? "  (invalid)" : ""}`, r.source, r.env])), "", ...(invalid.length ? [APP_URL_INVALID_SETTING, ""] : []), "order: flag > env > tree (strom.json) > config > default", `change: strom config set <key> <value> [--for-tree]  ·  strom config unset <key> [--for-tree]`, `other env: ${OTHER_ENV.map((e) => e.env).join(" ")}  (strom help config where)`, `config file: ${ctx.display(configFile(ctx.env))}`);

package/dist/commands/start.js

@@ -20,7 +20,7 @@ import { agentBrowser } from "../core/connector.js";
 import { browserNote } from "./connectors.js";
 import { offerLinks } from "../cli/wizard.js";
 import { appOpensLinks, appOpensResearch, appUrlSetting, importAppUrl, installedStromApp, liveAppUrl, liveAppUrlShown, noticeStromApp, stromAppUrl } from "../core/stromapp.js";
-import { forgetLive, liveRunning, serveLive, startLive, stopLive } from "../core/live.js";
+import { dropLiveSecret, forgetLive, liveRunning, serveLive, startLive, stopLive } from "../core/live.js";
 import { openForUser } from "../core/open.js";
 import { createShortcut, openInNewTerminal } from "../core/shortcut.js";
 import { browserKind, openFileWith, revealFile } from "../core/chromium.js";
@@ -318,8 +318,9 @@ register({
         "strom app --live, takes the tree from it and hears what changes — who is at work on what, what was recorded, what\n" +
         "waits for the user. It ends by itself when nobody asks it anything for two hours, or with strom live stop.\n" +
         "One error does not end it (a read that fails is tried again); what it did and what went wrong is in .strom/live.log.\n" +
-        "Started again it takes the address it had (its port while free), so the app following it goes on by itself;\n" +
-        "one that ended without a word is started again when a session starts.",
+        "Started again by itself (strom updated, one that ended without a word or when idle) it takes the address it had\n" +
+        "(its port while free), so the app following it goes on by itself; one that ended without a word is started again\n" +
+        "when a session starts. Stopped with strom live stop, the next one gets a new secret address.",
     examples: ["strom live", "strom live start", "strom live stop"],
     run(ctx) {
         const tree = bridgeTree(ctx);
@@ -351,20 +352,23 @@ register({
     summary: "Stop the live bridge",
     group: "output",
     tree: true,
-    description: "Started again, the bridge takes its last address (its port while free, its secret), so the Strom app that kept it\n" +
-        "goes on by itself. --forget: the next bridge gets a new secret — the address the app kept no longer works (the\n" +
-        "app gets the new one when the research is opened in it again: strom app).",
-    options: [{ name: "forget", type: "boolean", description: "the next bridge gets a new secret address" }],
+    description: "Ended for good: the next bridge gets a new secret (its port while free) — the address the Strom app kept no longer\n" +
+        "works, and the app gets the new one when the research is opened in it again (strom app). --forget: its port too.\n" +
+        "(A bridge started again by itself — strom updated, one that ended when idle — keeps its address.)",
+    options: [{ name: "forget", type: "boolean", description: "the next bridge gets a new port too, not only a new secret" }],
     examples: ["strom live stop", "strom live stop --forget"],
     run(ctx, { opts }) {
         const { root, lang } = bridgeTree(ctx);
         const how = stopLive(root);
         if (how === "alive")
             throw new StromError("the bridge could not be ended", { hint: `its process: see .strom/live.json — end it in the system's task manager`, code: "live.alive" });
+        // ended for good: its secret dropped (the address that may have got out dies with it)
+        const dropped = dropLiveSecret(root, "strom live stop");
         if (opts.forget)
             forgetLive(root);
         const said = ui(lang, how === "none" ? "ui.live.noneran" : how === "killed" ? "ui.live.killed" : "ui.live.stopped");
-        return { text: lines(said, opts.forget ? ui(lang, "ui.live.forgotten") : undefined), data: { stopped: how !== "none", how, ...(opts.forget ? { forgotten: true } : {}) } };
+        const next = opts.forget ? ui(lang, "ui.live.forgotten") : dropped ? ui(lang, "ui.live.newsecret") : undefined;
+        return { text: lines(said, next), data: { stopped: how !== "none", how, ...(dropped ? { newSecret: true } : {}), ...(opts.forget ? { forgotten: true } : {}) } };
     },
 }, {
     path: ["live", "serve"],
@@ -465,7 +469,9 @@ register({
         // the bridges of the research (the Strom app following it) end first: they run this installation's Node
         for (const k of ctx.knownTrees()) {
             try {
-                stopLive(k.root, "strom uninstall");
+                // ended for good: its secret too (installed again, the app gets the new address through strom app)
+                if (stopLive(k.root, "strom uninstall") !== "alive")
+                    dropLiveSecret(k.root, "strom uninstall");
             }
             catch {
                 // its tree unreadable: its bridge, if any, is found below

package/dist/core/actions.js

@@ -5,7 +5,7 @@ import { normalizeDate } from "./gdate.js";
 import { normalizeAge } from "./age.js";
 import { checkStatus, defaultStatus } from "./evidence.js";
 import { eventKind, FAMILY_EVENT_KINDS, NOTE_MAX, STATUSES, PARTICIPANT_ROLES, NAME_KINDS, RECORD_TYPES, } from "./model.js";
-import { cleanTitle, displayName, familiesAsChild, familiesAsPartner, gedcomName, gedcomTitledName, isBirthFamily, notAName, parseName, primaryName, sameName, slashInName } from "./people.js";
+import { cleanTitle, displayName, familiesAsChild, familiesAsPartner, gedcomName, gedcomTitledName, isBirthFamily, keepSides, notAName, parseName, primaryName, sameName, slashInName } from "./people.js";
 import { foldText } from "./text.js";
 import { roleWord } from "./roles.js";
 import { now, typeOfId } from "./tree.js";
@@ -380,6 +380,7 @@ export function editFamily(tree, familyId, edit, reason) {
             if (!was)
                 throw new UsageError(`${edit.remove} is not in ${familyId}`);
             next.partners = next.partners.filter((p) => p !== edit.remove);
+            delete next.husb;
             next.children = next.children.filter((c) => c.person !== edit.remove);
             for (const c of next.children)
                 if (c.relations?.[edit.remove]) {
@@ -623,7 +624,11 @@ export function editPerson(tree, id, edit, reason) {
             edit.prefix !== undefined ? `title before the name ${retitled.prefix ? `"${retitled.prefix}"` : "taken off"}` : "",
             edit.suffix !== undefined ? `title after the name ${retitled.suffix ? `"${retitled.suffix}"` : "taken off"}` : "",
         ].filter(Boolean).join(", ");
+        // its couples keep the sides their files wrote (U01-e): written before the person, read with the sex as it was
+        const sides = sex !== undefined && sex !== p.sex ? keepSides(tree, p, updated) : [];
         tree.put(updated, { op: "person.edit", targets: [id], summary: `${id} ${what}`, ...(reason ? { reason } : {}) });
+        for (const { next } of sides)
+            tree.put({ ...next, updated: now() }, { op: "family.edit", targets: [next.id], summary: next.husb ? `${next.id} ${next.husb} kept as HUSB (the sex of ${id} changed)` : `${next.id} sides by sex again`, ...(reason ? { reason } : {}) });
         return updated;
     });
 }

package/dist/core/config.js

@@ -13,7 +13,7 @@ import { DEFAULT_AGENT, PROFILES, TIERS } from "../agents/profiles.js";
 import { EXCERPT_QUALITIES, EXCERPT_SCOPES, EXCERPTS_MAX_MB, STRATEGIES } from "./model.js";
 import { downloadsDir } from "./browser.js";
 import { acquireLock } from "./lock.js";
-import { isAppVersion, isStromAppOrigin, STROM_APP_BETA_URL, STROM_APP_URL } from "./stromapp.js";
+import { defaultAppUrl, isAppVersion, isStromAppOrigin, STROM_APP_BETA_URL, STROM_APP_URL } from "./stromapp.js";
 import { updateChannel } from "./update.js";
 export const PERMISSION_LEVELS = ["ask", "auto", "full"];
 /** Earlier names of the levels, still understood. */
@@ -65,7 +65,7 @@ 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" },
-    { key: "strom.app.url", env: "STROM_APP_URL", tree: false, kind: "url", description: "another copy of the Strom app to open instead of https://stromapp.info/run/ — e.g. its development (http://127.0.0.1:8080/); installed from a browser, that copy opens as its own app" },
+    { key: "strom.app.url", env: "STROM_APP_URL", tree: false, kind: "url", description: "another copy of the Strom app to open instead of {appUrl} — e.g. its development (http://127.0.0.1:8080/); installed from a browser, that copy opens as its own app" },
 ];
 /** Fields of the stored settings whose key is not the field name. */
 const FIELDS = {
@@ -97,6 +97,13 @@ export const OTHER_ENV = [
     { env: "STROM_DOCUMENTS", description: "the Documents folder, where strom suggests its home (default: the system's)" },
     { env: "STROM_APP", description: "set by the Strom app when it starts strom (or an agent for it): strom then knows the app is there" },
 ];
+/**
+ * A setting's description as it is said here: {appUrl} the copy of the Strom app strom opens when strom.app.url says
+ * none — the channel's (defaultAppUrl: the beta its beta, the releases stromapp.info) (B1-g).
+ */
+export function settingDescription(def, env) {
+    return def.description.replace(/\{appUrl\}/g, defaultAppUrl(env));
+}
 export function settingDef(key) {
     const def = SETTINGS.find((s) => s.key === key);
     if (!def)
@@ -124,6 +131,10 @@ function isAppAddress(v) {
         return false; // not an address
     }
 }
+/** The Strom app's pages on the web strom names as its addresses: the releases stromapp.info only (production says nothing of a beta), the beta its beta too. */
+export function appWebPages(env) {
+    return updateChannel(env) === "beta" ? `${STROM_APP_BETA_URL} · ${STROM_APP_URL}` : STROM_APP_URL;
+}
 /**
  * strom.app.url that says no address of the Strom app — typed (`set`: strom config set), in the variable STROM_APP_URL
  * (`env`), or in the settings however it got there (`config`: written by hand): refused, with what is an address of it
@@ -132,7 +143,7 @@ function isAppAddress(v) {
  * a copy on this computer (its development) both.
  */
 export function appUrlInvalid(raw, how, env) {
-    const web = updateChannel(env) === "beta" ? `${STROM_APP_BETA_URL} · ${STROM_APP_URL}` : STROM_APP_URL;
+    const web = appWebPages(env);
     const allowed = `the Strom app: ${web}, or a copy on this computer http://127.0.0.1:<port>/`;
     const fix = how === "config" ? "\nset it right: strom config set strom.app.url <address> — or remove it: strom config unset strom.app.url" : how === "env" ? "\nthe variable STROM_APP_URL set right, or removed" : "";
     const code = "config.app-url";

package/dist/core/dialog.js

@@ -28,6 +28,18 @@ function psString(s) {
  * Ask in a window: true (yes), false (no, closed or no answer in time), or
  * undefined when this computer cannot show one (no desktop, no dialog tool).
  */
+/**
+ * Can this computer show a window of the system to ask in? Not with dialogs off (STROM_NO_DIALOG: a test run, a user who
+ * wants their consents in a terminal only), nor on Linux without a desktop or a dialog tool — then nothing is said to
+ * wait in one (found: strom update --json said a question waited in a window with none shown).
+ */
+export function canShowDialog(env, platform = process.platform) {
+    if (env.STROM_NO_DIALOG === "1")
+        return false;
+    if (platform === "darwin" || platform === "win32")
+        return true;
+    return Boolean((env.DISPLAY || env.WAYLAND_DISPLAY) && (which("zenity", env) || which("kdialog", env)));
+}
 export function systemDialog(text, env, platform = process.platform) {
     // A test run, or a user who wants their consents in a terminal only.
     if (env.STROM_NO_DIALOG === "1")

package/dist/core/import.js

@@ -12,7 +12,7 @@ import { validateRecord } from "./validate.js";
 import { normalizeDate } from "./gdate.js";
 import { appNoSurname, cleanTitle, noName, notAName, parseName, sameName, surnameAfterGiven, withoutTitles } from "./people.js";
 import { now } from "./tree.js";
-import { appUnknownIsNoSurname } from "./stromapp.js";
+import { appUnknownIsNoSurname, appWritesSexUnknown } from "./stromapp.js";
 import { children, parseGedcomText, val } from "../gedcom/parse.js";
 /** Christenings and baptisms are one fact for a comparison. */
 const SAME_KIND = { CHR: "BAPM", BAPM: "BAPM" };
@@ -120,11 +120,25 @@ function nameKind(type) {
 /**
  * A file of the Strom app (its HEAD: 1 SOUR STROM), and whether its "? /Unknown/" is a person of no surname — an app
  * before 3.10.0-beta.7 or one whose version the HEAD's 2 VERS does not say (T08b); from it on the surname Unknown.
+ * Its SEX U is a sex left unknown (U01) where the header says so (1 _STROM_SEX_U Y: the app's tree linked to a
+ * research) or the app is 3.10.0-beta.11 or newer (its HEAD's 2 VERS; the bridge stamps the version the app said);
+ * else the app guessed there (a husband male, anyone else female).
  */
 export function stromAppFile(head) {
     const sour = head ? children(head, "SOUR")[0] : undefined;
     const app = sour?.value.trim() === "STROM";
-    return { app, unknownIsNoSurname: app && appUnknownIsNoSurname(val(sour, "VERS")) };
+    const marked = val(head, "_STROM_SEX_U")?.trim().toUpperCase() === "Y";
+    return { app, unknownIsNoSurname: app && appUnknownIsNoSurname(val(sour, "VERS")), sexUnknown: marked || (app && appWritesSexUnknown(val(sour, "VERS"))) };
+}
+/**
+ * The sex of a person of a file, read the same way by strom intake and strom sync: M and F as it says; SEX U the sex
+ * left unknown — "U", a value like the others — where the file means it so (stromAppFile: sexUnknown, U01), else
+ * nothing the file says (an app's guess). No SEX line, or another value, says nothing of it in any file (B5-d: the app
+ * writes SEX for everyone; found: a file of its 3.10.0-beta.11 without SEX lines read as every sex set unknown).
+ */
+export function readGedSex(r, file) {
+    const sex = val(r, "SEX")?.trim().toUpperCase();
+    return sex === "M" || sex === "F" ? sex : sex === "U" && file.sexUnknown ? "U" : undefined;
 }
 /**
  * One NAME of a file, read the same way by strom intake and strom sync: the titles (NPFX, NSFX) apart from it — the
@@ -371,7 +385,7 @@ export function importGedcom(tree, text, opts) {
             const names = namesOf(r);
             // The birth name leads: a married name is a variant.
             names.sort((a, b) => (a.kind === "married" || a.kind === "alias" ? 1 : 0) - (b.kind === "married" || b.kind === "alias" ? 1 : 0));
-            const sex = val(r, "SEX")?.toUpperCase();
+            const sex = readGedSex(r, fromApp) ?? "U";
             const refs = [{ system, id: r.xref }];
             if (refn)
                 refs.push({ system: "refn", id: refn });
@@ -390,7 +404,7 @@ export function importGedcom(tree, text, opts) {
                 id: xrefToId.get(r.xref),
                 type: "person",
                 names: names.length ? names : [{ given: "?", surname: "" }],
-                sex: sex === "M" || sex === "F" ? sex : "U",
+                sex,
                 events: personEvents,
                 notes: personNotes.filter((x) => x.trim()).map((x) => note(tree, x)),
                 refs,

package/dist/core/live.js

@@ -38,10 +38,23 @@
 // It never ends because of one error: a read that fails while another strom
 // writes is tried again at the next tick, a request that fails answers 500.
 // What it did and what went wrong is in .strom/live.log (start, end and why,
-// errors with their stack). Started again, it takes the address it had
-// (.strom/live-last.json: its port while free, its token), so the app following
-// it goes on by itself; a bridge that ended without a word is started again
-// when a session starts (reviveLive).
+// errors with their stack).
+//
+// The secret: started again by itself — a newer strom on disk (live start
+// --current), one that ended without a word (reviveLive), the first run of a
+// newer strom bringing its bridges back, a start after it ended when idle — it
+// takes the address it had (.strom/live-last.json: its port while free, its
+// token), so the app following it goes on by itself. Ended for good (strom live
+// stop, strom uninstall) its secret is dropped: the next bridge gets a new one
+// (its port kept), the address the app kept no longer works, and the app gets
+// the new one when the research is opened in it again (strom app, ?live=). A
+// request with the secret from a page that is no Strom app (an Origin the
+// bridge does not let in; never "null", none at all, or a copy of the app on
+// this computer) means the address got out: the secret is replaced at once,
+// written where the next strom app reads it, the app's open event streams
+// ended, and that request answered as one without the secret. What is being
+// written then (a send, an original) is finished; only new requests need the
+// new secret. Nothing is replaced on a timer.
 import { opsLogsOf } from "./opslog.js";
 import fs from "node:fs";
 import http from "node:http";
@@ -74,7 +87,7 @@ import { rankTasks } from "./queue.js";
 import { humanTask } from "../cli/human.js";
 import { knownNewerVersion, updateChannel } from "./update.js";
 import { gitProgram, runGit } from "./git.js";
-import { appKnowsArchive, appKnowsNoCouple, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsFactStatus, appShowsSourceReads, appShowsStoryDrafts, appTurnsExcerpts, isAppVersion, isStromAppOrigin } from "./stromapp.js";
+import { appKnowsArchive, appKnowsNoCouple, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsFactStatus, appShowsSourceReads, appShowsStoryDrafts, appTurnsExcerpts, appUrlSetting, isAppVersion, isStromAppOrigin } from "./stromapp.js";
 import { Settings } from "./config.js";
 import { LINK_SCHEME, linkActions, linkHandlerState, linkHandlerStateLater, linkScheme } from "./links.js";
 import { autoTidy } from "./tidy.js";
@@ -133,7 +146,7 @@ function lastFile(root) {
 function readLast(root) {
     try {
         const last = JSON.parse(fs.readFileSync(lastFile(root), "utf8"));
-        return Number.isInteger(last.port) && /^[0-9a-f]{32}$/.test(last.token) ? last : undefined;
+        return Number.isInteger(last.port) && (last.token === undefined || /^[0-9a-f]{32}$/.test(last.token)) ? last : undefined;
     }
     catch {
         return undefined;
@@ -270,6 +283,20 @@ function spawnBridge(root, env, extra = {}) {
         fs.closeSync(log);
     return child;
 }
+/**
+ * The bridge ended for good (strom live stop, strom uninstall): its secret dropped, its port kept — the next bridge gets a
+ * new secret, the address the app kept is dead (the app gets the new one when the research is opened in it again). Whether
+ * there was one to drop.
+ */
+export function dropLiveSecret(root, why) {
+    const last = readLast(root);
+    if (!last?.token)
+        return false;
+    const { token: _dropped, ...rest } = last;
+    writeLast(root, { ...rest, ended: last.ended ?? { at: new Date().toISOString(), reason: why } });
+    noteLive(root, `its secret dropped (${why}): the next bridge gets a new one, at port ${last.port} while free — the Strom app gets it when the research is opened in it again (strom app)`);
+    return true;
+}
 /** The bridge's last address forgotten: the next one gets a new secret (and port) — the address the app kept is dead. */
 export function forgetLive(root) {
     fs.rmSync(lastFile(root), { force: true });
@@ -365,6 +392,35 @@ export function reviveLive(root, env) {
 function allowedOrigin(origin) {
     return origin && isStromAppOrigin(origin) ? origin : undefined;
 }
+/**
+ * A request with the secret from a page that is no Strom app: the address got out. Not one without an Origin (curl, a
+ * process of this computer, the app's EventSource), "null" (the app opened as a file), a page the bridge lets in, nor the
+ * copy of the app the person set (strom.app.url).
+ */
+function foreignOrigin(origin, env) {
+    if (origin === undefined || origin === "null" || allowedOrigin(origin))
+        return false;
+    try {
+        const said = appUrlSetting(new Settings(env, {}));
+        if (!said.invalid && new URL(said.url).origin === origin)
+            return false;
+    }
+    catch {
+        // no setting to read: the pages the bridge lets in are what there is
+    }
+    return true;
+}
+/** An address as the log says it: never its secret (one replaced meanwhile neither). */
+function masked(url) {
+    return String(url ?? "").replace(/\/[0-9a-f]{32}(?=[/?]|$)/, "/…");
+}
+/** live.json written whole: a strom reading it meanwhile never takes a half for no bridge. */
+function writeLive(root, info) {
+    const file = liveFile(root);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(`${file}.${process.pid}`, JSON.stringify(info, null, 2));
+    fs.renameSync(`${file}.${process.pid}`, file);
+}
 function head(root) {
     const r = spawnSync(gitProgram() ?? "git", ["rev-parse", "HEAD"], { cwd: root, encoding: "utf8", windowsHide: true });
     return r.status === 0 ? r.stdout.trim() : "";
@@ -793,9 +849,12 @@ export function serveLive(root, env) {
     catch (e) {
         noteLive(root, `an archive's tasks not put aside now: ${errorText(e)}`);
     }
-    // the address of the last bridge, so the app that followed it finds this one
+    // the address of the last bridge, so the app that followed it finds this one (its secret: none once it was ended for
+    // good — a new one); replaced while it runs when a page that is no Strom app comes with it (leaked)
     const last = readLast(root);
-    const token = last?.token ?? crypto.randomBytes(16).toString("hex");
+    let token = last?.token ?? crypto.randomBytes(16).toString("hex");
+    // what this bridge says of itself (live.json), once it listens
+    let live;
     const idleMs = Number(env.STROM_LIVE_IDLE_MS ?? 2 * 60 * 60_000);
     const pollMs = Number(env.STROM_LIVE_POLL_MS ?? 2000);
     const streams = new Set();
@@ -804,7 +863,7 @@ export function serveLive(root, env) {
     let log;
     /** A request that failed: said to the app, written into the log — the bridge goes on. */
     const failed = (req, res, e) => {
-        noteLive(root, `${req.method} ${String(req.url ?? "").replace(token, "…")} failed: ${errorText(e)}`);
+        noteLive(root, `${req.method} ${masked(req.url)} failed: ${errorText(e)}`);
         try {
             // an answer begun (the events) is only ended
             if (res.headersSent)
@@ -854,7 +913,7 @@ export function serveLive(root, env) {
             if (Array.isArray(said.skipped) && said.skipped.length)
                 marks.push(`skipped ${said.skipped.length}`);
             const why = res.statusCode >= 400 ? String(said.text ?? said.reason ?? said.error ?? "").replace(/\s+/g, " ").slice(0, 300) : "";
-            const route = String(req.url ?? "").replace(token, "…").replace(/\?.*$/, "");
+            const route = masked(req.url).replace(/\?.*$/, "");
             noteLive(root, `${req.method} ${route} → ${res.statusCode}${marks.length ? ` · ${marks.join(", ")}` : ""}${why ? ` · ${why}` : ""} (${Date.now() - started} ms)`);
         });
     };
@@ -869,11 +928,44 @@ export function serveLive(root, env) {
     // the client's own wait runs out after Node's 5 s, the request comes as the connection closes — "reset")
     server.keepAliveTimeout = 65_000;
     server.headersTimeout = 66_000;
+    /**
+     * The secret came from a page that is no Strom app: replaced at once — written where strom app reads it (live.json,
+     * live-last.json), the event streams on the old one ended (the app notices), said in the log. What is being written
+     * meanwhile finishes; every new request needs the new secret.
+     */
+    const leaked = (req, from, what) => {
+        token = crypto.randomBytes(16).toString("hex");
+        for (const s of streams)
+            s.end();
+        streams.clear();
+        if (live) {
+            live = { ...live, token, url: `http://127.0.0.1:${live.port}/${token}` };
+            try {
+                const now = liveRunning(root);
+                if (!now || now.pid === process.pid)
+                    writeLive(root, live);
+                const was = readLast(root);
+                if (!was || was.pid === process.pid)
+                    writeLast(root, { port: live.port, token, pid: process.pid, started: live.started });
+            }
+            catch (e) {
+                noteLive(root, `the new secret not written: ${errorText(e)}`);
+            }
+        }
+        const page = from.replace(/[\u0000-\u001f\u007f]/g, "?").slice(0, 200);
+        noteLive(root, `${req.method} /…/${String(what ?? "").slice(0, 40)} came with the secret from ${page}, a page that is no Strom app: the address got out — a new secret, the old one no longer works (the Strom app gets the new one when the research is opened in it again: strom app)`);
+    };
     const answer = (req, res) => {
         const [, t, what, sub, act] = (req.url ?? "").split("?")[0].split("/");
         // the app asking now and then (?poll=1) keeps no bridge running; anything else does
         if (!(req.method === "GET" && what === "status" && /[?&]poll=1(?:&|$)/.test(req.url ?? "")))
             lastAsked = Date.now();
+        // the secret from a page that is no Strom app: replaced, this request answered as one without it (no data, no CORS)
+        if (t === token && foreignOrigin(req.headers.origin, env)) {
+            leaked(req, String(req.headers.origin), what);
+            res.writeHead(404).end();
+            return;
+        }
         const origin = allowedOrigin(req.headers.origin);
         const version = appVersionOf(req, new Settings(env, {}));
         if (origin) {
@@ -1732,11 +1824,11 @@ export function serveLive(root, env) {
         server.once("listening", () => {
             up = true;
             const port = server.address().port;
-            const info = { port, token, pid: process.pid, url: `http://127.0.0.1:${port}/${token}`, started: new Date().toISOString(), version: VERSION };
-            fs.mkdirSync(path.dirname(liveFile(root)), { recursive: true });
-            fs.writeFileSync(liveFile(root), JSON.stringify(info, null, 2));
-            writeLast(root, { port, token, pid: process.pid, started: info.started });
-            noteLive(root, `started: strom ${VERSION}, port ${port}, ${last && last.port === port ? "the address of the last bridge" : last ? "the token of the last bridge, another port" : "a new address"}`);
+            live = { port, token, pid: process.pid, url: `http://127.0.0.1:${port}/${token}`, started: new Date().toISOString(), version: VERSION };
+            writeLive(root, live);
+            writeLast(root, { port, token, pid: process.pid, started: live.started });
+            const how = !last ? "a new address" : last.port === port ? (last.token ? "the address of the last bridge" : "the port of the last bridge, a new secret (it was ended for good)") : last.token ? "the token of the last bridge, another port" : "a new address";
+            noteLive(root, `started: strom ${VERSION}, port ${port}, ${how}`);
             // A read that fails (another strom writing that moment) is tried again at the next tick; written down once.
             let trouble;
             const safe = (what, fn) => {
@@ -1808,8 +1900,9 @@ export function serveLive(root, env) {
                     server.listen(port, "127.0.0.1", () => {
                         renewing = false;
                         try {
-                            fs.writeFileSync(liveFile(root), JSON.stringify(info, null, 2));
-                            writeLast(root, { port, token, pid: process.pid, started: info.started });
+                            if (live)
+                                writeLive(root, live);
+                            writeLast(root, { port, token, pid: process.pid, started: live?.started ?? new Date().toISOString() });
                         }
                         catch {
                             // its research gone meanwhile: the next tick ends it

package/dist/core/people.js

@@ -263,6 +263,64 @@ export function familiesAsChild(tree, id) {
 export function familiesAsPartner(tree, id) {
     return relIndex(tree).asPartner.get(id) ?? [];
 }
+/**
+ * The two sides of a couple, HUSB and WIFE, as the Strom app sides them (its coupleSides): a man HUSB, a woman WIFE,
+ * one of unknown sex the side the other one leaves free; two of one sex, or two unknown, in the order given. One
+ * partner alone: HUSB unless a woman. Never one of them left out.
+ */
+export function coupleSides(a, b) {
+    if (!a || !b) {
+        const one = a ?? b;
+        return one?.sex === "F" ? [undefined, one] : [one, undefined];
+    }
+    if (a.sex === "M" && b.sex !== "M")
+        return [a, b];
+    if (b.sex === "M" && a.sex !== "M")
+        return [b, a];
+    if (b.sex === "F" && a.sex !== "F")
+        return [a, b];
+    if (a.sex === "F" && b.sex !== "F")
+        return [b, a];
+    return [a, b];
+}
+/**
+ * A family's sides as its files write them: the ones kept when a sex of the partners changed (Family.husb, U01-e) —
+ * unless that puts a woman HUSB beside a man —, else coupleSides. An app that knows no unknown sex (the Strom app
+ * before 3.10.0-beta.11) guesses one by the side: a side kept is no change of the guess.
+ */
+export function familySides(f, a, b) {
+    if (a && b && (f.husb === a.id || f.husb === b.id)) {
+        const [h, w] = f.husb === a.id ? [a, b] : [b, a];
+        if (!(h.sex === "F" && w.sex === "M"))
+            return [h, w];
+    }
+    return coupleSides(a, b);
+}
+/**
+ * A person's sex about to change (editPerson): each couple of theirs keeps the sides its files wrote — set on the family
+ * where coupleSides would now swap them, taken off where it no longer would (U01-e).
+ */
+export function keepSides(tree, before, after) {
+    const out = [];
+    for (const f of familiesAsPartner(tree, before.id)) {
+        if (f.partners.length !== 2)
+            continue;
+        const of = (p) => f.partners.map((id) => (id === before.id ? p : tree.get(id))).filter((x) => !!x);
+        const [a, b] = of(before);
+        const [x, y] = of(after);
+        if (!a || !b || !x || !y)
+            continue;
+        const was = familySides(f, a, b)[0]?.id;
+        const kept = familySides({ husb: was }, x, y)[0]?.id;
+        const plain = coupleSides(x, y)[0]?.id;
+        const husb = kept === plain ? undefined : kept;
+        if (husb === f.husb)
+            continue;
+        const { husb: _old, ...rest } = f;
+        out.push({ family: f, next: { ...rest, ...(husb ? { husb } : {}) } });
+    }
+    return out;
+}
 export function parentsOf(tree, id) {
     const out = [];
     for (const f of familiesAsChild(tree, id)) {

package/dist/core/stromapp.js

@@ -7,7 +7,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { desktopDir, userHome } from "./paths.js";
-import { appUrlInvalid, checkValue, settingDef } from "./config.js";
+import { appUrlInvalid, checkValue, settingDef, Settings } from "./config.js";
 import { UsageError } from "./errors.js";
 import { foldText } from "./text.js";
 import { compareVersions, updateChannel } from "./update.js";
@@ -44,6 +44,20 @@ export function appUnknownIsNoSurname(version) {
     const v = version?.trim();
     return !v || !isAppVersion(v) || compareVersions(v, APP_WRITES_NO_SURNAME_EMPTY) < 0;
 }
+/**
+ * The first Strom app whose sex "unknown" is a sex of its own (its data version 12): it writes SEX U where the sex is
+ * unknown in its tree, never a guess — before it, it read SEX U as a husband male and anyone else female and wrote
+ * that guess back. A real pre-release, not a gate: its own betas before it guessed. Its file says so also by the
+ * header's 1 _STROM_SEX_U Y, but only in a tree linked to a research (U01).
+ */
+export const APP_WRITES_SEX_UNKNOWN = "3.10.0-beta.11";
+/** The data version of the Strom app's JSON from which its gender "unknown" is a sex of its own (its 3.10.0-beta.11, U01). */
+export const APP_DATA_SEX_UNKNOWN = 12;
+/** Is SEX U in a file of the Strom app of this version (its HEAD's 2 VERS) the sex the user left unknown? From 3.10.0-beta.11 on; no version said: no. */
+export function appWritesSexUnknown(version) {
+    const v = version?.trim();
+    return !!v && isAppVersion(v) && compareVersions(v, APP_WRITES_SEX_UNKNOWN) >= 0;
+}
 /** The pages of the Strom app — on the web, its beta, a copy on this computer (its development): the only ones strom opens with a research, and the only ones its bridge lets in. */
 export function isStromAppOrigin(origin) {
     return origin === "https://stromapp.info" || origin === "https://beta.stromapp.info" || /^http:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin);
@@ -149,6 +163,23 @@ export function appUrlShown(settings) {
     const said = appUrlSetting(settings);
     return said.invalid ? { url: said.url, invalid: true } : { url: said.url };
 }
+/**
+ * The Strom app's address the texts for an agent name — the guide, a tree's AGENTS.md, what strom agents install
+ * teaches the agents: the one `strom app` opens (appUrlShown: strom.app.url, else the channel's default — the beta its
+ * beta, the releases stromapp.info), read when the text is written (B1-i).
+ */
+export function agentAppUrl(env) {
+    return appUrlShown(new Settings(env, {})).url;
+}
+/** The Strom app's site beside its address in a text for an agent: https://stromapp.info, its beta's, a copy's (its origin). */
+export function appSite(url) {
+    try {
+        return new URL(url).origin;
+    }
+    catch {
+        return url;
+    }
+}
 /** Is the copy of the app another than stromapp.info (its beta, its development)? Never failing on the setting: an invalid one is none. */
 function anotherCopy(settings) {
     return appUrlSetting(settings).url !== STROM_APP_URL;

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, stromAppFile } from "./import.js";
+import { fromFlexDate, houseOf, importDate, readGedName, readGedSex, stromAppFile } from "./import.js";
 import { humanAge, normalizeAge } from "./age.js";
 import { dateYears } from "./gdate.js";
 import { create, update } from "./records.js";
@@ -40,8 +40,8 @@ import { StromError, UsageError } from "./errors.js";
 import * as git from "./git.js";
 import { now, Tree, typeOfId } from "./tree.js";
 import { isArchive } from "./mode.js";
-import { isAppVersion } from "./stromapp.js";
-import { cleanTitle, formatName, foundTitles, gedcomTitledName, primaryName, titledName } from "./people.js";
+import { APP_DATA_SEX_UNKNOWN, isAppVersion } from "./stromapp.js";
+import { cleanTitle, familiesAsPartner, formatName, foundTitles, gedcomTitledName, primaryName, 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();
@@ -479,7 +479,7 @@ export function readGedcom(text) {
         const ours = refn && OUR_ID.test(refn.value.trim()) && (!type || type === REFN_TYPE) ? refn.value.trim() : undefined;
         const key = ours && !persons.has(ours) ? ours : `x:${r.xref.replace(/@/g, "")}`;
         keys.set(r.xref, key);
-        const sex = val(r, "SEX");
+        const sex = readGedSex(r, fromApp);
         // each NAME read as strom intake reads it (readGedName): its parts (GIVN, SURN) first, the line's surname after the
         // given name where it has no slashes (N11), the titles apart; a person of no name and no surname the Strom app
         // writes "? //" (its stand-in for an unknown parent: "//", nobody) — and "? /Unknown/" before its 3.10.0-beta.7 (or
@@ -511,7 +511,7 @@ export function readGedcom(text) {
         persons.set(key, {
             key,
             names,
-            ...(sex === "M" || sex === "F" ? { sex } : {}),
+            ...(sex ? { sex } : {}),
             facts,
             notes: children(r, "NOTE").map(noteText).map((t) => t.trim()).filter(Boolean),
             said: allNotes(r, noteText),
@@ -578,7 +578,8 @@ export function readGedcom(text) {
     const treeId = val(head, "_STROM_TREE");
     const at = val(head, "_STROM_HEAD");
     const transcripts = val(head, "_STROM_TRANSCRIPTS")?.trim().toLowerCase() === "evidence" ? "evidence" : "lead";
-    const sexU = val(head, "_STROM_SEX_U")?.trim().toUpperCase() === "Y";
+    // SEX U where the sex is unknown in the app (its header's mark, an app from 3.10.0-beta.11): no guess of it (U01)
+    const sexU = fromApp.sexUnknown;
     const appTree = val(head, "_STROM_APP_TREE")?.trim();
     const since = val(head, "_STROM_SINCE")?.trim();
     const again = val(head, "_STROM_AGAIN")?.trim();
@@ -632,6 +633,9 @@ export function readStromJson(data) {
     const d = data;
     if (!d || typeof d !== "object" || !d.persons || typeof d.persons !== "object")
         throw new UsageError("not a family tree of the Strom app: no persons in it", { code: "tree.unreadable" });
+    // the sex "unknown" is the user's (U01): a sex of its own from the app's data version 12 (its 3.10.0-beta.11), never
+    // a guess of it; before it, only where the research's unknown stood beside the app's stand-in (research.sexU)
+    const sexU = (typeof d.version === "number" && d.version >= APP_DATA_SEX_UNKNOWN) || d.research?.sexU === true;
     // the sources: ours by their REFN, the app's own by its ID; a citation takes the entry's page, date and quality
     const sources = new Map();
     const sourceKeys = new Map();
@@ -736,7 +740,10 @@ export function readStromJson(data) {
             key,
             ...(titles ? { titles } : {}),
             names: [name, ...(p.nameVariants ?? [])].filter((n) => n.replace(/[/?\s]/g, "")),
-            ...(d.research?.sexU === true && p.sexUnknown ? {} : p.gender === "male" ? { sex: "M" } : p.gender === "female" ? { sex: "F" } : {}),
+            // 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)
+            ...(d.research?.sexU === true && p.sexUnknown ? { sex: "U" } : p.gender === "male" ? { sex: "M" } : p.gender === "female" ? { sex: "F" } : sexU && p.gender === "unknown" ? { sex: "U" } : {}),
             facts: cleanFacts(facts),
             notes: p.notes?.trim() ? [p.notes.trim()] : [],
             said: p.notes ?? "",
@@ -883,7 +890,7 @@ export function readStromJson(data) {
     }
     const r = d.research;
     const transcripts = r?.transcripts === "evidence" ? "evidence" : "lead";
-    return { format: "strom-json", ...(r?.id ? { treeId: r.id } : {}), ...(r?.head ? { head: r.head } : {}), persons, families, places, sources, transcripts, ...(r?.sexU === true ? { sexU: true } : {}), problems: [] };
+    return { format: "strom-json", ...(r?.id ? { treeId: r.id } : {}), ...(r?.head ? { head: r.head } : {}), persons, families, places, sources, transcripts, ...(sexU ? { sexU: true } : {}), problems: [] };
 }
 /** A file coming back: GEDCOM or the Strom app's JSON; empty or unreadable throws. */
 export function readTreeFile(file) {
@@ -2059,15 +2066,19 @@ export function planSync(tree, incoming, edits, opts = {}) {
         // given unknown the app only guessed: nothing to tell from it — but a file that writes U where the unknown stands
         // (_STROM_SEX_U, the app's beta.61) gives a sex there only as the user's edit, and an older app's guess is known (a
         // husband male, anyone else female: its reading of SEX U), so another sex is the user's edit (found on Mac: Petr U,
-        // guessed male, set female in the app, "changes 0" and the edit lost)
+        // guessed male, set female in the app, "changes 0" and the edit lost); the unknown such a file gives is a sex like
+        // the others (U01): a known sex set unknown there is the user's edit too — a lead's corrected, a record's the
+        // user's to decide (found with the app's 3.10.0-beta.11: M → U dropped in silence)
         const [mySex, givenSex] = [o.sex ?? "U", b ? (b.sex ?? "U") : undefined];
         const guessed = givenSex === "U" ? (incoming.sexU ? "U" : b.husb ? "M" : "F") : undefined;
         if (p.sex && p.sex !== mySex && givenSex !== p.sex && (mySex !== "U" || (givenSex !== undefined && givenSex !== "U") || (guessed !== undefined && p.sex !== guessed))) {
             const backed = (tree.get(id)?.events ?? []).some((e) => !e.retracted && recordBacked(tree, e));
             const since = givenSex !== undefined && mySex !== givenSex;
             // set otherwise than the app guessed for the research's unknown: the user's to decide, record or none (Milan,
-            // 2026-10-04: never lost in silence, a conflict; the app keeps "unknown" only after its 3.9)
-            const overGuess = mySex === "U" && guessed !== undefined;
+            // 2026-10-04: never lost in silence, a conflict; the app keeps "unknown" only after its 3.9) — but a file whose
+            // unknown is exact guessed nothing (U01-d): a sex set there for the research's unknown is an edit like M → U, a
+            // correction where no record gives the person's facts, the user's to decide where one does
+            const overGuess = mySex === "U" && guessed !== undefined && !incoming.sexU;
             push({ kind: "sex.changed", action: b ? (edits === "user" ? "user" : backed || since || overGuess ? "conflict" : "correct") : "report", person: id, name, text: p.sex });
         }
         notesDiff({ person: id, name }, p.notes, [o.said, b?.said ?? "", ...o.names], o.facts);
@@ -3411,8 +3422,14 @@ export function applySync(tree, plan, incoming, source, only) {
                         ]);
                         break;
                     }
+                    // the sides its couples kept before (Family.husb) — where the edit changes them, put back by an undo after the
+                    // sexes, so the files after it are those before the sync (B5-b): recorded once per family, ahead of its sexes
+                    const at = applied.length;
+                    const sides = familiesAsPartner(tree, owner).map((f) => [f.id, f.husb ?? ""]);
                     editPerson(tree, owner, { sex: c.text }, `the user's edit: ${reason}`);
                     applied.push({ do: "sex.edit", id: owner, before: p.sex });
+                    const moved = sides.filter(([id, was]) => (tree.get(id)?.husb ?? "") !== was && !applied.some((a) => a.do === "family.sides" && a.id === id));
+                    applied.splice(at, 0, ...moved.map(([id, was]) => ({ do: "family.sides", id, before: was })));
                     break;
                 }
                 case "family.new": {
@@ -3508,7 +3525,7 @@ export function applySync(tree, plan, incoming, source, only) {
                         summary: `${fam.id} partner ${partner} removed: ${phrase(tree.lang, "archive.removed")}`,
                         reason: `${phrase(tree.lang, "archive.removed")}: ${reason}`,
                     });
-                    applied.push({ do: "partner.remove", id: fam.id, before: JSON.stringify({ partner, at: fam.partners.indexOf(partner) }) });
+                    applied.push({ do: "partner.remove", id: fam.id, before: JSON.stringify({ partner, at: fam.partners.indexOf(partner), ...(fam.husb ? { husb: fam.husb } : {}) }) });
                     break;
                 }
                 case "child.parents": {
@@ -3988,6 +4005,18 @@ export function undoSync(tree, input) {
             case "sex.edit":
                 editPerson(tree, a.id, { sex: String(a.before ?? "U") }, reason);
                 break;
+            case "family.sides": {
+                // the side the couple kept before the sync, after its sexes are back (B5-b)
+                const was = String(a.before ?? "");
+                const f = tree.get(a.id);
+                if (f && (f.husb ?? "") !== was)
+                    update(tree, a.id, "family", ({ husb: _h, ...x }) => ({ ...x, ...(was ? { husb: was } : {}) }), {
+                        op: "family.edit",
+                        summary: was ? `${a.id} ${was} kept as HUSB again: ${reason}` : `${a.id} sides by sex again: ${reason}`,
+                        reason,
+                    });
+                break;
+            }
             case "child.add":
                 update(tree, a.id, "family", (f) => ({ ...f, children: f.children.filter((c) => c.person !== a.before) }), { op: "family.edit", summary: `${a.id} child ${String(a.before)} removed: ${reason}`, reason });
                 break;
@@ -4010,8 +4039,9 @@ export function undoSync(tree, input) {
                 break;
             case "partner.remove": {
                 const b = JSON.parse(String(a.before ?? "{}"));
+                // the partner back, and the side the couple kept with them (B5-b)
                 if (b.partner)
-                    update(tree, a.id, "family", (f) => (f.partners.includes(b.partner) || f.partners.length >= 2 ? f : { ...f, partners: f.partners.toSpliced(b.at ?? f.partners.length, 0, b.partner) }), { op: "family.edit", summary: `${a.id} partner ${b.partner} back: ${reason}`, reason });
+                    update(tree, a.id, "family", (f) => (f.partners.includes(b.partner) || f.partners.length >= 2 ? f : { ...f, partners: f.partners.toSpliced(b.at ?? f.partners.length, 0, b.partner), ...(b.husb ? { husb: b.husb } : {}) }), { op: "family.edit", summary: `${a.id} partner ${b.partner} back: ${reason}`, reason });
                 break;
             }
             case "family.add":

package/dist/core/tree.js

@@ -17,7 +17,7 @@ import { acquireLock, withLock } from "./lock.js";
 /** How long a writer waits for the tree while another one works (a long intake, a batch). */
 const LOCK_WAIT_MS = 120_000;
 import { RECORD_TYPES, ALL_PREFIXES, SCHEMA_VERSION } from "./model.js";
-import { validateRecord } from "./validate.js";
+import { settledRecord, validateRecord } from "./validate.js";
 import { NeedsConsentError, StromError, UsageError } from "./errors.js";
 import * as git from "./git.js";
 import { opsLogs } from "./opslog.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.13.0-beta.4";
+export const VERSION = "1.13.0-beta.5";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/
@@ -296,7 +296,7 @@ export class Tree {
                         continue;
                     let rec;
                     try {
-                        rec = readJson(path.join(dir, f));
+                        rec = settledRecord(readJson(path.join(dir, f)));
                     }
                     catch {
                         continue; // unreadable record: reported by `strom check`
@@ -323,7 +323,7 @@ export class Tree {
         let one = this.single.get(id);
         if (one === undefined) {
             try {
-                one = readJson(this.recordPath(type, id));
+                one = settledRecord(readJson(this.recordPath(type, id)));
             }
             catch {
                 one = null;
@@ -512,7 +512,8 @@ export class Tree {
     }
     /** Validate and write a record, then log the sealed operation. Call inside withTreeLock. */
     put(input, op) {
-        const record = composed(input);
+        // a family's husb that names none of its two partners is dropped, never written (B5-a)
+        const record = settledRecord(composed(input));
         const problems = validateRecord(record);
         if (problems.length > 0) {
             throw new UsageError(`invalid ${record.type} ${record.id}: ${problems.map((p) => `${p.path} ${p.message}`).join("; ")}`, {

package/dist/core/validate.js

@@ -252,6 +252,20 @@ export function validateRecord(value) {
     }
     return out;
 }
+/**
+ * A record as strom reads, writes and checks it: a family's husb (the side its files keep, U01-e) only while it names
+ * one of its two partners — else it is dropped, never an error (B5-a: a partner taken away by a sync, by an archive's
+ * send, or by an older strom that keeps the field without knowing it). The same object when nothing is dropped.
+ */
+export function settledRecord(value) {
+    if (!isObj(value) || value.type !== "family" || !("husb" in value))
+        return value;
+    const f = value;
+    if (typeof f.husb === "string" && Array.isArray(f.partners) && f.partners.length === 2 && f.partners.includes(f.husb))
+        return value;
+    const { husb: _stale, ...rest } = f;
+    return rest;
+}
 /** Every reference a record makes to another record (for dangling-reference checks). */
 export function recordRefs(value) {
     const refs = [];

package/dist/gedcom/export.js

@@ -26,7 +26,7 @@
 //   in notes.
 import { GedWriter } from "./lines.js";
 import { labels, RELA } from "./labels.js";
-import { birthEvent, claimText, conflictTitle, displayName, formatName, gedcomTitledName, noName, preferredOrder, primaryName, relationTo } from "../core/people.js";
+import { birthEvent, claimText, conflictTitle, coupleSides, displayName, familySides, formatName, gedcomTitledName, noName, preferredOrder, primaryName, relationTo } from "../core/people.js";
 import { foldText } from "../core/text.js";
 import { dateYears } from "../core/gdate.js";
 import { humanAge, isGedcomAge, normalizeAge } from "../core/age.js";
@@ -268,9 +268,15 @@ export function exportGedcom(tree, opts = {}) {
         stats.families++;
         w.record(x(f.id), "FAM");
         const [a, b] = f.partners.map((id) => persons.find((p) => p.id === id));
-        // HUSB/WIFE by sex; an unknown sex keeps the order given.
-        const husb = [a, b].find((p) => p?.sex === "M") ?? (a?.sex !== "F" ? a : undefined);
-        const wife = [a, b].find((p) => p && p !== husb);
+        // HUSB/WIFE by sex as the Strom app sides a couple (its coupleSides): a man HUSB, a woman WIFE, an unknown sex the
+        // side the other leaves free; two of one sex, or two unknown, keep the order given — never a partner left out
+        // (found: two women, or a woman and one of unknown sex, written with the WIFE alone). One alone: a woman WIFE.
+        // The sides kept when a sex of theirs changed (Family.husb): an app that guesses an unknown sex by the side sees
+        // no change (familySides) — only in the Strom file: every version of the app keeps a couple's partners in the order
+        // of HUSB and WIFE and counts another order as a changed couple, and draws and exports them by sex itself. The
+        // standard file by coupleSides alone (B5-c): another program reads HUSB as the man, WIFE as the woman — never a man
+        // WIFE or a woman HUSB beside one of unknown sex there (found: a man of the app written WIFE beside one unknown)
+        const [husb, wife] = strict ? coupleSides(a, b) : familySides(f, a, b);
         if (husb)
             w.line(1, "HUSB", x(husb.id));
         if (wife)

package/package.json

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