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

package/CHANGELOG.cs.md

@@ -20,6 +20,10 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   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.
+  Výzkum založený dřív z takového rodokmenu (MyHeritage, Legacy, PAF) je doplní ze souboru, který má uložený:
+  `strom input names I…` je ukáže, `--apply` přidá jen tato jména s citací importu, `--undo` je vezme zpět.
+- **Jeden archiv, jedna otázka.** Když obrazy jednoho archivu přicházejí z více adres (jeho web, album, server
+  obrazů), svolení archivu se žádá jednou a platí pro všechny, ne adresu po adrese.
 - **Linie výzkumu.** České texty všude říkají „linie výzkumu“, nikde už „směry“.
 
 ## 1.15.0

package/CHANGELOG.de.md

@@ -21,7 +21,12 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   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.
+  `strom intake` liest `_MARNM` anderer Programme als Namen nach der Heirat. Eine Forschung, die früher aus so einem
+  Stammbaum begonnen wurde (MyHeritage, Legacy, PAF), bekommt sie aus der Datei, die sie aufbewahrt:
+  `strom input names I…` zeigt sie, `--apply` fügt nur diese Namen hinzu, mit dem Import als Quelle, `--undo` nimmt
+  sie zurück.
+- **Ein Archiv, eine Frage.** Kommen die Bilder eines Archivs von mehreren Adressen (seine Seite, ein Album, ein
+  Bildserver), wird die Erlaubnis des Archivs einmal erfragt und gilt für alle, nicht Adresse für Adresse.
 - **Forschungslinien auf Tschechisch.** Die tschechischen Texte sagen jetzt überall „linie výzkumu“ (Forschungslinien).
 
 ## 1.15.0

package/CHANGELOG.md

@@ -20,6 +20,10 @@ The changes of each version in short. The full notes and the install lines are o
   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.
+  A research started earlier from such a family tree (MyHeritage, Legacy, PAF) gets them from the file it keeps:
+  `strom input names I…` shows them, `--apply` adds only these names, citing the import, `--undo` takes them back.
+- **One archive, one question.** When one archive's images come from several hosts (its site, an album, an image
+  server), the permission it needs is asked once and decided for all of them, not host by host.
 - **Lines of research in Czech.** The Czech texts say „linie výzkumu“ (lines of research) everywhere now.
 
 ## 1.15.0

package/dist/cli/menu-archives.js

@@ -11,7 +11,7 @@ import { humanDay } from "./human.js";
 import { Tree } from "../core/tree.js";
 import { isArchive } from "../core/mode.js";
 import { bareHost, listConnectors, routeOf, routesOf } from "../core/connector.js";
-import { claimOf, loadArchives, rank } from "../core/terms.js";
+import { claimOf, loadArchives, pendingQuestions, questionHosts, rank } from "../core/terms.js";
 import { connectorFor, levelWords, tasksStanding, tasksWaitingOn, termsText, waysOffered, wokenLines } from "../core/archiveasks.js";
 import { wakeForArchive } from "../core/archivewait.js";
 import { archivesOverview, capWords, levelsOf, paceFor } from "../commands/archives.js";
@@ -53,8 +53,9 @@ export async function decideArchive(ctx, run, lang, root, host, q, all) {
     const title = a?.title ?? q?.title ?? c.manifest.title ?? host;
     const tree = root ? Tree.open(root, ctx.env) : undefined;
     const hosts = all && all.length > 1 ? all : [host];
-    // the command's target: the downloader for all its hosts at once, else the host
-    const target = hosts.length > 1 ? c.name : host;
+    // the command's target: the downloader for all its hosts at once, else the host — with every host of its question
+    // (strom allow archive decides a question of one archive for all its hosts)
+    const target = hosts.length > 1 && hosts.some((h) => !q?.archiveHosts?.includes(h)) ? c.name : host;
     out("");
     out(` ${t("ui.archive.item", { title, host: hosts.join(", ") })}`);
     out(`    ${termsText(lang, ctx.env, { host, ...(a?.quote ? { quote: a.quote } : q?.quote ? { quote: q.quote } : {}), ...(a?.terms ?? q?.terms ? { terms: (a?.terms ?? q?.terms) } : {}), ...(a?.quoteBy ? { quoteBy: a.quoteBy } : q?.quoteBy ? { quoteBy: q.quoteBy } : {}) })}`);
@@ -222,7 +223,7 @@ function hostStates(ctx, lang, c) {
 /** Settings → Archives → permissions: each archive of a downloader here, then the same choices as in What waits. */
 export async function archivePermissions(ctx, run, lang, root) {
     const t = translator(lang);
-    const pending = (hosts) => loadArchives(ctx.env).pending.find((p) => p.kind === "permission" && hosts.includes(p.host ?? ""));
+    const pending = (hosts) => pendingQuestions(ctx.env).find((p) => p.kind === "permission" && questionHosts(p).some((h) => hosts.includes(h)));
     await subMenu(ctx, lang, () => {
         const rows = archivesOverview(ctx);
         const connectors = connectorsHere(ctx);

package/dist/cli/menu-links.js

@@ -35,6 +35,7 @@ import { foldText, safeFolderName } from "../core/text.js";
 import { StromError } from "../core/errors.js";
 import { forgetTree } from "../commands/trees.js";
 import { archiveQuestions } from "../core/archiveasks.js";
+import { questionHosts } from "../core/terms.js";
 import { bareHost, listConnectors } from "../core/connector.js";
 import { decideArchive } from "./menu-archives.js";
 import { inboxOf, requestFile, sameGroup } from "../core/waiting.js";
@@ -173,11 +174,11 @@ export async function archiveAsked(ctx, run, lang, root, host) {
     const tree = Tree.open(root, ctx.env);
     if (isArchive(tree))
         return stop(ctx, t("ui.link.archive.none"));
-    const q = archiveQuestions(tree).find((p) => p.kind === "permission" && p.host === host);
+    const q = archiveQuestions(tree).find((p) => p.kind === "permission" && questionHosts(p).includes(host));
     const known = q ? true : listConnectors(ctx.settings.shared()?.value, ctx.env).some((c) => c.manifest.hosts.map(bareHost).includes(host));
     if (!known)
         return stop(ctx, t("ui.link.archive.none"));
-    return decideArchive(ctx, run, lang, root, host, q);
+    return decideArchive(ctx, run, lang, root, host, q, q?.archiveHosts);
 }
 /** A direction of the research paused, ended (each with the person's reason, if they give one) or taken up again. */
 export async function directionDo(ctx, run, lang, root, id, what) {

package/dist/cli/menu-waiting.js

@@ -426,7 +426,7 @@ async function decide(ctx, run, lang, root, w) {
         return void (await decideStory(ctx, run, lang, root, w.story, storyOf(tree, w.story)));
     const q = w.question;
     if (q?.kind === "permission" && q.host)
-        return void (await decideArchive(ctx, run, lang, root, q.host, q));
+        return void (await decideArchive(ctx, run, lang, root, q.host, q, q.archiveHosts));
     if (q?.kind === "takeover")
         return decideTakeover(ctx, run, lang, q);
     if (q?.kind === "milder" && q.connector) {

package/dist/commands/archives.js

@@ -19,7 +19,7 @@ import { currentSession } from "../core/session.js";
 import { noteSessionWait, wakeForArchive } from "../core/archivewait.js";
 import { connectorFor, levelWords, waysOffered, wokenLines } from "../core/archiveasks.js";
 import { claudeHere } from "../cli/menu-parts.js";
-import { acceptConnectors, allows, keepReadings, askLater, claimOf, connectorLevels, grantWay, hostOf, humanPace, keepNetVerdict, keyHost, latchedPace, LEVELS, loadArchives, pendingQuestions, rank, settlePending, revokeWay, setFloor, strictest, takenOverWaiting, windowShown, WAYS, } from "../core/terms.js";
+import { acceptConnectors, allows, keepReadings, askLater, claimOf, connectorLevels, grantWay, hostOf, humanPace, keepNetVerdict, keyHost, latchedPace, LEVELS, loadArchives, pendingQuestions, questionHosts, rank, settlePending, revokeWay, setFloor, strictest, takenOverWaiting, windowShown, WAYS, } from "../core/terms.js";
 /** The images (or pages) of an archive wait for the person's decision: nothing was asked of the archive. */
 export class NeedsPermissionError extends StromError {
     hosts;
@@ -466,7 +466,10 @@ export function syncTrees(ctx) {
     }
     return synced;
 }
-/** The hosts a name stands for: a connector's (its name), else the connector hosts on that host or site — never wider. */
+/**
+ * The hosts a name stands for: a connector's (its name), else the connector hosts on that host or site — never wider,
+ * but for the other hosts of one archive whose question waits with it (one archive, one decision).
+ */
 function targetHosts(ctx, target) {
     const all = listConnectors(shared(ctx), ctx.env);
     const byName = all.find((c) => c.name === target);
@@ -477,6 +480,14 @@ function targetHosts(ctx, target) {
     const hosts = [...new Set(connectors.flatMap((c) => c.manifest.hosts.map(bareHost).filter((h) => hostAllowed(h, [given]) || hostAllowed(given, [h]))))];
     if (!hosts.length)
         throw new UsageError(`no connector reaches ${given}`, { hint: all.length ? `connectors: ${all.map((c) => `${c.name} (${c.manifest.hosts.join(", ")})`).join(", ")}` : "none yet: strom connector list" });
+    const reached = new Set(connectors.flatMap((c) => c.manifest.hosts.map(bareHost)));
+    for (const q of pendingQuestions(ctx.env)) {
+        const its = questionHosts(q);
+        if (q.kind === "permission" && its.some((h) => hosts.includes(h)))
+            for (const h of its)
+                if (reached.has(h) && !hosts.includes(h))
+                    hosts.push(h);
+    }
     return { hosts, connectors };
 }
 const WAY_TEXT = { slow: "images slowly, at a person's pace", browser: "images through the browser on this computer", manual: "images by hand only" };

package/dist/commands/intake.js

@@ -9,11 +9,11 @@ import path from "node:path";
 import { register } from "../cli/registry.js";
 import { lines, moreLine, paginate, table, truncate } from "../cli/format.js";
 import { notFound, UsageError } from "../core/errors.js";
-import { likelyDuplicates } from "../core/people.js";
 import { collectFiles, fileSha256, inputPath, MAX_IN_TREE, mimeOf, storeShared } from "../core/media.js";
 import { create, normId, requireRecord, update } from "../core/records.js";
 import { phrase } from "../core/phrases.js";
-import { importGedcom, importStromJson, isStromJson } from "../core/import.js";
+import { addMarriedNames, importedTree, importGedcom, importStromJson, isStromJson, marriedNamesPlan, undoMarriedNames } from "../core/import.js";
+import { gedcomName, likelyDuplicates } from "../core/people.js";
 import { decodeText, safeFolderName } from "../core/text.js";
 import { amendInput, checkOriginalMeta } from "../core/originals.js";
 import { batchStatus, closeBatch, listBatches, readBatch } from "../core/batches.js";
@@ -153,6 +153,13 @@ register({
                         skipped++;
                         if (forTask)
                             handed.push(known.get(sha));
+                        // a family tree imported before strom read its married names (_MARNM): said how they come in
+                        const had = tree.get(known.get(sha));
+                        if (!quiet && had && !importedTree(had)) {
+                            const missing = marriedNamesPlan(tree, had, decodeText(fs.readFileSync(file))).add.length;
+                            if (missing)
+                                report.push(`  ${had.id}: ${missing} married name(s) it gives were left out when it was imported → strom input names ${had.id}`);
+                        }
                         continue;
                     }
                     const size = fs.statSync(file).size;
@@ -315,6 +322,73 @@ register({
         const got = tree.withTreeLock(() => amendInput(tree, id, { persons, note: typeof opts.note === "string" ? opts.note : undefined }));
         return { text: tree.written.length ? lines(...tree.written.map((o) => o.summary)) : `${id}: nothing new`, data: got };
     },
+}, {
+    path: ["input", "names"],
+    summary: "The married names (_MARNM) of a family tree imported before strom read them: shown, --apply adds them",
+    group: "inputs",
+    tree: true,
+    writes: true,
+    description: "strom before 1.16 left out the married names other programs write as _MARNM (MyHeritage, Legacy, PAF). This reads\n" +
+        "the file the research was started from again — the input it keeps — and finds the people imported from it by the\n" +
+        "IDs the import kept (nobody else). Only names of the married kind are added, beside the name each person is shown\n" +
+        "by, citing the import's source; a person who has the name already stays as they are; people of the file not in the\n" +
+        "research are only listed. Without --apply only shown; --apply is one commit; --undo takes back what it added.\n" +
+        "Another export of the tree (another file) is not paired: give the input the research has (strom input list).",
+    args: [{ name: "input", description: "the imported family tree: its input (I…), or the same file", required: true }],
+    options: [
+        { name: "apply", type: "boolean", description: "add them (without: only show)" },
+        { name: "undo", type: "boolean", description: "take back the married names it added from this input" },
+    ],
+    examples: ["strom input names I0004", "strom input names ~/Downloads/rodokmen.ged --apply", "strom input names I0004 --undo"],
+    run(ctx, { args, opts }) {
+        const tree = ctx.tree();
+        const arg = args[0];
+        const inputs = tree.list("input");
+        let input = /^I?\d+$/i.test(arg.trim()) ? inputs.find((i) => i.id === normId(arg, "input")) : undefined;
+        if (!input) {
+            const p = ctx.resolvePath(arg);
+            if (!fs.existsSync(p) || !fs.statSync(p).isFile()) {
+                // an input's ID this research does not have (a file of that name neither)
+                if (/^I?\d+$/i.test(arg.trim()))
+                    throw new UsageError(`no input ${normId(arg, "input")} in this research`, { hint: "strom input list", code: "input.names.missing", params: { input: normId(arg, "input") } });
+                throw notFound(arg);
+            }
+            const sha = fileSha256(p);
+            input = inputs.find((i) => i.sha === sha);
+            if (!input)
+                throw new UsageError(`${ctx.display(p)} is not a family tree this research was started from (another file, another export)`, {
+                    hint: "the research keeps the file it imported: strom input list — then strom input names I…",
+                    code: "input.names.other-file",
+                });
+        }
+        const why = importedTree(input);
+        if (why)
+            throw new UsageError(why, { hint: "strom input list — a family tree imported from GEDCOM (kind tree)", code: "input.names.not-imported", params: { input: input.id } });
+        const name = (id) => {
+            const p = tree.get(id);
+            return p?.names[0] ? gedcomName(p.names[0]).replace(/\//g, "").replace(/\s+/g, " ").trim() : id;
+        };
+        if (opts.undo) {
+            const gone = undoMarriedNames(tree, input);
+            return {
+                text: gone.length ? lines(...gone.map((g) => `  ${g.person} ${name(g.person)}: − ${gedcomName(g.name)}`), `${gone.length} married name(s) from ${input.id} taken back`) : `${input.id}: no married name of it to take back`,
+                data: { input: input.id, undone: gone.map((g) => ({ person: g.person, name: gedcomName(g.name) })) },
+            };
+        }
+        const file = inputPath(tree, input);
+        if (!file || !fs.existsSync(file))
+            throw new UsageError(`the file of ${input.id} is not here (${input.file ?? "none"})`, { hint: `strom input show ${input.id}`, code: "input.names.no-file", params: { input: input.id } });
+        const plan = marriedNamesPlan(tree, input, decodeText(fs.readFileSync(file)));
+        if (opts.apply && plan.add.length)
+            addMarriedNames(tree, plan);
+        const done = !!opts.apply && !tree.dryRun;
+        const text = lines(`${input.id} ${input.name}: ${plan.add.length} married name(s) ${done ? "added" : "to add"}, ${plan.have.length} already there, ${plan.unpaired.length} person(s) of the file not in the research`, ...plan.add.map((a) => `  ${a.person} ${name(a.person)}: + ${gedcomName(a.name)} (married)`), plan.unpaired.length ? "not in the research (nothing added):" : undefined, ...plan.unpaired.map((u) => `  ${u.xref} ${u.name.replace(/\//g, "").replace(/\s+/g, " ").trim()}: ${u.married.map(gedcomName).join(", ")}`), plan.add.length && !opts.apply ? `\nadd them: strom input names ${input.id} --apply` : undefined, done && plan.add.length ? `take them back: strom input names ${input.id} --undo` : undefined);
+        const row = (a) => ({ person: a.person, xref: a.xref, name: gedcomName(a.name) });
+        return {
+            text,
+            data: { input: input.id, source: plan.source, applied: done, add: plan.add.map(row), have: plan.have.map(row), unpaired: plan.unpaired.map((u) => ({ xref: u.xref, name: u.name, married: u.married.map(gedcomName) })) },
+        };
+    },
 }, {
     path: ["input", "batch"],
     summary: "Batches of material the Strom app sent: how many files, how far they are sorted",

package/dist/commands/meta.js

@@ -113,7 +113,7 @@ function orientation(ctx) {
         // the ways as the menu and the bridge offer them (a site only a browser goes to, a bot check: never slowly)
         const connectors = listConnectors(ctx.settings.shared()?.value, ctx.env);
         const claude = claudeHere(ctx, tree.config);
-        base.permissions = asked.map((q) => ({ host: q.host, title: q.title ?? q.host, ...(q.connector ? { connector: q.connector } : {}), since: q.at, tries: q.tries ?? 1, tasks: tasksStanding(tree, q), command: `strom allow archive ${q.host} --way ${waysOffered(connectorFor(connectors, q.host, q.connector), claude, q.way, !!q.browserOnly).join("|")}` }));
+        base.permissions = asked.map((q) => ({ host: q.host, ...(q.archiveHosts ? { hosts: q.archiveHosts } : {}), title: q.title ?? q.host, ...(q.connector ? { connector: q.connector } : {}), since: q.at, tries: q.tries ?? 1, tasks: tasksStanding(tree, q), command: `strom allow archive ${q.host} --way ${waysOffered(connectorFor(connectors, q.host, q.connector), claude, q.way, !!q.browserOnly).join("|")}` }));
     }
     const stories = ctx.settings.stories(tree.config);
     base.stories = !stories.on ? "off" : stories.said || told.stories ? "on" : "tell";

package/dist/core/archiveasks.js

@@ -7,7 +7,7 @@ import { actsAsArchive } from "./state.js";
 import { waitsOnHost } from "./archivewait.js";
 import { waitsForDecision } from "./queue.js";
 export { savedInInbox } from "./archivewait.js";
-import { claimOf, pendingQuestions, termsFor } from "./terms.js";
+import { claimOf, pendingQuestions, questionHosts, termsFor } from "./terms.js";
 import { bareHost, listConnectors, routesOf } from "./connector.js";
 import { ui } from "../cli/ui.js";
 import { humanDay } from "../cli/human.js";
@@ -52,7 +52,7 @@ export function tasksWaitingOn(tree, host) {
  * those the queue holds back for it, and those a fetch needed it for (still to be done) — their IDs.
  */
 export function tasksStanding(tree, q) {
-    const ids = new Set(tasksWaitingOn(tree, q.host).map((t) => t.id));
+    const ids = new Set(questionHosts(q).flatMap((h) => tasksWaitingOn(tree, h).map((t) => t.id)));
     const held = waitsForDecision(tree, [q]);
     for (const t of tree.list("task"))
         if (t.state === "open" && held(t))
@@ -169,12 +169,13 @@ export function archiveWaitingItems(tree, shared, claude) {
                 {
                     kind: "permission",
                     id: q.key,
-                    what: ui(lang, "ui.archive.item", { title, host: q.host }),
+                    what: ui(lang, "ui.archive.item", { title, host: questionHosts(q).join(", ") }),
                     on: termsText(lang, tree.env, q),
                     at: q.at,
                     since: q.at,
                     tries: q.tries ?? 1,
                     host: q.host,
+                    ...(q.archiveHosts ? { hosts: q.archiveHosts } : {}),
                     title,
                     ...(q.terms ? { terms: q.terms } : {}),
                     ...(q.quote ? { quote: q.quote } : {}),

package/dist/core/import.js

@@ -11,7 +11,8 @@ import { foldText } from "./text.js";
 import { roleWord } from "./roles.js";
 import { validateRecord } from "./validate.js";
 import { normalizeDate } from "./gdate.js";
-import { appNoSurname, cleanTitle, noName, notAName, parseName, sameName, surnameAfterGiven, withoutTitles } from "./people.js";
+import { appNoSurname, cleanTitle, gedcomName, noName, notAName, parseName, sameName, surnameAfterGiven, withoutTitles } from "./people.js";
+import { update } from "./records.js";
 import { now } from "./tree.js";
 import { appUnknownIsNoSurname, appWritesSexUnknown } from "./stromapp.js";
 import { children, parseGedcomText, val } from "../gedcom/parse.js";
@@ -197,6 +198,11 @@ export function marnmNames(r, givenOf) {
         add(m.value, names[0] ? givenOf(names[0]) : "");
     return out;
 }
+/** The married names (_MARNM) of a person of a file as strom intake takes them: with the given name of their NAME (none for what stands in place of a name). */
+function importedMarnm(r, file) {
+    const given = (n) => (notAName(readGedName(n, file).name.given) ? "" : readGedName(n, file).name.given.replace(/\//g, "|"));
+    return marnmNames(r, given);
+}
 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. */
@@ -370,8 +376,7 @@ export function importGedcom(tree, text, opts) {
             })
                 .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)))];
+            return [...names, ...importedMarnm(r, fromApp).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) => {
@@ -532,6 +537,100 @@ export function importGedcom(tree, text, opts) {
  * research's tree coming back"); a file that names no research (the standard file, another program) only where most
  * of the people its IDs name are alike by name — and then each by its name too. Merged since: the one it went into.
  */
+// ── the married names an earlier import left out ─────────────────────────────
+//
+// strom before 1.16 read no _MARNM (MyHeritage, Legacy, PAF): a research started from such a file lacks the names
+// after a marriage. Taken in again from the very file it was started from (its input), by the IDs the import kept
+// (refs gedcom:<sha> + the file's xref) — nobody else, nothing but these names.
+/** Where a married name taken in later cites the import: the person's xref in the file and the tag. */
+const MARNM_LOCATOR = " _MARNM";
+/** The input a family tree was imported from (a GEDCOM file kept by the research), else why not. */
+export function importedTree(input) {
+    if (input.kind !== "tree" || !input.sha || !/\.ged$/i.test(input.name))
+        return `${input.id} is not a GEDCOM family tree`;
+    if (!input.source || !input.imported)
+        return `${input.id} was not imported (strom intake --no-import)`;
+    return undefined;
+}
+/** What the input's file gives as married names (_MARNM) that the people imported from it lack. */
+export function marriedNamesPlan(tree, input, text) {
+    const { records } = parseGedcomText(text);
+    const file = stromAppFile(records.find((r) => r.tag === "HEAD"));
+    const system = `gedcom:${input.sha.slice(0, 12)}`;
+    // the people the import made of the file (or added to): by the xref it kept; one merged since is the one it went into
+    const byXref = new Map();
+    for (const p of tree.list("person"))
+        for (const r of p.refs ?? [])
+            if (r.system === system)
+                byXref.set(r.id, p);
+    const live = (p) => {
+        for (let i = 0; p && i < 20; i++) {
+            if (!p.mergedInto)
+                return p.retracted ? undefined : p;
+            p = tree.get(p.mergedInto);
+        }
+        return undefined;
+    };
+    const plan = { input: input.id, source: input.source, add: [], have: [], unpaired: [] };
+    for (const r of records.filter((x) => x.tag === "INDI" && x.xref)) {
+        // NFC as every record (a file may write a name decomposed)
+        const married = importedMarnm(r, file).map((n) => ({ ...n, given: n.given.normalize("NFC"), surname: n.surname.normalize("NFC") }));
+        if (!married.length)
+            continue;
+        const p = live(byXref.get(r.xref));
+        if (!p) {
+            plan.unpaired.push({ xref: r.xref, name: (children(r, "NAME")[0]?.value ?? "?").replace(/\s+/g, " ").trim(), married });
+            continue;
+        }
+        for (const name of married) {
+            const had = p.names.some((n) => sameName(n, name)) || plan.add.some((a) => a.person === p.id && sameName(a.name, name));
+            (had ? plan.have : plan.add).push({ person: p.id, xref: r.xref, name });
+        }
+    }
+    return plan;
+}
+/** Add the names of a plan: each of the married kind, last, citing the import (the person's xref and _MARNM). */
+export function addMarriedNames(tree, plan) {
+    tree.withTreeLock(() => {
+        for (const a of plan.add) {
+            const name = { ...a.name, citations: [{ source: plan.source, locator: `${a.xref.replace(/@/g, "")}${MARNM_LOCATOR}` }] };
+            update(tree, a.person, "person", (p) => (p.names.some((n) => sameName(n, name)) ? p : { ...p, names: [...p.names, name] }), {
+                op: "person.name",
+                summary: `${a.person} name ${gedcomName(name)} (married) ← ${plan.source}`,
+                reason: `the married name ${plan.input} gives (_MARNM), left out when it was imported`,
+            });
+        }
+    });
+}
+/** Take back what addMarriedNames added from this input: the names citing its import there (another citation kept: only this one goes). */
+export function undoMarriedNames(tree, inputRec) {
+    const source = inputRec.source;
+    const ours = (c) => c.source === source && !!c.locator?.endsWith(MARNM_LOCATOR);
+    const gone = [];
+    if (!source)
+        return gone;
+    tree.withTreeLock(() => {
+        for (const p of tree.list("person")) {
+            const at = p.names.flatMap((n, i) => (i > 0 && n.kind === "married" && n.citations?.some(ours) ? [i] : []));
+            if (!at.length)
+                continue;
+            const hit = at.map((i) => p.names[i]);
+            update(tree, p.id, "person", (x) => ({
+                ...x,
+                names: x.names.flatMap((n, i) => {
+                    if (!at.includes(i))
+                        return [n];
+                    // cited by something else too: only this citation goes
+                    const rest = (n.citations ?? []).filter((c) => !ours(c));
+                    return rest.length ? [{ ...n, citations: rest }] : [];
+                }),
+            }), { op: "name.remove", summary: `${p.id} name ${hit.map(gedcomName).join(", ")} taken back`, reason: `the married names taken in from ${inputRec.id} taken back` });
+            for (const n of hit)
+                gone.push({ person: p.id, name: n });
+        }
+    });
+    return gone;
+}
 function oursByRefn(tree, treeId, people) {
     if (treeId && treeId !== tree.config.id)
         return people.map(() => undefined);

package/dist/core/terms.js

@@ -186,12 +186,75 @@ export function updateArchives(env, change) {
  * know (a list grown since covers more) — none left, no question.
  */
 export function pendingQuestions(env) {
-    return loadArchives(env).pending.flatMap((q) => {
+    return oneArchive(loadArchives(env).pending.flatMap((q) => {
         if (q.kind !== "takeover" || !q.hosts)
             return [q];
         const left = (q.connectors ?? []).filter((n) => !q.hosts?.[n] || !coveredByTerms(env, q.hosts[n]));
         return left.length ? [{ ...q, connectors: left }] : [];
-    });
+    }));
+}
+/** The hosts a question is for: those of its archive, else its own. */
+export function questionHosts(q) {
+    return q.archiveHosts?.length ? q.archiveHosts : q.host ? [q.host] : [];
+}
+/**
+ * The questions about the images of one archive — its hosts (the site's pages, its image servers) asked one by one,
+ * the same connector, site and terms — read as one: since the first time asked, the tasks of them all (each once), the
+ * ways every host may go. Each host keeps its own question in the file (an older strom reads them as before).
+ */
+function oneArchive(qs) {
+    const groups = new Map();
+    const out = [];
+    for (const q of qs) {
+        if (q.kind !== "permission" || !q.host) {
+            out.push(q);
+            continue;
+        }
+        const key = JSON.stringify([q.connector ?? "", webDomain(q.host), q.terms ?? ""]);
+        const g = groups.get(key);
+        if (g)
+            g.push(q);
+        else {
+            const fresh = [q];
+            groups.set(key, fresh);
+            out.push(fresh);
+        }
+    }
+    return out.map((x) => (Array.isArray(x) ? (x.length === 1 ? x[0] : merged(x)) : x));
+}
+function merged(qs) {
+    const all = [...qs].sort((a, b) => a.at.localeCompare(b.at));
+    const first = all[0];
+    const latest = (f) => all.map(f).filter((x) => !!x).sort().at(-1);
+    const tasks = [];
+    for (const q of all)
+        for (const t of q.tasks ?? (q.tree && q.task ? [{ tree: q.tree, task: q.task }] : []))
+            if (!tasks.some((x) => x.tree === t.tree && x.task === t.task))
+                tasks.push(t);
+    const lastAsked = [...all].sort((a, b) => (a.last ?? a.at).localeCompare(b.last ?? b.at)).at(-1);
+    const browserOnly = all.some((q) => q.browserOnly);
+    const choices = all.every((q) => q.choices) ? first.choices.filter((w) => all.every((q) => q.choices.includes(w)) && !(browserOnly && w === "slow")) : undefined;
+    const title = all.find((q) => q.title)?.title;
+    const level = all.some((q) => q.level) ? strictest(...all.map((q) => q.level)) : undefined;
+    const way = browserOnly ? "browser" : first.way;
+    const window = latest((q) => q.window);
+    const last = latest((q) => q.last);
+    return {
+        ...first,
+        archiveHosts: [...new Set(all.map((q) => q.host))],
+        ...(title ? { title } : {}),
+        ...(level ? { level } : {}),
+        ...(way ? { way } : {}),
+        ...(choices ? { choices: choices.includes("manual") ? choices : [...choices, "manual"] } : {}),
+        ...(browserOnly ? { browserOnly } : {}),
+        ...(window ? { window } : {}),
+        ...(lastAsked.tree ? { tree: lastAsked.tree } : {}),
+        ...(lastAsked.task ? { task: lastAsked.task } : {}),
+        ...(tasks.length ? { tasks } : {}),
+        // one command asks all the archive's hosts at once: the most any host was needed
+        tries: Math.max(...all.map((q) => q.tries ?? 1)),
+        ...(last && last > first.at ? { last } : {}),
+    };
 }
 export function dropPending(s, key) {
     s.pending = s.pending.filter((p) => p.key !== key);

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.2";
+export const VERSION = "1.16.0-beta.4";
 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.2",
+  "version": "1.16.0-beta.4",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {