strom-research 1.5.0 → 1.6.0

package/dist/core/stromapp.js

@@ -39,10 +39,35 @@ export const APP_SENDS_CHANGES = "3.3.0";
 export function appSendsChanges(settings) {
     return APP_SENDS_CHANGES !== undefined || stromAppUrl(settings) !== STROM_APP_URL;
 }
+/**
+ * The Strom app opens strom-research:// links (the app's spec docs/ZADANI_VYZKUM_ODKAZY_Z_APLIKACE.md): it reads
+ * each excerpt's mark (_STROM_CLIP) and the links a research offers (_STROM_LINKS in the GEDCOM the bridge serves).
+ * The first version of stromapp.info that does (3.4.0, 2026-09-27); another copy of the app (its beta, its
+ * development: strom.app.url) is taken as current. An app of a known version (strom.version) goes by it.
+ */
+export const APP_OPENS_LINKS = "3.4.0";
+export function appOpensLinks(settings, version) {
+    if (stromAppUrl(settings) !== STROM_APP_URL)
+        return true;
+    if (!APP_OPENS_LINKS)
+        return false;
+    if (!version)
+        return true;
+    const n = (v) => v.split(".").map((x) => Number.parseInt(x, 10) || 0);
+    const [a, b] = [n(version), n(APP_OPENS_LINKS)];
+    for (let i = 0; i < 3; i++)
+        if ((a[i] ?? 0) !== (b[i] ?? 0))
+            return (a[i] ?? 0) > (b[i] ?? 0);
+    return true;
+}
 /** The address that opens the Strom app to send the user's edited tree to the bridge. */
 export function sendAppUrl(bridge, settings) {
     return `${stromAppUrl(settings)}?send=${encodeURIComponent(bridge)}`;
 }
+/** The address that opens the Strom app to hand one of its trees to a new research (strom-research://new). */
+export function adoptAppUrl(bridge, settings) {
+    return `${stromAppUrl(settings)}?adopt=${encodeURIComponent(bridge)}`;
+}
 /** The address that opens the Strom app following a research through its bridge. */
 export function liveAppUrl(bridge, settings) {
     return `${stromAppUrl(settings)}?live=${encodeURIComponent(bridge)}`;

package/dist/core/sync.js

@@ -358,7 +358,86 @@ export function receivedSince(root, since) {
         return undefined;
     return fs
         .readdirSync(dir)
-        .filter((f) => f.endsWith(".ged"))
+        .filter((f) => f.endsWith(".ged") && !f.startsWith("adopt-"))
+        .map((f) => path.join(dir, f))
+        .filter((f) => fs.statSync(f).mtimeMs >= since)
+        .sort()
+        .pop();
+}
+// ── a tree of the Strom app becomes a research (strom-research://new, ?adopt=) ──
+/** Where a new research waits for the tree of the app it was started for: the app's mark, since when. */
+const ADOPT_FILE = path.join(".strom", "adopt.json");
+/** How long the app's mark is good (the app keeps it an hour too). */
+export const ADOPT_FOR_MS = 60 * 60_000;
+/** This research waits for the app's tree with this mark (the link's app=…). */
+export function awaitAdoption(root, token) {
+    fs.mkdirSync(path.join(root, ".strom"), { recursive: true });
+    fs.writeFileSync(path.join(root, ADOPT_FILE), JSON.stringify({ token, at: new Date().toISOString() }));
+}
+/** The mark of the tree this research waits for — none when it waits for none, got it already, or waited too long. */
+export function pendingAdoption(root) {
+    try {
+        const a = JSON.parse(fs.readFileSync(path.join(root, ADOPT_FILE), "utf8"));
+        return a.token && !a.done && Date.now() - Date.parse(a.at ?? "") < ADOPT_FOR_MS ? a.token : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The app's tree for a new research (POST <bridge>/adopt): a GEDCOM, kept in the inbox for the research in the
+ * terminal to take in — nothing of the research changes here. Taken once; the file it was kept as.
+ */
+export function receiveAdopted(root, text) {
+    if (!pendingAdoption(root))
+        throw new UsageError("this research waits for no tree");
+    if (!/^\uFEFF?\s*0\s+HEAD/.test(text))
+        throw new UsageError("not a GEDCOM file");
+    if (!/^1 INDI\b|^0 @[^@]+@ INDI\b/m.test(text))
+        throw new UsageError("empty: no people in it");
+    const dir = path.join(root, SYNC_INBOX);
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, `adopt-${new Date().toISOString().replace(/[:.]/g, "-")}.ged`);
+    fs.writeFileSync(file, text);
+    const a = JSON.parse(fs.readFileSync(path.join(root, ADOPT_FILE), "utf8"));
+    fs.writeFileSync(path.join(root, ADOPT_FILE), JSON.stringify({ ...a, done: new Date().toISOString() }));
+    return file;
+}
+/** Why the app's tree was not taken (POST <bridge>/adopt refused): noted for the research in the terminal, which stops waiting. */
+export function noteAdoptFailed(root, why) {
+    const dir = path.join(root, SYNC_INBOX);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, `adopt-failed-${Date.now()}.json`), JSON.stringify({ why, at: new Date().toISOString() }));
+}
+/** The app's tree was refused since `since` (ms): why. */
+export function adoptFailedSince(root, since) {
+    const dir = path.join(root, SYNC_INBOX);
+    if (!fs.existsSync(dir))
+        return undefined;
+    const last = fs
+        .readdirSync(dir)
+        .filter((f) => f.startsWith("adopt-failed-"))
+        .map((f) => path.join(dir, f))
+        .filter((f) => fs.statSync(f).mtimeMs >= since)
+        .sort()
+        .pop();
+    if (!last)
+        return undefined;
+    try {
+        return JSON.parse(fs.readFileSync(last, "utf8")).why;
+    }
+    catch {
+        return "other";
+    }
+}
+/** The tree the app handed over since `since` (ms), if any. */
+export function adoptedSince(root, since) {
+    const dir = path.join(root, SYNC_INBOX);
+    if (!fs.existsSync(dir))
+        return undefined;
+    return fs
+        .readdirSync(dir)
+        .filter((f) => f.startsWith("adopt-") && f.endsWith(".ged"))
         .map((f) => path.join(dir, f))
         .filter((f) => fs.statSync(f).mtimeMs >= since)
         .sort()
@@ -488,7 +567,7 @@ export function planSync(tree, incoming, edits, opts = {}) {
         }
         if (was && !partial)
             for (const b of was)
-                if (!incKeys.has(factKey(b)) && !used.has(factKey(b)) && carried.has(kindOf(b.kind)) && ourKeys.has(factKey(b)))
+                if (!incKeys.has(factKey(b)) && !used.has(factKey(b)) && carried.has(kindOf(b.kind)) && ourKeys.has(factKey(b)) && !keptOnce(owner, b, inc))
                     push({ kind: "fact.gone", action: "report", ...owner, was: b });
     };
     // people
