strom-research 1.13.1 → 1.13.2-beta.2

package/dist/commands/output.js

@@ -13,7 +13,7 @@ import { UsageError } from "../core/errors.js";
 import { excerptSettings, planExcerpts } from "../core/excerpt.js";
 import { runGit, tracked } from "../core/git.js";
 import { Settings } from "../core/config.js";
-import { appKnowsArchive, appKnowsNoCouple, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsSourceReads, appShowsFactStatus, appShowsStoryDrafts, appTurnsExcerpts } from "../core/stromapp.js";
+import { appKnowsArchive, appKnowsNoCouple, appShowsHypothesisLinks, appDecidesConflicts, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsSourceReads, appShowsFactStatus, appShowsStoryDrafts, appTurnsExcerpts } from "../core/stromapp.js";
 import { EXCERPT_QUALITIES, EXCERPT_SCOPES } from "../core/model.js";
 function findingRows(f) {
     return table(f.slice(0, 30).map((x) => [x.level === "error" ? "ERROR" : "warn", `line ${x.line}`, x.message]));
@@ -85,7 +85,11 @@ export function writeTreeGed(tree, opts) {
     const noCouple = opts.for === "strom" && appKnowsNoCouple(new Settings(tree.env, {}), opts.stromVersion);
     const archive = opts.for === "strom" && appKnowsArchive(new Settings(tree.env, {}), opts.stromVersion);
     const titles = opts.for === "strom" && appReadsTitles(new Settings(tree.env, {}), opts.stromVersion);
-    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}), ...(clips ? { clips } : {}), ...(research ? { research } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}) });
+    // …and what each variant of a hypothesis would connect, for an app that shows it
+    const hypothesisLinks = opts.for === "strom" && appShowsHypothesisLinks(new Settings(tree.env, {}), opts.stromVersion);
+    // …and the sides of a conflict of the user's edit, for an app that decides it
+    const conflictSides = opts.for === "strom" && appDecidesConflicts(new Settings(tree.env, {}), opts.stromVersion);
+    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}), ...(clips ? { clips } : {}), ...(research ? { research } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}), ...(hypothesisLinks ? { hypothesisLinks } : {}), ...(conflictSides ? { conflictSides } : {}) });
     const findings = validateGedcom(result.text, opts.for === "standard" ? { strict: true } : {});
     const file = opts.out ?? gedFile(tree, opts.for, opts.research);
     if (!hasGedErrors(findings) && !tree.dryRun) {

package/dist/commands/session.js

@@ -362,6 +362,8 @@ function edgeNext(e) {
     const join = hyp ? ` · ${hyp.id} ${hyp.island ? `joins ${hyp.joins.join(" ")} (${hyp.island.people} people off the tree)` : `would join through ${hyp.joins.join(" ")}`}` : "";
     if (t)
         return `${t.id}${t.position ? ` #${t.position}` : ""}${t.held ? ` (${t.held})` : ""}${e.tasks.length > 1 ? ` +${e.tasks.length - 1}` : ""}${join}`;
+    if (e.next === "decide" && e.end === "named")
+        return `${e.hypotheses.filter((h) => !h.tests.length).map((h) => h.id).join(" ")} names the parents, no task tests it — the user decides${join}`;
     if (e.next === "decide")
         return `tried ${e.tried.join(" ")} — ask the user${join}`;
     return join.replace(/^ · /, "");
@@ -383,6 +385,7 @@ const SCOPE_WORDS = {
 };
 const END_WORDS = {
     unnamed: "the baptism names no father (born out of wedlock)",
+    named: "a variant of an open hypothesis names the parents — not linked until it is decided",
     lost: "the records of those years are lost",
     "before-records": "born before the known birth records of the place begin",
     gap: "the known records have a gap in those years",
@@ -416,10 +419,10 @@ function edgeLines(tree, e, who) {
         e.books.length ? `  books: ${e.books.map((b) => `${b.id}${b.years ? ` (${b.years})` : ""}${b.access.startsWith("online") ? "" : ` ${b.access}`}`).join(", ")}` : undefined,
         e.covered.length ? `  searched in vain: ${e.covered.map(y).join(", ")}` : undefined,
         e.noRecords.length ? `  no records known: ${e.noRecords.map(y).join(", ")}` : undefined,
-        `  next: ${NEXT_WORDS[e.next]}`,
+        `  next: ${e.next === "decide" && e.end === "named" ? "the hypothesis that names the parents waits for a decision — the user decides (or a task tests it)" : NEXT_WORDS[e.next]}`,
         ...e.tasks.map((t) => `    ${t.id} ${t.level} ${t.state}${t.position ? ` #${t.position}` : ""}${t.held ? ` (waits: ${t.held}${t.until ? ` until ${t.until}` : ""})` : ""}${t.on ? ` — ${truncate(t.on, 60)}` : ""}: ${truncate(t.what, 90)}`),
         e.tried.length ? `  tried: ${e.tried.join(" ")}` : undefined,
-        ...e.hypotheses.map((h) => `  ${h.id} ${truncate(h.question, 90)}${!h.joins.length ? "" : h.island ? ` — would join ${h.joins.map(who).join(", ")} of a family off the tree (${h.island.people} people, ${h.island.held} tasks wait for it)` : ` — would join them to the tree through ${h.joins.map(who).join(", ")}`}${h.tests.length ? `; tested by ${h.tests.join(" ")}` : "; no task tests it"}`),
+        ...e.hypotheses.map((h) => `  ${h.id} ${truncate(h.question, 90)}${h.variants?.length ? ` (variant ${h.variants.join(", ")})` : ""}${!h.joins.length ? "" : h.island ? ` — would join ${h.joins.map(who).join(", ")} of a family off the tree (${h.island.people} people, ${h.island.held} tasks wait for it)` : ` — would join them to the tree through ${h.joins.map(who).join(", ")}`}${h.tests.length ? `; tested by ${h.tests.join(" ")}` : "; no task tests it"}`),
         e.conflicts.length ? `  open conflicts: ${e.conflicts.join(" ")}` : undefined,
         e.searches || e.sessions ? `  work so far: ${e.searches} search${e.searches === 1 ? "" : "es"}, ${e.sessions} session${e.sessions === 1 ? "" : "s"}${e.cost !== undefined ? `, $${e.cost.toFixed(2)}${e.costPartial ? "+" : ""}` : ""}${e.last ? `; last ${e.last}` : ""}` : undefined,
     ].filter((x) => x !== undefined);

package/dist/core/changelog.js

@@ -41,6 +41,8 @@ const SAID = {
     "lesson.add": "log.lesson.add",
     "hypothesis.add": "log.hypothesis.add",
     "hypothesis.argue": "log.hypothesis.argue",
+    "hypothesis.link": "log.hypothesis.link",
+    "hypothesis.variant": "log.hypothesis.variant",
     "hypothesis.decide": "log.hypothesis.decide",
     "conflict.add": "log.conflict.add",
     "conflict.resolve": "log.conflict.resolve",

package/dist/core/conflicts.js

@@ -0,0 +1,105 @@
+// A conflict of the user's edit in the Strom app with what the research holds: its two sides, the user's and the
+// research's — what `strom conflict resolve --take user|research` decides by.
+import { UsageError } from "./errors.js";
+import { claimText } from "./people.js";
+/** The note on the user's claim of a conflict of their edit (core/sync.ts conflictOfEdit). */
+export const USER_EDIT = "the user's edit";
+/** A conflict of the user's edit in the Strom app: a fact's, a child's parents, a name's, a title's or a sex's. */
+export function isEditConflict(c) {
+    return Boolean(c.edit || c.parents || (["NAME", "SEX", "NPFX", "NSFX"].includes(c.fact ?? "") && c.claims.some((x) => x.note === USER_EDIT)));
+}
+/** Which side a claim of a conflict of the user's edit is: the user's, the research's; none in any other conflict. */
+export function sideOf(c, claim) {
+    if (!isEditConflict(c))
+        return undefined;
+    if (claim.note === USER_EDIT)
+        return "user";
+    if (claim.note?.startsWith("the research"))
+        return "research";
+    return undefined;
+}
+/** The claim of a side of a conflict of the user's edit. */
+export function claimOf(c, side) {
+    return c.claims.find((x) => sideOf(c, x) === side);
+}
+/** The kinds of fact a conflict of the user's edit is decided by side from the Strom app (phase 1: not a child's parents). */
+const BY_SIDE = new Set(["NAME", "SEX", "NPFX", "NSFX"]);
+/**
+ * The two sides of a conflict of the user's edit the Strom app decides by side (conflict.decide): a fact's value (date,
+ * place, value — not its details or the people it names, which carry no edit), a name, a title before or after it, a
+ * sex. None for a child's parents (FAMC), a conflict between sources, or one without both sides.
+ */
+export function sidesOf(c) {
+    if (!isEditConflict(c) || c.parents || c.fact === "FAMC")
+        return undefined;
+    if (!c.edit && !BY_SIDE.has(c.fact ?? ""))
+        return undefined;
+    const user = claimOf(c, "user");
+    const research = claimOf(c, "research");
+    return user && research ? { user, research } : undefined;
+}
+/**
+ * A side's value as the Strom app is given it (the Strom file's VAL, the bridge's sides): in the research's language,
+ * an empty value empty (a title the user took off) — never a dash.
+ */
+export function sideText(tree, c, claim) {
+    return claim.value.trim() === "" ? "" : claimText(tree, c, claim);
+}
+/** What the app is told of a conflict it decides by side: both sides' values, a sex also as M, F or U. */
+export function appSides(tree, c) {
+    const s = c.state === "open" ? sidesOf(c) : undefined;
+    if (!s)
+        return undefined;
+    return {
+        take: true,
+        sides: { user: sideText(tree, c, s.user), research: sideText(tree, c, s.research) },
+        ...(c.fact === "SEX" ? { raw: { user: sexRaw(s.user.value), research: sexRaw(s.research.value) } } : {}),
+    };
+}
+/** A sex as a program reads it: M, F, else U. */
+export function sexRaw(v) {
+    return v === "M" || v === "F" ? v : "U";
+}
+/** The sources a conflict's decision weighed: those of its claims, and those of the fact of the user's edit. */
+export function weighedSources(tree, c) {
+    const out = new Set(c.claims.map((x) => x.source).filter((s) => !!s));
+    if (c.edit)
+        for (const owner of c.subject) {
+            const rec = tree.get(owner);
+            const e = rec && (rec.type === "person" || rec.type === "family") ? rec.events.find((x) => x.id === c.edit.event) : undefined;
+            for (const cite of e?.citations ?? [])
+                out.add(cite.source);
+        }
+    return out;
+}
+/**
+ * Whether a decided conflict may be decided again (strom conflict resolve), else why not: only with a reason; a side
+ * once taken is not taken again (its fact is written: changed with the fact commands); what the user decided, an agent
+ * decides again only on a source the decision did not weigh.
+ */
+export function againAllowed(tree, c, how) {
+    const was = c.resolution ?? "";
+    const params = { id: c.id, resolution: was, ...(c.taken ? { take: c.taken } : {}), ...(c.decidedBy ? { by: c.decidedBy } : {}) };
+    if (!how.reason)
+        throw new UsageError(`${c.id} is decided already: "${was.slice(0, 120)}"${c.decidedBy === "user" ? " — the user's decision" : ""}`, {
+            hint: c.decidedBy === "user" ? `the user's decision stands; deciding it again needs a new source and a reason: strom conflict resolve ${c.id} … --source S… --reason "<what the new record shows>"` : `deciding again needs --reason (e.g. "the marriage entry of 1839 overturns it")`,
+            code: "conflict.decided",
+            params,
+        });
+    if (how.side && c.taken)
+        throw new UsageError(`${c.id} took the ${c.taken === "user" ? "user's" : "research's"} value already: its fact is written — change the fact with the fact commands (event edit, event retract), then decide it again with --resolution`, {
+            hint: `strom conflict show ${c.id}`,
+            code: "conflict.taken",
+            params,
+        });
+    if (c.decidedBy === "user" && how.by === "agent") {
+        const weighed = weighedSources(tree, c);
+        const fresh = how.sources.filter((s) => !weighed.has(s));
+        if (!fresh.length)
+            throw new UsageError(`${c.id} is the user's decision: an agent decides it again only on a source it did not weigh (${[...weighed].join(", ") || "none"})`, {
+                hint: `strom conflict resolve ${c.id} … --source S… --reason "<what the new record shows>" — or ask the user`,
+                code: "conflict.user-decided",
+                params,
+            });
+    }
+}

package/dist/core/directions.js

@@ -20,19 +20,40 @@ export function namesId(text, id) {
 }
 const PERSON_ID = /(?<![\p{L}\p{M}\p{N}])P\d{4,}(?![\p{L}\p{M}\p{N}])/gu;
 /**
- * The people a hypothesis is about: those of its subject, and the people of the tree its question and its variants'
- * claims name by ID ("the son of P0012 and P0013") — a variant that names a family nothing links to the tree would
- * join it, though the subject names only the person of the tree. What each variant cites for or against it is
- * evidence, not who it is about.
+ * The people a hypothesis is about: those of its subject, and the people its variants' links would connect (strom
+ * hypothesis link). A hypothesis no variant of which says what it would connect yet: the people of the tree its
+ * question and its variants' claims name by ID instead ("the son of P0012 and P0013") — a variant that names a family
+ * nothing links to the tree would join it, though the subject names only the person of the tree. Once links say it,
+ * an ID in a claim is context (a wife, a witness), not who it is about. What each variant cites for or against it is
+ * evidence, never who it is about.
  */
 export function hypothesisPeople(tree, h) {
-    const named = [h.question, ...h.variants.map((v) => v.claim)].flatMap((text) => text.match(PERSON_ID) ?? []);
+    const linked = h.variants.some((v) => v.links?.length);
+    const named = linked
+        ? h.variants.flatMap((v) => (v.links ?? []).flatMap((l) => linkPeople(tree, l)))
+        : [h.question, ...h.variants.map((v) => v.claim)].flatMap((text) => text.match(PERSON_ID) ?? []);
     const people = named.filter((id) => {
         const p = tree.get(id);
         return p && !p.retracted;
     });
     return [...new Set([...aboutPeople(tree, h.subject), ...people])];
 }
+/** The people one variant names: those its links would connect and those its claim names by ID. */
+export function variantPeople(tree, v) {
+    return [...new Set([...(v.links ?? []).flatMap((l) => linkPeople(tree, l)), ...(v.claim.match(PERSON_ID) ?? [])])];
+}
+/** The variants that would join these people (any of them): by their links, or their claim naming them by ID. */
+export function joiningVariants(tree, h, people) {
+    const set = new Set(people);
+    return h.variants.filter((v) => variantPeople(tree, v).some((x) => set.has(x))).map((v) => v.label);
+}
+/** The people a variant's link would connect: the child and its parents (the partners of its family), or its persons. */
+export function linkPeople(tree, l) {
+    if (l.kind !== "child")
+        return l.persons;
+    const family = l.family ? tree.get(l.family) : undefined;
+    return [l.person, ...(l.parents ?? []), ...(family && !family.retracted ? family.partners : [])];
+}
 /** The direction a task belongs to: its own, else the narrowest one its people are in; none for a task about nobody. */
 export function directionOf(tree, t, all) {
     if (t.research)

package/dist/core/edge.js

@@ -6,7 +6,7 @@
 // tree ends (_STROM_EDGE, _STROM_ISLAND) and what `strom edge` says.
 import { now } from "./tree.js";
 import { Settings } from "./config.js";
-import { aboutPeople, directionOf, hypothesisPeople, namesId, scopes } from "./directions.js";
+import { aboutPeople, directionOf, hypothesisPeople, joiningVariants, namesId, scopes } from "./directions.js";
 import { birthEstimate, birthRecordProven, birthWindow, frontier, FRONTIER_LEVELS, RECORD_KINDS, recordsetsCovering } from "./frontier.js";
 import { kinship, offTree } from "./kin.js";
 import { familiesAsChild, familiesAsPartner, parentsOf, primaryName } from "./people.js";
@@ -23,12 +23,13 @@ export const EDGE_MISSING = ["parents", "father", "mother", "proof"];
  */
 export const EDGE_SCOPES = ["in", "limit", "paused", "done", "living", "outside", "off-tree"];
 /**
- * What the records say so far, from the most final: the baptism names no father (born out of wedlock); every year of the
+ * What the records say so far, from the most final: the baptism names no father (born out of wedlock); a variant of an
+ * open hypothesis names the parents, nobody linked them (strom hypothesis link --child: the user decides); every year of the
  * birth is searched in vain or has no records — lost, before the known records begin, a gap in them; searched in
  * vain everywhere strom knew to look; the books left are only in the archive; searched in part; not searched yet;
  * no book of the birthplace known; the birthplace unknown; nothing to go on (no year, no place).
  */
-export const EDGE_ENDS = ["unnamed", "lost", "before-records", "gap", "not-found", "offline", "partly", "unsearched", "no-books", "no-place", "no-clue"];
+export const EDGE_ENDS = ["unnamed", "named", "lost", "before-records", "gap", "not-found", "offline", "partly", "unsearched", "no-books", "no-place", "no-clue"];
 /**
  * What comes next: an agent works on it now, it waits for the user, it is in the queue, it waits out of the queue
  * (a direction paused, people off the tree, put aside), strom proposes it with the next session, everything strom
@@ -83,7 +84,11 @@ function islands(tree, kin, tasks, hypotheses) {
             hypotheses: hypotheses
                 .map((h) => ({ h, about: hypothesisPeople(tree, h) }))
                 .filter(({ about }) => about.some((x) => people.has(x)) && about.some((x) => kin.has(x)))
-                .map(({ h, about }) => ({ id: h.id, joins: about.filter((x) => kin.has(x)) })),
+                .map(({ h, about }) => {
+                // the variants that would join this family: they name its people
+                const variants = joiningVariants(tree, h, people);
+                return { id: h.id, joins: about.filter((x) => kin.has(x)), ...(variants.length ? { variants } : {}) };
+            }),
             held: tasks.filter((t) => LIVE.has(t.state) && off(t) && aboutPeople(tree, t.subject).some((x) => people.has(x))).length,
         };
         for (const id of people)
@@ -91,8 +96,34 @@ function islands(tree, kin, tasks, hypotheses) {
     }
     return out;
 }
-/** Every edge of the tree with something the research knows of it, and the families nothing links to the tree. */
-export function treeEdges(tree) {
+/**
+ * Whether a variant of the hypothesis would make the person a child of parents of the tree (strom hypothesis link
+ * --child): a family there, or parents there — not already (as the Strom file says it: core/gedcom export).
+ */
+function namesParents(tree, h, person) {
+    const there = (id) => {
+        const p = tree.get(id);
+        return !!p && !p.retracted;
+    };
+    return h.variants.some((v) => (v.links ?? []).some((l) => {
+        if (l.kind !== "child" || l.person !== person)
+            return false;
+        const parents = [...new Set(l.parents ?? [])];
+        // parents of no family together — none since, with the child in it
+        if (!l.family)
+            return (parents.length > 0 &&
+                parents.every(there) &&
+                !familiesAsChild(tree, person).some((f) => !f.retracted && f.partners.length === parents.length && parents.every((x) => f.partners.includes(x))));
+        const f = tree.get(l.family);
+        return !!f && !f.retracted && !f.children.some((c) => c.person === person);
+    }));
+}
+/**
+ * Every edge of the tree with something the research knows of it, and the families nothing links to the tree.
+ * `named`: an edge whose parents a variant names (the end named) — off for a Strom app that does not know it yet.
+ */
+export function treeEdges(tree, opts = {}) {
+    const named = opts.named ?? true;
     const lang = tree.lang;
     const today = now().slice(0, 10);
     const kin = kinship(tree);
@@ -220,10 +251,14 @@ export function treeEdges(tree) {
                     open.push({ year: y, online: kept.some((b) => b.access === "online-free" || b.access === "online-login") });
             }
         const earliest = Math.min(...placeBooks.map((b) => yearsOf(b.years)?.from ?? Infinity));
+        // the parents a variant of an open hypothesis names, not linked: the user decides it (the hypothesis, its tests)
+        const naming = named && missing !== "proof" ? hyps.filter(({ h }) => namesParents(tree, h, p.id)).map(({ h }) => h.id) : [];
         let end;
         // the baptism is read and names the mother alone (a child born out of wedlock); a mother missing is one not recorded yet
         if (missing === "father" && proven)
             end = "unnamed";
+        else if (naming.length)
+            end = "named";
         else if (!est.place)
             end = est.year ? "no-place" : "no-clue";
         else if (!placeBooks.length)
@@ -251,15 +286,21 @@ export function treeEdges(tree) {
             const joining = kin.size > 0 && about.some((x) => kin.has(x)) && about.some((x) => !kin.has(x));
             const joins = joining ? about.filter((x) => kin.has(x) !== onTree) : [];
             const isle = joins.length && onTree ? isles.get(joins[0]) : undefined;
+            // the variants that would make the join: those that name the people off the tree
+            const variants = joins.length ? joiningVariants(tree, h, onTree ? joins : (isles.get(p.id)?.people ?? [p.id])) : [];
             return {
                 id: h.id,
                 question: h.question,
                 joins,
                 ...(isle ? { island: { people: isle.people.length, held: isle.held } } : {}),
+                ...(variants.length ? { variants } : {}),
                 // a task about it, or one whose words name it ("the baptism … (H0007 B)")
                 tests: tasks.filter((t) => LIVE.has(t.state) && (t.subject.includes(h.id) || namesId(t.what, h.id))).map((t) => t.id),
             };
         });
+        // named, and no task tests the hypotheses that name them: what comes next is the user's decision
+        const untested = naming.length > 0 && edgeHyps.filter((h) => naming.includes(h.id)).every((h) => !h.tests.length);
+        const nextNow = end === "named" && untested && (next === "none" || next === "proposed") ? "decide" : next;
         const edgeConflicts = conflicts
             .filter((c) => subjectPeople(tree, c.subject).includes(p.id) && (!c.fact || EDGE_FACTS.has(c.fact)))
             .map((c) => c.id);
@@ -276,7 +317,7 @@ export function treeEdges(tree) {
             scope,
             ...(through ? { research: through.research.id, generation: through.people.get(p.id) } : {}),
             end,
-            next,
+            next: nextNow,
             ...(est.year || est.place ? { estimate: { ...(est.year ? { year: est.year } : {}), ...(est.place ? { place: est.place } : {}), ...(est.basis ? { basis: est.basis } : {}) } } : {}),
             ...(window ? { window } : {}),
             ...(Number.isFinite(earliest) && (end === "before-records" || noRecords.some((y) => y < earliest)) ? { recordsFrom: earliest } : {}),

package/dist/core/links.js

@@ -62,6 +62,8 @@ export const LINK_DIRECTION_DOS = ["pause", "done", "resume"];
 export const LINK_SYNC_DOS = ["show"];
 /** What a link does with a conflict: the user decides it, or leaves it to the agent. */
 export const LINK_CONFLICT_DOS = ["decide", "agent"];
+/** The side a conflict of the user's edit is decided for, picked in the app: the terminal asks only to confirm and why. */
+export const LINK_CONFLICT_TAKES = ["user", "research"];
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const SOURCE = /^S\d{1,9}$/;
 const PERSON = /^P\d{1,9}$/;
@@ -227,8 +229,12 @@ export function parseLink(text, scheme = LINK_SCHEME) {
             const partner = idOf(q, "partner", PERSON, false);
             return { action, tree: id, person, ...(partner ? { partner } : {}), do: oneOf(q, "do", LINK_STORY_DOS) };
         }
-        case "conflict":
-            return { action, tree: id, id: idOf(q, "id", CONFLICT, true), do: oneOf(q, "do", LINK_CONFLICT_DOS, "decide") };
+        case "conflict": {
+            const how = oneOf(q, "do", LINK_CONFLICT_DOS, "decide");
+            // the side, only of a decision, only one of its fixed values
+            const take = how === "decide" && q.has("take") ? oneOf(q, "take", LINK_CONFLICT_TAKES) : undefined;
+            return { action, tree: id, id: idOf(q, "id", CONFLICT, true), do: how, ...(take ? { take } : {}) };
+        }
         case "sync-undo":
             return { action, tree: id, intake: idOf(q, "intake", INPUT, true) };
         case "sync": {

package/dist/core/live.js

@@ -26,6 +26,8 @@
 //                          X-Strom-Batch, -Path (and -Zip: 1, a ZIP unpacked here): one file of a batch
 //   POST <token>/batch/<id>/done   the batch is whole ({name, files, person, note}): its files become sorting tasks
 //                          (a batch nobody closes is closed a day after its last file)
+//   POST <token>/conflict/<X…>   the person decides a conflict of their edit in the app by side ({"do": "decide",
+//                          "take": "user" | "research", "note"?}): strom conflict resolve --take, written as the user's
 //   GET <token>/adopt      a new research waits for a tree of the app: its mark, name, until when; transfer: true when
 //                          the tree comes from a browser the app cannot reach strom from; existing: true when it goes
 //                          into a research made before, its tree never came (POST /adopt hands it over)
@@ -62,7 +64,7 @@ import path from "node:path";
 import crypto from "node:crypto";
 import { spawn, spawnSync } from "node:child_process";
 import { withoutAgentMarks } from "./which.js";
-import { newerTree, Tree, TREE_FILE, VERSION } from "./tree.js";
+import { newerTree, Tree, TREE_FILE, typeOfId, VERSION } from "./tree.js";
 import { readJsonIfExists } from "./json.js";
 import { changeLines } from "./changelog.js";
 import { directionOf, scopes } from "./directions.js";
@@ -87,11 +89,13 @@ 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, appUrlSetting, isAppVersion, isStromAppOrigin } from "./stromapp.js";
+import { appKnowsArchive, appKnowsNoCouple, appShowsHypothesisLinks, appDecidesConflicts, 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";
 import { diskVersion, stromLauncher } from "./self.js";
+import { sidesOf } from "./conflicts.js";
+import { normId } from "./records.js";
 import { foldText } from "./text.js";
 import { storiesToApprove } from "./stories.js";
 /**
@@ -145,6 +149,15 @@ function said(lang, key, params = {}) {
  * - `batch.closed` 409 {batch} — the batch is closed already: send the rest as a new batch
  * - `batch.full-files` 413 {batch, files}; `batch.full-bytes` 413 {batch, gb} — the most a batch takes
  * - `batch.none` 404 {batch} — POST /batch/<id>/done: no such batch here; `batch.bad-body` 400 — its body no JSON
+ *
+ * A decision of the person (POST /conflict/<X…>): 200 {decided, take, head, written, person?, family?}, else
+ * - `app.only` 403; `decide.bad-body` 400 — no JSON {"do": "decide", …}; `conflict.bad-take` 400 — take not user|research
+ * - `conflict.none` 404 {id} — no such conflict; `conflict.no-edit` 422 {id} — not one the app decides by side
+ * - `conflict.decided` 409 {id} (and resolution, take, at, by, in) — decided already (a terminal, an agent, the app)
+ * - `research.busy` 503 (and Retry-After, `retry`) — a send or an adoption is being written, another decision, another
+ *   strom holding the research: ask again in a moment
+ * - `locked` 423 (and reasonCode, reasonParams) — a newer strom wrote the research: this one never writes it
+ * - `decide.failed` 500 — went wrong (the English sentence says why)
  */
 function refusal(error, code, params = {}) {
     return { error, code, text: error, ...(Object.keys(params).length ? { params } : {}) };
@@ -593,7 +606,7 @@ function idsOf(applied, known) {
     return Object.keys(ids.persons).length || Object.keys(ids.sources).length ? { ids } : {};
 }
 /** What the bridge does that an app may ask about (each added once, never taken away). */
-export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes"];
+export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes", "hypothesis.links", "conflict.decide"];
 export function history(root, tree, range = [`-n${LOG_MAX}`]) {
     const r = runGit(root, ["log", ...range, "--format=%x1e%H%x1f%cI%x1f%s%x1f%b%x1f", "--name-only"]);
     if (r.status !== 0)
@@ -1050,7 +1063,7 @@ export function serveLive(root, env) {
             catch {
                 // not JSON: the status alone
             }
-            const marks = ["code", "reasonCode", "intake", "input", "changes", "applied", "pending", "keptAs", "known", "batch", "sha"]
+            const marks = ["code", "reasonCode", "decided", "take", "intake", "input", "changes", "applied", "pending", "keptAs", "known", "batch", "sha"]
                 .filter((k) => said[k] !== undefined && said[k] !== null && typeof said[k] !== "object")
                 .map((k) => `${k} ${String(said[k]).slice(0, 80)}`);
             if (Array.isArray(said.conflicts) && said.conflicts.length)
@@ -1153,6 +1166,10 @@ export function serveLive(root, env) {
             batchDone(req, res, origin, decodeURIComponent(sub ?? ""));
             return;
         }
+        if (req.method === "POST" && t === token && what === "conflict" && sub && !act) {
+            decideFor(req, res, origin, "conflict", decodeURIComponent(sub), conflictDecision);
+            return;
+        }
         if (req.method !== "GET" || t !== token) {
             res.writeHead(404).end();
             return;
@@ -1251,12 +1268,14 @@ export function serveLive(root, env) {
                     const turnsExcerpts = appTurnsExcerpts(new Settings(env, {}), version);
                     const noCouple = appKnowsNoCouple(new Settings(env, {}), version);
                     const titles = appReadsTitles(new Settings(env, {}), version);
+                    const hypothesisLinks = appShowsHypothesisLinks(new Settings(env, {}), version);
+                    const conflictSides = appDecidesConflicts(new Settings(env, {}), version);
                     const offered = opens ? links(env) : [];
                     ged = {
                         head: h,
                         links: offered.join(" "),
                         version: version ?? "",
-                        text: exportGedcom(tree, { for: "strom", ...(h ? { head: h } : {}), ...(images ? { excerpts: images.of } : {}), ...(opens ? { clips: true, research: true } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}), ...(offered.length ? { links: offered, ...(linkScheme(env) !== LINK_SCHEME ? { linkScheme: linkScheme(env) } : {}) } : {}) }).text,
+                        text: exportGedcom(tree, { for: "strom", ...(h ? { head: h } : {}), ...(images ? { excerpts: images.of } : {}), ...(opens ? { clips: true, research: true } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}), ...(hypothesisLinks ? { hypothesisLinks } : {}), ...(conflictSides ? { conflictSides } : {}), ...(offered.length ? { links: offered, ...(linkScheme(env) !== LINK_SCHEME ? { linkScheme: linkScheme(env) } : {}) } : {}) }).text,
                     };
                 }
                 res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store", "X-Strom-Head": h }).end(ged.text);
@@ -1925,6 +1944,150 @@ export function serveLive(root, env) {
             closeBatchNow(id, extra, reply);
         }));
     };
+    /**
+     * A decision of the person in the app (POST /conflict/<X…>; one route of each kind — a hypothesis's later shares
+     * this): checked here, then written by a strom of its own as the user's (forApp: the command the terminal runs, its
+     * lock, its log and commit), one at a time and never while a send or an adoption is written — then busy (503 +
+     * Retry-After, research.busy: what the bridge says of an original or a batch the research cannot take now). Every
+     * kind answers alike: 200 {decided, head, written, …}; its refusals by their codes (`<kind>.none` 404, `<kind>.decided`
+     * 409, …), the research a newer strom wrote 423 `locked`, not from the app's pages 403 `app.only`.
+     */
+    let deciding;
+    const DECIDE_RETRY_S = 5;
+    const decideFor = (req, res, origin, kind, raw, how) => {
+        const reply = (code, body) => {
+            if (!res.headersSent)
+                res.writeHead(code, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store", ...(code === 503 ? { "Retry-After": String(body.retry ?? DECIDE_RETRY_S) } : {}) }).end(JSON.stringify(body));
+        };
+        if (!origin) {
+            req.resume();
+            return reply(403, refusal("only the Strom app may decide here", "app.only"));
+        }
+        let text = "";
+        let over = false;
+        req.on("data", (c) => {
+            if (text.length + c.length > 8192)
+                over = true;
+            else
+                text += c.toString("utf8");
+        });
+        req.on("end", () => safely(req, res, () => {
+            // a research a newer strom wrote: never opened, never written (as /status says it: locked)
+            const newer = newerTree(root, env);
+            if (newer)
+                return reply(423, { ...refusal(newer.message, "locked"), reasonCode: newer.code, ...(newer.params ? { reasonParams: newer.params } : {}) });
+            let body = {};
+            try {
+                const parsed = text.trim() ? JSON.parse(text) : {};
+                if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+                    throw new Error("not an object");
+                body = parsed;
+            }
+            catch {
+                over = true;
+            }
+            if (over || body.do !== "decide")
+                return reply(400, refusal(`the body: JSON {"do": "decide", …}`, "decide.bad-body"));
+            const id = /^[A-Za-z]\d{1,9}$/.test(raw) ? normId(raw) : "";
+            const tree = Tree.open(root, env);
+            const rec = id && typeOfId(id) === kind ? tree.get(id) : undefined;
+            if (!rec || rec.type !== kind)
+                return reply(404, refusal(`no ${kind} ${raw.slice(0, 32)} in this research`, `${kind}.none`, { id: raw.slice(0, 32) }));
+            const asked = how.ask(tree, rec, body);
+            if ("code" in asked)
+                return reply(asked.code, asked.body);
+            // a send or an adoption being written, another decision: asked again in a moment
+            if (writing || adopting || deciding)
+                return reply(503, { ...refusal("the research is busy — ask again in a moment", "research.busy"), retry: DECIDE_RETRY_S });
+            deciding = id;
+            const { command, args } = stromLauncher();
+            const child = spawn(command, [...args, ...asked.args, "--json"], { cwd: root, env: forApp(env, root), stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+            track(child);
+            let out = "";
+            let err = "";
+            child.stdout.on("data", (d) => (out += d.toString("utf8")));
+            child.stderr.on("data", (d) => (err += d.toString("utf8")));
+            child.on("error", (e) => {
+                deciding = undefined;
+                reply(500, refusal(errorText(e), "decide.failed"));
+            });
+            child.on("close", (code) => {
+                deciding = undefined;
+                if (code === null)
+                    return;
+                let data = {};
+                try {
+                    data = JSON.parse(out);
+                }
+                catch {
+                    // said by the exit code
+                }
+                const now = Tree.open(root, env);
+                if (code === 0)
+                    return reply(200, how.done(now, id, data, head(root)));
+                const why = String(data.message ?? err.trim().split("\n").find((l) => l.startsWith("error:"))?.slice(6).trim() ?? `exit ${code}`);
+                noteLive(root, `${id} was not decided (exit ${code}): ${why}`);
+                // the research busy (another strom holding it longer than a writer waits)
+                if (code === EXIT.locked)
+                    return reply(503, { ...refusal(why, "research.busy"), retry: DECIDE_RETRY_S });
+                const known = typeof data.code === "string" ? how.refused(now, id, data.code, why) : undefined;
+                reply(known?.code ?? 500, known?.body ?? { ...refusal(why, "decide.failed"), ...(typeof data.code === "string" ? { reasonCode: data.code } : {}) });
+            });
+        }));
+    };
+    /** Whose a conflict is, as the app finds it: its person (a couple's: its first partner) and its family. */
+    const conflictOwners = (tree, c) => {
+        const person = c.subject.find((s) => s.startsWith("P"));
+        const family = c.subject.find((s) => s.startsWith("F"));
+        const partner = person ?? (family ? tree.get(family)?.partners[0] : undefined);
+        return { ...(partner ? { person: partner } : {}), ...(family ? { family } : {}) };
+    };
+    /** A conflict decided already: what was decided, which side, when and by whom. */
+    const decidedAnswer = (c) => ({
+        ...refusal(`${c.id} is decided already: ${c.resolution ?? ""}`, "conflict.decided", { id: c.id }),
+        resolution: c.resolution ?? "",
+        ...(c.taken ? { take: c.taken } : {}),
+        ...(c.decidedAt ? { at: c.decidedAt } : {}),
+        ...(c.decidedBy ? { by: c.decidedBy } : {}),
+        ...(c.decidedIn ? { in: c.decidedIn } : {}),
+    });
+    /** POST /conflict/<X…> {"do": "decide", "take": "user" | "research", "note"?}: strom conflict resolve --take, the user's. */
+    const conflictDecision = {
+        ask(tree, rec, body) {
+            const c = rec;
+            if (c.state !== "open")
+                return { code: 409, body: decidedAnswer(c) };
+            if (!sidesOf(c))
+                return { code: 422, body: refusal(`${c.id} is no conflict of an edit in the Strom app the app decides by side`, "conflict.no-edit", { id: c.id }) };
+            if (body.take !== "user" && body.take !== "research")
+                return { code: 400, body: refusal(`"take" is "user" or "research"`, "conflict.bad-take") };
+            if (body.note !== undefined && typeof body.note !== "string")
+                return { code: 400, body: refusal(`"note" is text`, "decide.bad-body") };
+            // the person's note: one line of text, 200 characters at most (the rest cut)
+            const note = [...String(body.note ?? "").replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim()].slice(0, 200).join("").trim();
+            const decided = phrase(tree.lang, "conflict.app.decided");
+            const reasoning = note ? phrase(tree.lang, "conflict.app.noted", { decided, note }) : decided;
+            return { args: ["conflict", "resolve", c.id, `--take=${body.take}`, `--reasoning=${reasoning}`] };
+        },
+        done(tree, id, data) {
+            const c = tree.get(id);
+            return {
+                decided: id,
+                take: c.taken ?? data.taken,
+                head: head(root),
+                written: typeof data.written === "string" ? data.written : `${id} decided: the research's value kept`,
+                ...conflictOwners(tree, c),
+            };
+        },
+        refused(tree, id, code, why) {
+            const c = tree.get(id);
+            if (c && ["conflict.decided", "conflict.taken", "conflict.user-decided"].includes(code))
+                return { code: 409, body: decidedAnswer(c) };
+            if (code === "conflict.no-edit")
+                return { code: 422, body: refusal(why, "conflict.no-edit", { id }) };
+            return undefined;
+        },
+    };
     /** The app sends nothing (unchanged, the user said no, no tree of this research): strom sync --app stops waiting. */
     const nothing = (req, res, origin) => {
         const reply = (code, body) => res.writeHead(code, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }).end(JSON.stringify(body));

package/dist/core/model.js

@@ -50,6 +50,13 @@ export const SEARCH_RESULTS = ["found", "negative", "partial", "inconclusive"];
 export const STRATEGIES = ["balanced", "depth", "priority"];
 export const TASK_LEVELS = ["intake", "locate", "link", "verify", "enrich", "request", "narrate"];
 export const TASK_STATES = ["open", "doing", "done", "parked", "waiting", "dropped"];
+/**
+ * What a variant of a hypothesis would connect, were it true (strom hypothesis link): whose child a person is — a
+ * family of the tree, or one or two parents who have no family together —, two records of one person, a couple, or
+ * siblings whose parents are unknown. Nothing of it is a link of the tree: the variant's claim, said so a program can
+ * show it (the Strom app: _VAR / _LINK under _STROM_HYPO).
+ */
+export const VARIANT_LINK_KINDS = ["child", "same", "partners", "siblings"];
 export const LESSON_SCOPES = ["method", "repository", "recordset", "place", "project"];
 export const LESSON_MAX = 200;
 export const INPUT_KINDS = ["document", "photo", "tree", "text", "other"];