@@ -559,6 +638,16 @@ export function planSync(tree, incoming, edits, opts = {}) {
     return { changes, base: !!base, ...(incoming.head ? { head: incoming.head } : {}), partial, identity };
 }
 /** Does the research's fact say all the file's fact says, and more: the same kind, and each of its date, place, value the same or missing in the file. */
+/**
+ * The Strom app keeps a couple's marriages and divorces as the course of one union: two marriages with no divorce
+ * between are one marriage to it, the first (found live, 2026-09-27: a marriage from the register and a later
+ * record's other date). A further one of these missing while the file has one of that kind is its shape, not an edit.
+ */
+const UNION_KINDS = new Set(["MARR", "DIV"]);
+function keptOnce(owner, gone, file) {
+    const kind = kindOf(gone.kind);
+    return !!owner.family && UNION_KINDS.has(kind) && file.some((f) => kindOf(f.kind) === kind);
+}
 function knowsMore(ours, file) {
     if (kindOf(ours.kind) !== kindOf(file.kind))
         return false;
@@ -658,6 +747,7 @@ export function applySync(tree, plan, incoming, source, only) {
                     const title = `${(c.name ?? owner).replace(/\//g, "").replace(/\s+/g, " ").trim()}: ${c.fact.kind} — ${describe(mine)} × ${describe(c.fact)}`;
                     const x = create(tree, "conflict", {
                         title: title.slice(0, 200),
+                        fact: c.fact.kind,
                         subject: [owner],
                         claims: [
                             { ...(mine.citations[0] ? { source: mine.citations[0].source } : {}), value: describe(mine), note: `the research: ${mine.id}` },

package/dist/core/tree.js

@@ -23,7 +23,7 @@ import * as git from "./git.js";
 import { commitSeal, createKey, fingerprint, loadKey, sha256, signOp } from "./seal.js";
 import { stringifyCanonical } from "./json.js";
 export const TREE_FILE = "strom.json";
-export const VERSION = "1.5.0";
+export const VERSION = "1.6.0";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/dist/core/uninstall.js

@@ -12,6 +12,7 @@ import { shortcutCmdDir } from "./shortcut.js";
 import { globalTargets, isInstalled, uninstallGlobal } from "../agents/global.js";
 import { PROFILES } from "../agents/profiles.js";
 import { installation } from "./self.js";
+import { linkFiles, unregisterLinks } from "./links.js";
 /** The mark the installer (install/install.sh) puts on the PATH line it adds. */
 const MARK = "# strom research";
 function exists(p) {
@@ -100,6 +101,8 @@ export function uninstallPlan(env, names, opts = {}) {
         remove.push({ kind: "agent", agent: PROFILES[t.agent]?.name ?? t.agent, path: t.file, remove: () => uninstallGlobal(t) });
     for (const f of shortcuts(env, platform, names))
         remove.push({ kind: "shortcut", path: f, remove: () => (fs.rmSync(f, { force: true }), true) });
+    for (const f of linkFiles(env, platform))
+        remove.push({ kind: "links", path: f, remove: () => unregisterLinks(env, platform) });
     const inst = opts.install ?? installation();
     const git = ownGitDir(env);
     // strom's own git lives in the installation's folder on Windows; alone, it goes by itself.

package/dist/gedcom/export.js

@@ -123,6 +123,18 @@ export function exportGedcom(tree, opts = {}) {
         if (pl.coords)
             for (const n of pl.names)
                 coords.set(foldText(n.name), pl.coords);
+    // What the research knows beyond the facts (the Strom profile, opts.research): read once.
+    const research = {
+        conflicts: opts.research ? tree.list("conflict") : [],
+        hypotheses: opts.research ? tree.list("hypothesis").filter((h) => h.state === "open") : [],
+        // a search is of the people of the task it served
+        searched: opts.research
+            ? tree
+                .list("search")
+                .map((q) => ({ search: q, people: (q.task ? tree.get(q.task)?.subject : undefined) ?? [] }))
+                .filter((x) => x.people.length)
+            : [],
+    };
     // ── header ──
     w.line(0, "HEAD");
     w.line(1, "SOUR", "STROM_RESEARCH");
@@ -136,6 +148,10 @@ export function exportGedcom(tree, opts = {}) {
         const head = opts.head ?? git.head(tree.root);
         if (head)
             w.line(1, "_STROM_HEAD", head);
+        if (opts.links?.length)
+            w.line(1, "_STROM_LINKS", opts.links.join(" "));
+        if (opts.research)
+            w.line(1, "_STROM_ASOF", new Date().toISOString().slice(0, 10));
     }
     w.line(1, "SUBM", "@U1@");
     w.line(1, "GEDC");
@@ -185,6 +201,8 @@ export function exportGedcom(tree, opts = {}) {
         for (const d of [...nameQuotes, ...deferred])
             w.text(1, "NOTE", d);
         story(p.story);
+        if (opts.research && opts.for === "strom")
+            known(p);
         for (const link of famc.get(p.id) ?? []) {
             w.line(1, "FAMC", x(link.fam));
             if (link.relation === "adopted" || link.relation === "foster")
@@ -297,6 +315,8 @@ export function exportGedcom(tree, opts = {}) {
             w.line(1, "OBJE");
             w.line(2, "FORM", "jpg");
             w.line(2, "_STROM_KIND", "excerpt");
+            if (opts.clips && e.clip)
+                w.line(2, "_STROM_CLIP", e.clip);
             if (e.url)
                 w.text(2, "_URL", e.url);
             w.wrapped(2, "FILE", dataUrl(e));
@@ -417,6 +437,40 @@ export function exportGedcom(tree, opts = {}) {
      * The story of a person or a couple: _STORY as Strom reads it (the facts it
      * rests on as DATA lines, the caveat as NOTE); a note in strict GEDCOM.
      */
+    /** What the research knows of a person beyond the facts: its conflicts, open hypotheses, what was searched for them. */
+    function known(p) {
+        const about = (subject) => subject.includes(p.id) || subject.some((id) => families.some((f) => f.id === id && f.partners.includes(p.id)));
+        for (const c of research.conflicts.filter((x) => about(x.subject))) {
+            w.line(1, "_STROM_CONFLICT", c.id);
+            // the fact it is about: its tag, else a conflict of the research named by its title
+            w.line(2, "TYPE", c.fact ?? "EVEN");
+            w.text(2, "TITL", c.title);
+            w.line(2, "STAT", c.state === "resolved" ? "decided" : "open");
+            for (const claim of c.claims) {
+                w.text(2, "VAL", claim.value);
+                if (claim.source && sourceById.has(claim.source)) {
+                    citedSources.add(claim.source);
+                    w.line(3, "SOUR", x(claim.source));
+                }
+            }
+            if (c.state === "resolved" && c.resolution)
+                w.text(2, "DECI", c.resolution);
+        }
+        for (const h of research.hypotheses.filter((x) => about(x.subject))) {
+            w.line(1, "_STROM_HYPO");
+            w.text(2, "TITL", h.question);
+            w.text(2, "NOTE", h.variants.map((v) => `${v.label}: ${v.claim}`).join("\n"));
+        }
+        for (const q of research.searched.filter((x) => x.people.includes(p.id)).map((x) => x.search)) {
+            w.line(1, "_STROM_SEARCHED");
+            w.text(2, "TITL", q.question);
+            const years = /^(\d{3,4})(?:\s*[-–]\s*(\d{3,4}))?$/.exec(q.scope.years ?? "");
+            if (years)
+                w.line(2, "DATE", years[2] && years[2] !== years[1] ? `FROM ${years[1]} TO ${years[2]}` : years[1]);
+            w.line(2, "RESN", q.result === "found" ? "found" : "none");
+            w.line(2, "_AT", q.created.slice(0, 10));
+        }
+    }
     function story(st) {
         if (!st)
             return;

package/dist/gedcom/validate.js

@@ -14,11 +14,15 @@ const INDI_EVENTS = [
 const FAM_EVENTS = ["MARR", "DIV", "MARB", "MARC", "MARL", "MARS", "ANUL", "DIVF", "ENGA", "CENS", "EVEN", "NCHI"];
 /** Allowed child tags by parent context ("INDI", "INDI.BIRT", …). CONC/CONT are allowed under anything with text. */
 const CHILDREN = {
-    HEAD: ["SOUR", "DEST", "DATE", "SUBM", "SUBN", "FILE", "COPR", "GEDC", "CHAR", "LANG", "PLAC", "NOTE", "_STROM_TREE", "_STROM_HEAD"],
+    HEAD: ["SOUR", "DEST", "DATE", "SUBM", "SUBN", "FILE", "COPR", "GEDC", "CHAR", "LANG", "PLAC", "NOTE", "_STROM_TREE", "_STROM_HEAD", "_STROM_LINKS", "_STROM_ASOF"],
     "HEAD.SOUR": ["VERS", "NAME", "CORP", "DATA"],
     "HEAD.GEDC": ["VERS", "FORM"],
     "HEAD.DATE": ["TIME"],
-    INDI: ["NAME", "SEX", "FAMC", "FAMS", "NOTE", "SOUR", "REFN", "ASSO", "ALIA", "OBJE", "RESN", "RIN", "CHAN", "_STORY", ...INDI_EVENTS],
+    INDI: ["NAME", "SEX", "FAMC", "FAMS", "NOTE", "SOUR", "REFN", "ASSO", "ALIA", "OBJE", "RESN", "RIN", "CHAN", "_STORY", "_STROM_CONFLICT", "_STROM_HYPO", "_STROM_SEARCHED", ...INDI_EVENTS],
+    "INDI._STROM_CONFLICT": ["TYPE", "TITL", "STAT", "VAL", "DECI"],
+    "INDI._STROM_HYPO": ["TITL", "NOTE"],
+    "INDI._STROM_SEARCHED": ["TITL", "DATE", "RESN", "_AT"],
+    _STROM_VALUE: ["SOUR"],
     "INDI.NAME": ["TYPE", "GIVN", "SURN", "NPFX", "NSFX", "NICK", "SPFX", "SOUR", "NOTE"],
     "INDI.FAMC": ["PEDI", "NOTE"],
     "INDI.FAMS": ["NOTE"],
@@ -42,8 +46,11 @@ const CHILDREN = {
     _WITN: ["RELA", "NOTE"],
     ADDR: ["CONT", "ADR1", "ADR2", "ADR3", "CITY", "STAE", "POST", "CTRY"],
 };
-const TEXT_TAGS = new Set(["NOTE", "TEXT", "TITL", "PAGE", "AUTH", "PUBL", "_STORY", "DATA", "COPR", "ADDR", "CAUS", "FILE", "_URL"]);
-const EXTENSIONS = new Set(["_STORY", "_WITN", "_FREL", "_MREL", "_STROM_KIND", "_URL", "_STROM_TREE", "_STROM_HEAD"]);
+const TEXT_TAGS = new Set(["NOTE", "TEXT", "TITL", "PAGE", "AUTH", "PUBL", "_STORY", "DATA", "COPR", "ADDR", "CAUS", "FILE", "_URL", "VAL", "DECI"]);
+const EXTENSIONS = new Set([
+    "_STORY", "_WITN", "_FREL", "_MREL", "_STROM_KIND", "_URL", "_STROM_TREE", "_STROM_HEAD", "_STROM_LINKS", "_STROM_CLIP",
+    "_STROM_ASOF", "_STROM_CONFLICT", "_STROM_HYPO", "_STROM_SEARCHED", "_AT",
+]);
 /** Context of the children of the last tag in `anc` (the ancestors of a line). */
 function contextOf(anc) {
     const record = anc[0];
@@ -74,6 +81,8 @@ function contextOf(anc) {
     }
     if (depth === 3 && parent === "ASSO")
         return "EVENT.ASSO";
+    if (depth === 3 && (parent === "VAL" || parent === "DECI") && anc[1] === "_STROM_CONFLICT")
+        return "_STROM_VALUE";
     if (depth === 3 && (parent === "HUSB" || parent === "WIFE") && record === "FAM")
         return `EVENT.${parent}`;
     return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {