strom-research 1.8.0 → 1.9.0

package/assets/method/core.md

@@ -37,6 +37,14 @@ conclusion so the next researcher can follow it.
 - **Lessons belong where they apply.** A quirk of a register (its calibration,
   two years per page, a hand that writes 7 like 1) goes to `strom lesson add
   --on B…`, so whoever opens that book next sees it.
+- **The tree first, then above it.** A family found in the records that no
+  family link joins to the tree is not researched further — not its parents,
+  not its children — until the link is proven, or the user asks for it. First
+  the hypothesis that would join it (`strom hypothesis add … --about` a person
+  of the tree), then a task that tests it and names it (`--about H…`). The
+  queue holds back every other task about people off the tree
+  (`strom task list --off-tree`); they come back by themselves once the link
+  is recorded.
 - **Stay within the task.** New questions become new tasks (`strom task add`,
   with where and done-when), not detours. A new task whose images are not here
   gets them now: through the archive's connector (built first when it has

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 { appOpensLinks } from "../core/stromapp.js";
+import { appOpensLinks, appShowsEdges } 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]));
@@ -73,7 +73,9 @@ export function writeTreeGed(tree, opts) {
     // an app that opens links shows what the research knows of a person too (the same version)
     const research = opts.for === "strom" && appOpensLinks(new Settings(tree.env, {}), opts.stromVersion);
     const clips = research && !!images;
-    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}), ...(clips ? { clips } : {}), ...(research ? { research } : {}) });
+    // …and where the tree ends, for an app that shows it
+    const edges = opts.for === "strom" && appShowsEdges(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 } : {}) });
     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

@@ -17,10 +17,12 @@ import { buildBrief } from "../brief/brief.js";
 import { DEFAULT_BUDGET, DEFAULT_RUN_MINUTES, Settings } from "../core/config.js";
 import { prependPath } from "../runners/runner.js";
 import { frontier } from "../core/frontier.js";
+import { treeEdges } from "../core/edge.js";
+import { label, parentsOf, resolvePerson } from "../core/people.js";
 import { storyProposals } from "../core/stories.js";
 import { OFF_MAP_HOW, offMapLine, placesOffMap } from "../core/places.js";
 import { create, csvOpt, requireRecord, update } from "../core/records.js";
-import { taskQueue, waitingLines } from "./tasks.js";
+import { offTreeLine, taskQueue, waitingLines } from "./tasks.js";
 import { resolveResearch } from "./research.js";
 import { writeGedcoms } from "./output.js";
 import { syncAgentFiles } from "../agents/files.js";
@@ -110,7 +112,9 @@ register({
         const s = startSession(tree, { ...(task ? { task } : {}), ...(research ? { research: research.id } : {}) });
         reviveLive(tree.root, ctx.env);
         const brief = buildBrief(tree, { ...(task ? { task } : {}), session: s, budget: ctx.settings.number("brief.budget", tree.config, DEFAULT_BUDGET), shared: ctx.settings.shared()?.value });
-        return { text: lines(written(tree), "", brief.text), data: { session: s, brief: brief.text, sections: brief.sections } };
+        // a task the queue holds back, started by its ID: the agent hears why before it begins
+        const off = task && args[0] ? offTreeLine(tree, task, true) : undefined;
+        return { text: lines(written(tree), off, "", brief.text), data: { session: s, brief: brief.text, sections: brief.sections, ...(off ? { offTree: true } : {}) } };
     },
 }, {
     path: ["session", "note"],
@@ -292,7 +296,132 @@ register({
             data: { frontier: items.map((i) => ({ person: i.person.id, generation: i.generation, reason: i.reason, coveredBy: i.coveredBy, proposal: i.proposal, exhausted: i.exhausted })), stories },
         };
     },
+}, {
+    path: ["edge"],
+    summary: "Where the tree ends: above whom it does not go on, why (what the records say so far) and what comes next — what the Strom app shows on those cards",
+    group: "tasks",
+    tree: true,
+    args: [{ name: "person", description: "whose edge in full: ID (P0001) or name (default: every edge the research reaches)", variadic: true }],
+    options: [{ name: "all", type: "boolean", description: "also the edges no direction reaches: family outside the directions, people off the tree" }],
+    examples: ["strom edge", "strom edge P0001", "strom edge --all --json"],
+    run(ctx, { args, opts }) {
+        const tree = ctx.tree();
+        const { edges, islands } = treeEdges(tree);
+        const who = (id) => {
+            const p = tree.get(id);
+            return p ? label(p) : id;
+        };
+        if (args.length) {
+            const people = args.map((a) => resolvePerson(tree, a));
+            const out = [];
+            for (const p of people) {
+                const e = edges.get(p.id);
+                const isle = islands.get(p.id);
+                if (out.length)
+                    out.push("");
+                if (!e)
+                    out.push(`${label(p)} — ${parentsOf(tree, p.id).length === 2 ? "the tree goes on above: a record proves the parents" : "nothing the research knows of the edge above yet (no direction reaches them, no work on it)"}`);
+                else
+                    out.push(...edgeLines(tree, e, who));
+                if (isle)
+                    out.push(islandLine(isle, who));
+            }
+            const data = people.map((p) => ({ person: p.id, edge: edges.get(p.id) ?? null, island: islands.get(p.id) ? { ...islands.get(p.id), people: islands.get(p.id).people.length } : null }));
+            return { text: lines(...out), data: { edges: data } };
+        }
+        const reached = new Set(["in", "limit", "paused", "done"]);
+        const shown = [...edges.values()].filter((e) => opts.all || reached.has(e.scope)).sort((a, b) => (a.generation ?? 99) - (b.generation ?? 99) || a.person.localeCompare(b.person));
+        const count = (k) => [...shown.reduce((m, e) => m.set(e[k], (m.get(e[k]) ?? 0) + 1), new Map())].map(([v, n]) => `${v} ${n}`).join(", ");
+        const hidden = edges.size - shown.length;
+        return {
+            text: shown.length
+                ? lines(table(shown.map((e) => [
+                    e.person,
+                    e.generation !== undefined ? `G${e.generation}` : "",
+                    e.missing,
+                    e.scope === "in" ? "" : e.scope,
+                    e.end,
+                    e.next,
+                    truncate(edgeNext(e), 70),
+                ])), "", `ends: ${count("end")}`, `next: ${count("next")}`, hidden ? `${hidden} more no direction reaches (strom edge --all)` : undefined, "one in full: strom edge P…")
+                : "no edge the research reaches — every person in its directions has parents a record proves",
+            data: { edges: shown, islands: [...new Set(islands.values())].map((i) => ({ ...i, people: i.people.length, first: i.people[0] })) },
+        };
+    },
 });
+/** What comes next at an edge, in a few words: the first task and where it stands, else what the user decides. */
+function edgeNext(e) {
+    const t = e.tasks[0];
+    const hyp = e.hypotheses.find((h) => h.joins.length);
+    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")
+        return `tried ${e.tried.join(" ")} — ask the user${join}`;
+    return join.replace(/^ · /, "");
+}
+const MISSING_WORDS = {
+    parents: "both parents unknown",
+    father: "the father unknown",
+    mother: "the mother unknown",
+    proof: "no record proves the parents recorded",
+};
+const SCOPE_WORDS = {
+    in: "reached by",
+    limit: "at the limit of",
+    paused: "in a paused direction,",
+    done: "in an ended direction,",
+    living: "most likely alive — not researched",
+    outside: "family of the tree no direction goes through",
+    "off-tree": "of a family nothing links to the tree yet",
+};
+const END_WORDS = {
+    unnamed: "the baptism names no father (born out of wedlock)",
+    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",
+    "not-found": "searched in vain everywhere strom knew to look",
+    offline: "the books left are only in the archive",
+    partly: "searched in part",
+    unsearched: "not searched yet",
+    "no-books": "no book of the birthplace known",
+    "no-place": "the birthplace unknown",
+    "no-clue": "nothing to go on: no year, no place of birth",
+};
+const NEXT_WORDS = {
+    working: "an agent works on it now",
+    waiting: "waits for the user",
+    queued: "in the queue",
+    held: "waits out of the queue",
+    proposed: "strom proposes it with the next session",
+    decide: "everything strom could propose was tried — the user decides",
+    none: "nothing planned",
+};
+/** One edge in full, for the agent. */
+function edgeLines(tree, e, who) {
+    const y = (r) => (r.from === r.to ? `${r.from}` : `${r.from}–${r.to}`);
+    const est = e.estimate;
+    const basis = est?.basis ? ` (estimated from ${est.basis.kind === "MARR" ? "the marriage" : "the eldest child"} ${est.basis.year})` : "";
+    return [
+        `${who(e.person)} — the tree ends above: ${MISSING_WORDS[e.missing]}`,
+        `  ${SCOPE_WORDS[e.scope]}${e.research ? ` ${e.research}, generation ${e.generation}` : ""}`,
+        `  the records: ${END_WORDS[e.end]}${e.recordsFrom ? ` (from ${e.recordsFrom})` : ""}`,
+        e.window ? `  baptism sought ${y(e.window)}${est?.place ? ` in ${est.place}` : ""}${basis}` : est?.place ? `  born in ${est.place}, year unknown` : undefined,
+        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]}`,
+        ...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.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);
+}
+function islandLine(i, who) {
+    const joins = i.hypotheses.map((h) => `${h.id} (to ${h.joins.map(who).join(", ")})`);
+    return `  of a family nothing links to the tree: ${i.people.length} people, ${i.held} tasks wait for it${joins.length ? `; would join it: ${joins.join(", ")}` : "; no hypothesis would join it yet"}`;
+}
 // ── agents ─────────────────────────────────────────────────────────────────
 register({
     path: ["agents", "sync"],

package/dist/commands/tasks.js

@@ -20,6 +20,8 @@ import { makeNote } from "../core/actions.js";
 import { phrase } from "../core/phrases.js";
 import { readJsonLines } from "../core/json.js";
 import { lacksImages, rankTasks } from "../core/queue.js";
+import { joiningHypotheses, offTree } from "../core/kin.js";
+import { aboutPeople } from "../core/directions.js";
 import { clipNote, inboxFolderFor, parseImageList, transcriptNote } from "../core/media.js";
 function written(tree) {
     return lines(...tree.written.map((o) => o.summary), tree.dryRun ? "(dry run — nothing written)" : undefined);
@@ -89,6 +91,22 @@ export function rankedQueue(tree, filter = {}) {
         .filter((t) => !filter.level || t.level === filter.level);
     return rankTasks(tree, tasks, filter.strategy, { storyTurn: filter.storyTurn });
 }
+/**
+ * What an agent is told of a task about people nothing links to the tree (core/kin.ts offTree): it waits out of the
+ * queue until the user asks for it or the hypothesis that would join them is decided; the task that tests that
+ * hypothesis names it. Undefined for a task of the tree.
+ */
+export function offTreeLine(tree, t, starting = false) {
+    if (!offTree(tree)(t))
+        return undefined;
+    const joins = joiningHypotheses(tree, aboutPeople(tree, t.subject));
+    const first = joins.length
+        ? `test first what would join them: ${joins.map((h) => `${h.id} "${truncate(h.question, 70)}"`).join("; ")} — a task that tests it names it (--about ${joins[0].id})`
+        : "first a link to a person of the tree: a hypothesis (strom hypothesis add … --about P… of the tree) and a task that tests it, naming it (--about H…)";
+    return starting
+        ? `⚠ ${t.id} is about people nothing links to the tree yet: go on only if the user asked for this work. Else close the session (strom session close --continue …) and ${first}`
+        : `· ${t.id} is about people nothing links to the tree yet: it waits out of the queue until the user asks for it or a hypothesis joins them — ${first}`;
+}
 function taskLine(t) {
     return [t.id, `p${t.priority}`, t.level, t.state === "open" ? "" : `[${t.state}]`, truncate(t.what, 70)];
 }
@@ -231,7 +249,7 @@ register({
         // it is known — not in a session spent finding out that there is nothing to read.
         const noImages = lacksImages(tree, t);
         return {
-            text: lines(written(tree), ...similar.map((x) => `⚠ similar ${x.state} task ${x.id} "${truncate(x.what, 60)}" — if it is the same, keep one: strom task drop ${t.id} --reason "duplicate of ${x.id}" and strom task edit ${x.id} --where … --note "…"`), noImages ? `· no images for it here yet — if the user has to download them, say which now: strom task wait ${t.id} --images B…:<numbers> --on "<the book, its link, which images>"` : undefined),
+            text: lines(written(tree), ...similar.map((x) => `⚠ similar ${x.state} task ${x.id} "${truncate(x.what, 60)}" — if it is the same, keep one: strom task drop ${t.id} --reason "duplicate of ${x.id}" and strom task edit ${x.id} --where … --note "…"`), offTreeLine(tree, t), noImages ? `· no images for it here yet — if the user has to download them, say which now: strom task wait ${t.id} --images B…:<numbers> --on "<the book, its link, which images>"` : undefined),
             data: { task: t, similar: similar.map((x) => x.id), needsImages: noImages },
         };
     },
@@ -250,8 +268,13 @@ register({
         const strategy = ctx.settings.strategy(tree.config);
         const queue = rankedQueue(tree, { ...(research ? { research } : {}), ...(opts.level ? { level: String(opts.level) } : {}), strategy });
         const first = queue[0];
-        if (!first)
-            return { text: 'no open tasks → strom research show <G…> to see what is missing, then strom task add', data: { task: null } };
+        if (!first) {
+            const held = tree.list("task").filter(offTree(tree)).filter((t) => t.state === "open").length;
+            const text = held
+                ? `no open task of the tree — ${held} wait about people nothing links to it yet (strom task list --off-tree): test the hypothesis that would join them, or ask the user`
+                : "no open tasks → strom research show <G…> to see what is missing, then strom task add";
+            return { text, data: { task: null, offTree: held } };
+        }
         const t = first.task;
         return {
             text: lines(taskDetail(tree, t), "", `first because: ${first.why} (queue: ${strategy})`, `start it: strom task start ${t.id}`),
@@ -271,6 +294,7 @@ register({
         { name: "research", type: "string", value: "<G…>", description: "only this research" },
         { name: "level", type: "string", value: "<level>", description: "only this level" },
         { name: "about", type: "string", value: "<who>", description: "only tasks about this person/record (also X…, H…)" },
+        { name: "off-tree", type: "boolean", description: "the open tasks that wait out of the queue: about people nothing links to the tree yet" },
         { name: "full", type: "boolean", description: "--json: whole records instead of one row each" },
     ],
     run(ctx, { opts }) {
@@ -278,7 +302,10 @@ register({
         const research = typeof opts.research === "string" ? resolveResearch(tree, opts.research).id : undefined;
         let all;
         const why = new Map();
-        if (!opts.state) {
+        const off = offTree(tree);
+        if (opts["off-tree"])
+            all = tree.list("task").filter((t) => t.state === "open" && off(t) && (!opts.level || t.level === opts.level));
+        else if (!opts.state) {
             const ranked = rankedQueue(tree, { ...(research ? { research } : {}), ...(opts.level ? { level: String(opts.level) } : {}), strategy: ctx.settings.strategy(tree.config) });
             for (const r of ranked)
                 why.set(r.task.id, r.why);
@@ -297,8 +324,10 @@ register({
             all = all.filter((t) => t.subject.includes(id));
         }
         const page = paginate(all, ctx.limit, ctx.page);
+        // the queue says what waits out of it for a link to the tree
+        const held = !opts.state && !opts["off-tree"] && !opts.about ? tree.list("task").filter((t) => t.state === "open" && off(t)).length : 0;
         return {
-            text: all.length ? lines(table(page.items.map(taskLine)), moreLine(page, "strom task list")) : "no tasks",
+            text: lines(all.length ? lines(table(page.items.map(taskLine)), moreLine(page, "strom task list")) : "no tasks", held ? `${held} more wait out of the queue: about people nothing links to the tree yet (strom task list --off-tree)` : undefined),
             data: { total: page.total, tasks: opts.full ? page.items : page.items.map((t) => ({ id: t.id, priority: t.priority, level: t.level, state: t.state, what: t.what, subject: t.subject, ...(why.has(t.id) ? { why: why.get(t.id) } : {}) })) },
         };
     },
@@ -360,7 +389,7 @@ register({
             summary: `${id} ${fields.map((f) => (f === "doneWhen" ? "done-when" : f === "subject" ? "about" : f)).join(", ")}${change.where ? ` → ${truncate(change.where.join("; "), 50)}` : ""}`,
             reason: opts.reason,
         });
-        return { text: written(tree), data: { task: t } };
+        return { text: lines(written(tree), change.subject ? offTreeLine(tree, t) : undefined), data: { task: t } };
     },
 }, {
     path: ["task", "start"],

package/dist/core/edge.js

@@ -0,0 +1,296 @@
+// The edge of the tree: the people above whom it does not go on — no parents, one of them, or parents no record
+// proves — and what the research knows there. Why it ends (what the records say so far: the known books of the
+// birth, the years searched in vain, the records that begin later or are lost), what comes next (the work on it and
+// where it stands in the queue, or that the user decides), and the hypotheses that would join a family nothing
+// links to the tree yet. Read only, computed from the research: what the Strom app shows on the card where the
+// tree ends (_STROM_EDGE, _STROM_ISLAND) and what `strom edge` says.
+import { now } from "./tree.js";
+import { Settings } from "./config.js";
+import { aboutPeople, directionOf, 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";
+import { livingBorn } from "./review.js";
+import { effectiveState, rankTasks } from "./queue.js";
+import { subjectPeople } from "./records.js";
+import { foldText } from "./text.js";
+/** What is missing above the person: both parents, one of them, or a record that proves the parents recorded. */
+export const EDGE_MISSING = ["parents", "father", "mother", "proof"];
+/**
+ * Whether the research reaches them: a direction of it does (in), would but stops at its limit (limit), is paused
+ * or ended (paused, done); none does — they are most likely alive (living), family of the tree no direction goes
+ * through (outside), or a family nothing links to the tree yet (off-tree).
+ */
+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
+ * 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"];
+/**
+ * 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
+ * could propose was tried (the user decides), nothing.
+ */
+export const EDGE_NEXT = ["working", "waiting", "queued", "held", "proposed", "decide", "none"];
+const BIRTH_KINDS = RECORD_KINDS.BIRT;
+const LIVE = new Set(["open", "doing", "waiting", "parked"]);
+const FINISHED = new Set(["done", "dropped"]);
+const EDGE_FACTS = new Set(["BIRT", "CHR", "BAPM", "FAMC"]);
+function yearsOf(text) {
+    const m = /^\s*(\d{3,4})(?:\s*[-–]\s*(\d{3,4}))?\s*$/.exec(text ?? "");
+    if (!m)
+        return undefined;
+    const a = Number(m[1]);
+    const b = m[2] ? Number(m[2]) : a;
+    return { from: Math.min(a, b), to: Math.max(a, b) };
+}
+/** Single years as ranges ([1780, 1781, 1782, 1790] → 1780–1782, 1790). */
+function ranges(years) {
+    const out = [];
+    for (const y of [...years].sort((a, b) => a - b)) {
+        const last = out[out.length - 1];
+        if (last && y === last.to + 1)
+            last.to = y;
+        else
+            out.push({ from: y, to: y });
+    }
+    return out;
+}
+const within = (y, r) => !r || (y >= r.from && y <= r.to);
+/** The families nothing links to the tree, person by person (none when the tree has nobody it is for). */
+function islands(tree, kin, tasks, hypotheses) {
+    const out = new Map();
+    if (!kin.size)
+        return out;
+    const off = offTree(tree);
+    for (const p of tree.list("person")) {
+        if (p.retracted || kin.has(p.id) || out.has(p.id))
+            continue;
+        const people = new Set();
+        const queue = [p.id];
+        while (queue.length) {
+            const id = queue.shift();
+            if (people.has(id) || kin.has(id))
+                continue;
+            people.add(id);
+            queue.push(...familiesAsPartner(tree, id).flatMap((f) => [...f.partners, ...f.children.map((c) => c.person)]), ...familiesAsChild(tree, id).flatMap((f) => f.partners));
+        }
+        const island = {
+            people: [...people],
+            hypotheses: hypotheses
+                .map((h) => ({ h, about: aboutPeople(tree, h.subject) }))
+                .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)) })),
+            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)
+            out.set(id, island);
+    }
+    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) {
+    const lang = tree.lang;
+    const today = now().slice(0, 10);
+    const kin = kinship(tree);
+    const all = scopes(tree).filter((s) => !s.research.retracted);
+    const tasks = tree.list("task").filter((t) => !t.retracted);
+    const hypotheses = tree.list("hypothesis").filter((h) => !h.retracted && h.state === "open");
+    const conflicts = tree.list("conflict").filter((c) => !c.retracted && c.state === "open");
+    const searches = tree.list("search").filter((q) => !q.retracted);
+    const sessions = tree.list("session");
+    const researches = new Map(tree.list("research").map((r) => [r.id, r]));
+    const ranked = rankTasks(tree, tasks, new Settings(tree.env, {}).strategy(tree.config)).map((r) => r.task.id);
+    const position = new Map(ranked.map((id, i) => [id, i + 1]));
+    const off = offTree(tree);
+    const isles = islands(tree, kin, tasks, hypotheses);
+    const frontiers = new Map();
+    const frontierOf = (r) => {
+        if (!frontiers.has(r.id))
+            frontiers.set(r.id, new Map(frontier(tree, r).map((i) => [i.person.id, i])));
+        return frontiers.get(r.id);
+    };
+    const hypAbout = hypotheses.map((h) => ({ h, about: aboutPeople(tree, h.subject) }));
+    const edges = new Map();
+    for (const p of tree.list("person")) {
+        if (p.retracted)
+            continue;
+        const parents = parentsOf(tree, p.id);
+        const proven = birthRecordProven(p);
+        let missing;
+        if (parents.length === 0)
+            missing = "parents";
+        else if (parents.length === 1)
+            missing = parents[0].sex === "F" ? "father" : parents[0].sex === "M" ? "mother" : "parents";
+        else if (!proven)
+            missing = "proof";
+        else
+            continue;
+        // ── whether the research reaches them ──
+        const est = birthEstimate(tree, p, lang);
+        const window = birthWindow(est);
+        const reach = all.filter((s) => (s.people.get(p.id) ?? 0) >= 1).sort((a, b) => a.people.size - b.people.size || a.research.id.localeCompare(b.research.id));
+        const limited = (s) => {
+            const l = s.research.limits;
+            return !!((l?.generations && s.people.get(p.id) >= l.generations) || (l?.before && est.year && est.year < l.before));
+        };
+        const active = reach.filter((s) => s.research.state === "active");
+        const through = active.find((s) => !limited(s)) ?? active[0] ?? reach.find((s) => s.research.state === "paused") ?? reach[0];
+        const scope = active.some((s) => !limited(s))
+            ? "in"
+            : active.length
+                ? "limit"
+                : through
+                    ? through.research.state
+                    : livingBorn(tree, p) !== undefined
+                        ? "living"
+                        : kin.size && !kin.has(p.id)
+                            ? "off-tree"
+                            : "outside";
+        // ── the books of the birth, and the work on the parents ──
+        const placeBooks = est.place ? recordsetsCovering(tree, est.place, undefined, BIRTH_KINDS).filter((b) => !b.retracted) : [];
+        const books = placeBooks.filter((b) => !window || !b.years || (() => {
+            const y = yearsOf(b.years);
+            return !y || (y.from <= window.to && y.to >= window.from);
+        })());
+        const bookIds = new Set(books.map((b) => b.id));
+        const hyps = hypAbout.filter(({ about }) => about.includes(p.id)).map(({ h, about }) => ({ h, about }));
+        const hypIds = new Set(hyps.map(({ h }) => h.id));
+        const onParents = (t) => (t.subject.includes(p.id) && (FRONTIER_LEVELS.has(t.level) || ((t.level === "verify" || t.level === "enrich") && t.where.some((w) => bookIds.has(w))))) ||
+            t.subject.some((s) => hypIds.has(s));
+        const mine = tasks.filter(onParents);
+        const mineIds = new Set(mine.map((t) => t.id));
+        const surname = foldText(primaryName(p).surname);
+        const sought = searches.filter((q) => (q.task ? mineIds.has(q.task) : !!surname && (q.scope.surnames ?? []).some((s) => foldText(s) === surname) && q.recordsets.some((b) => bookIds.has(b))));
+        const edgeTasks = mine
+            .filter((t) => LIVE.has(effectiveState(t, today)))
+            .map((t) => {
+            const state = effectiveState(t, today);
+            const at = position.get(t.id);
+            const dir = directionOf(tree, t, all);
+            const dirState = dir ? researches.get(dir)?.state : undefined;
+            const held = state === "parked" ? "parked" : state !== "open" || at ? undefined : dirState === "paused" || dirState === "done" ? dirState : off(t) ? "off-tree" : undefined;
+            const on = state === "waiting" ? t.waitingOn : state === "parked" ? t.parkedReason : undefined;
+            return {
+                id: t.id,
+                level: t.level,
+                state,
+                what: t.what,
+                ...(at && state === "open" ? { position: at } : {}),
+                ...(held ? { held } : {}),
+                ...(state === "parked" && t.parkedUntil ? { until: t.parkedUntil } : {}),
+                ...(on ? { on } : {}),
+            };
+        })
+            .sort((a, b) => (a.position ?? 1e9) - (b.position ?? 1e9) || a.id.localeCompare(b.id));
+        const tried = mine.filter((t) => FINISHED.has(t.state)).map((t) => t.id);
+        const item = through && through.research.state === "active" ? frontierOf(through.research).get(p.id) : undefined;
+        const next = edgeTasks.some((t) => t.state === "doing")
+            ? "working"
+            : edgeTasks.some((t) => t.state === "waiting")
+                ? "waiting"
+                : edgeTasks.some((t) => t.position)
+                    ? "queued"
+                    : edgeTasks.length
+                        ? "held"
+                        : scope === "in" && item?.proposal
+                            ? "proposed"
+                            : tried.length || item?.exhausted
+                                ? "decide"
+                                : "none";
+        // ── what the records say so far: each year of the window searched in vain, without records, or open ──
+        const covered = [];
+        const noRecords = [];
+        const lostYears = [];
+        const open = [];
+        if (window && placeBooks.length)
+            for (let y = window.from; y <= window.to; y++) {
+                const of = books.filter((b) => within(y, yearsOf(b.years)));
+                const kept = of.filter((b) => b.access !== "lost");
+                if (!of.length)
+                    noRecords.push(y);
+                else if (!kept.length)
+                    lostYears.push(y);
+                else if (kept.every((b) => sought.some((q) => q.result === "negative" && q.recordsets.includes(b.id) && within(y, yearsOf(q.scope.years) ?? (q.scope.pages ? { from: 0, to: -1 } : yearsOf(b.years))))))
+                    covered.push(y);
+                else
+                    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));
+        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 (!est.place)
+            end = est.year ? "no-place" : "no-clue";
+        else if (!placeBooks.length)
+            end = "no-books";
+        else if (window && !open.length)
+            end = lostYears.length
+                ? "lost"
+                : noRecords.length === window.to - window.from + 1 && earliest > window.to
+                    ? "before-records"
+                    : noRecords.length
+                        ? noRecords.every((y) => y < earliest)
+                            ? "before-records"
+                            : "gap"
+                        : "not-found";
+        else if (item?.exhausted)
+            end = "not-found";
+        else if (window && open.every((o) => !o.online))
+            end = "offline";
+        else
+            end = sought.length || tried.length ? "partly" : "unsearched";
+        // ── the hypotheses, conflicts, and what the work cost ──
+        // a hypothesis that names people on and off the tree would join them: the people on the other side of it
+        const onTree = kin.has(p.id);
+        const edgeHyps = hyps.map(({ h, about }) => {
+            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;
+            return {
+                id: h.id,
+                question: h.question,
+                joins,
+                ...(isle ? { island: { people: isle.people.length, held: isle.held } } : {}),
+                tests: tasks.filter((t) => LIVE.has(t.state) && t.subject.includes(h.id)).map((t) => t.id),
+            };
+        });
+        const edgeConflicts = conflicts
+            .filter((c) => subjectPeople(tree, c.subject).includes(p.id) && (!c.fact || EDGE_FACTS.has(c.fact)))
+            .map((c) => c.id);
+        const spent = sessions.filter((s) => s.task && mineIds.has(s.task));
+        const cost = spent.reduce((n, s) => n + (s.metrics?.costUsd ?? 0), 0);
+        const partial = spent.some((s) => s.state !== "open" && (s.metrics?.costPartial || s.metrics?.costUsd === undefined));
+        const last = [...spent.map((s) => s.ended ?? s.started), ...sought.map((q) => q.created)].sort().pop()?.slice(0, 10);
+        const known = scope === "in" || scope === "limit" || scope === "paused" || scope === "done" || edgeTasks.length || tried.length || edgeHyps.length || sought.length || edgeConflicts.length;
+        if (!known)
+            continue;
+        edges.set(p.id, {
+            person: p.id,
+            missing,
+            scope,
+            ...(through ? { research: through.research.id, generation: through.people.get(p.id) } : {}),
+            end,
+            next,
+            ...(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 } : {}),
+            books: books.map((b) => ({ id: b.id, title: b.title, ...(b.years ? { years: b.years } : {}), access: b.access })),
+            covered: ranges(covered),
+            noRecords: ranges(noRecords),
+            tasks: edgeTasks,
+            tried,
+            hypotheses: edgeHyps,
+            conflicts: edgeConflicts,
+            searches: sought.length,
+            sessions: spent.length,
+            ...(spent.length ? { cost: Math.round(cost * 100) / 100, ...(partial ? { costPartial: true } : {}) } : {}),
+            ...(last ? { last } : {}),
+        });
+    }
+    return { edges, islands: isles };
+}

package/dist/core/frontier.js

@@ -7,8 +7,8 @@ import { foldText } from "./text.js";
 import { phrase } from "./phrases.js";
 const OPEN_STATES = new Set(["open", "doing", "parked", "waiting"]);
 const FINISHED_STATES = new Set(["done", "dropped"]);
-const FRONTIER_LEVELS = new Set(["locate", "link", "request"]);
-function birthRecordProven(p) {
+export const FRONTIER_LEVELS = new Set(["locate", "link", "request"]);
+export function birthRecordProven(p) {
     return p.events.some((e) => ["BIRT", "CHR", "BAPM"].includes(e.kind) && (e.status === "proven" || e.status === "probable") && !e.retracted);
 }
 /** The kinds of record set in which an event of this kind is written down. */
@@ -120,7 +120,15 @@ export function birthEstimate(tree, p, lang) {
     const year = ownYear ?? (marrYear ? marrYear - 25 : eldest ? eldest.year - 28 : undefined);
     const place = own?.place ?? marr?.place ?? eldest?.b?.place;
     const from = ownYear ? undefined : marrYear ? phrase(lang, "estimate.marriage", { year: marrYear }) : eldest ? phrase(lang, "estimate.child", { year: eldest.year }) : undefined;
-    return { ...(year ? { year } : {}), ...(place ? { place } : {}), ...(from ? { from } : {}) };
+    const basis = ownYear || !year ? undefined : marrYear ? { kind: "MARR", year: marrYear } : { kind: "child", year: eldest.year };
+    return { ...(year ? { year } : {}), ...(place ? { place } : {}), ...(from ? { from } : {}), ...(basis ? { basis } : {}) };
+}
+/** The years a search for a birth has to cover: a few around a known year, wider around an estimate. */
+export function birthWindow(est) {
+    if (!est.year)
+        return undefined;
+    const span = est.from ? 10 : 3;
+    return { from: est.year - span, to: est.year + span };
 }
 /**
  * The people a research is about, each with their generation from its focus:
@@ -202,7 +210,7 @@ export function frontier(tree, research) {
             const tried = new Set(finished.filter((t) => t.level === "link").flatMap((t) => t.where));
             const place = est.place;
             // an estimate needs a wider search than a known year
-            const span = est.from ? 10 : 3;
+            const span = est.from ? 10 : 3; // as birthWindow
             const about = est.from && year ? phrase(lang, "born.about", { year, from: est.from }) : "";
             const reason = phrase(lang, hasBirthFamily ? "reason.unproven" : "reason.unknown");
             const sets = candidateRecordsets(tree, place, year).filter((b) => !tried.has(b.id));

package/dist/core/kin.js

@@ -2,6 +2,7 @@
 // app opens on them), and how near anyone is to the people the research is
 // for (which entries get their image in the Strom app first).
 import { Settings } from "./config.js";
+import { aboutPeople } from "./directions.js";
 import { ancestorGenerations, familiesAsChild, familiesAsPartner } from "./people.js";
 function researches(tree) {
     return tree
@@ -57,7 +58,7 @@ export function mainPerson(tree) {
  * their ancestors 0, the partners, children and children's partners of those 1, anyone linked by family further 2.
  */
 export function kinship(tree) {
-    const roots = [...new Set([...researches(tree).map((r) => r.focus), mainPerson(tree)].filter((x) => !!x))];
+    const roots = [...new Set([...researches(tree).flatMap((r) => [r.focus, ...(r.review?.people ?? [])]), mainPerson(tree)].filter((x) => !!x))];
     const out = new Map();
     for (const r of roots)
         for (const id of ancestorGenerations(tree, r).keys())
@@ -88,3 +89,41 @@ export function kinship(tree) {
     }
     return out;
 }
+/**
+ * Work about people nothing links to the tree yet: none of the people a task is about (with those of the conflicts
+ * and hypotheses it names) is kin of the people the research is for. It waits out of the queue until the user asks
+ * for it (a direction or a review of one of them makes them the research's) or a hypothesis that joins them to the
+ * tree is decided and recorded. A task that tests that hypothesis names it (--about H…) or the person of the tree
+ * it would join, and so is in the queue. The user's material (intake) and work at hand never wait; a tree with
+ * nobody to be for holds nothing.
+ */
+export function offTree(tree) {
+    const kin = kinship(tree);
+    if (!kin.size)
+        return () => false;
+    return (t) => {
+        if (t.level === "intake" || t.state === "doing")
+            return false;
+        const about = aboutPeople(tree, t.subject);
+        return about.length > 0 && !about.some((p) => kin.has(p));
+    };
+}
+/**
+ * The open hypotheses that would join people off the tree to it: each names someone of the tree and someone of
+ * their family (the people family links join to them) — the work to do before any work on them.
+ */
+export function joiningHypotheses(tree, people) {
+    const kin = kinship(tree);
+    const family = new Set();
+    const queue = people.filter((p) => !kin.has(p));
+    while (queue.length) {
+        const p = queue.shift();
+        if (family.has(p))
+            continue;
+        family.add(p);
+        queue.push(...familiesAsPartner(tree, p).flatMap((f) => [...f.partners, ...f.children.map((c) => c.person)]), ...familiesAsChild(tree, p).flatMap((f) => f.partners));
+    }
+    return tree
+        .list("hypothesis")
+        .filter((h) => h.state === "open" && h.subject.some((s) => family.has(s)) && h.subject.some((s) => kin.has(s)));
+}

package/dist/core/live.js

@@ -49,7 +49,7 @@ import { rankTasks } from "./queue.js";
 import { humanTask } from "../cli/human.js";
 import { knownNewerVersion } from "./update.js";
 import { gitProgram, runGit } from "./git.js";
-import { appOpensLinks, isStromAppOrigin } from "./stromapp.js";
+import { appOpensLinks, appShowsEdges, isStromAppOrigin } from "./stromapp.js";
 import { Settings } from "./config.js";
 import { linkActions, linkHandlerState } from "./links.js";
 import { stromLauncher } from "./self.js";
@@ -308,6 +308,37 @@ function whoAtWork(label, lang) {
     const chat = /^(.+) conversation$/.exec(label);
     return chat ? phrase(lang, "who.chat", { agent: chat[1] }) : label;
 }
+/**
+ * The person an agent works on, for the app to follow it in the tree: the first person its task is about (a marriage
+ * names both, the one it asks about first), else the last one its session wrote about.
+ */
+function workedOn(root, tree, s, task) {
+    const known = (id) => /^P\d{1,7}$/.test(id) && tree.get(id) !== undefined;
+    const first = (task?.subject ?? []).find(known);
+    if (first)
+        return { person: first };
+    const file = path.join(root, "data", "ops", `${s.id}.jsonl`);
+    let lines = [];
+    try {
+        lines = fs.readFileSync(file, "utf8").split("\n");
+    }
+    catch {
+        return {};
+    }
+    for (let i = lines.length - 1; i >= 0; i--) {
+        let op;
+        try {
+            op = JSON.parse(lines[i]);
+        }
+        catch {
+            continue; // empty, or a line being written
+        }
+        const person = (op.targets ?? []).findLast(known);
+        if (person)
+            return { person };
+    }
+    return {};
+}
 /** Who is at work now, on which task (an agent strom started, and its open session). */
 function working(root, tree, all) {
     const open = openSessions(tree);
@@ -319,7 +350,7 @@ function working(root, tree, all) {
             who: whoAtWork(w.label, tree.lang),
             since: w.since,
             ...(w.paused ? { paused: w.paused } : {}),
-            ...(s ? { session: s.id, ...(s.task ? { task: task ? `${task.id} ${task.what}` : s.task, ...personOf(task) } : {}) } : {}),
+            ...(s ? { session: s.id, ...(s.task ? { task: task ? `${task.id} ${task.what}` : s.task } : {}), ...workedOn(root, tree, s, task) } : {}),
             ...(research ? { research } : {}),
         };
     });
@@ -533,11 +564,13 @@ export function serveLive(root, env) {
                     const images = set ? planExcerpts(tree, set.shared, { quality: set.quality, for: set.for, maxBytes: set.mb * 1024 * 1024, budgetMs: LIVE_IMAGES_MS }) : undefined;
                     // an app that opens strom-research:// links: each excerpt's mark, and the links this computer takes
                     const opens = appOpensLinks(new Settings(env, {}));
+                    // …and where the tree ends, for an app that shows it
+                    const edges = appShowsEdges(new Settings(env, {}));
                     const offered = opens ? links(env) : [];
                     ged = {
                         head: h,
                         links: offered.join(" "),
-                        text: exportGedcom(tree, { for: "strom", ...(h ? { head: h } : {}), ...(images ? { excerpts: images.of } : {}), ...(opens ? { clips: true, research: true } : {}), ...(offered.length ? { links: offered } : {}) }).text,
+                        text: exportGedcom(tree, { for: "strom", ...(h ? { head: h } : {}), ...(images ? { excerpts: images.of } : {}), ...(opens ? { clips: true, research: true } : {}), ...(edges ? { edges } : {}), ...(offered.length ? { links: offered } : {}) }).text,
                     };
                 }
                 res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store", "X-Strom-Head": h }).end(ged.text);

package/dist/core/queue.js

@@ -6,13 +6,16 @@
 // after work that waits for a download: they are never what a session is
 // spent on instead of the research. Working alone (strom run) they still get
 // their turn: after STORY_EVERY sessions without one, a story first. In a
-// conversation the user leads, and a story is written when they want it. Strategies (setting queue.strategy): balanced (the default), depth
+// conversation the user leads, and a story is written when they want it. Work
+// about people nothing links to the tree waits until the user asks for it or a
+// hypothesis joins them (core/kin.ts offTree). Strategies (setting queue.strategy): balanced (the default), depth
 // (stay on the line of the last sessions), priority (strict priority).
 import { parentsOf } from "./people.js";
 import { taskRecordsets } from "./frontier.js";
 import { now } from "./tree.js";
 import { subjectPeople } from "./records.js";
 import { directionOf, scopes } from "./directions.js";
+import { offTree } from "./kin.js";
 export const LEVEL_ORDER = { intake: 0, locate: 1, link: 2, verify: 3, enrich: 4, request: 5, narrate: 6 };
 /** Levels that read records: without images of their record sets they can only ask the user for them. */
 const NEEDS_IMAGES = new Set(["link", "verify"]);
@@ -57,8 +60,10 @@ export function rankTasks(tree, tasks, strategy = "balanced", opts = {}) {
     const researches = tree.list("research");
     // a direction the user paused or ended: its tasks wait (one at work goes on)
     const stopped = new Set(researches.filter((r) => r.state !== "active").map((r) => r.id));
-    const all = stopped.size ? scopes(tree) : [];
-    const waits = (t) => t.state !== "doing" && stopped.size > 0 && stopped.has(directionOf(tree, t, all) ?? "");
+    const all = scopes(tree);
+    // work about people nothing links to the tree waits for the user or for the hypothesis that joins them (core/kin.ts)
+    const off = offTree(tree);
+    const waits = (t) => t.state !== "doing" && ((stopped.size > 0 && stopped.has(directionOf(tree, t, all) ?? "")) || off(t));
     const open = tasks.filter((t) => ["open", "doing"].includes(effectiveState(t, today)) && !waits(t));
     const withImages = new Set(tree.list("media").map((m) => m.recordset));
     const lines = new Map();
@@ -72,7 +77,8 @@ export function rankTasks(tree, tasks, strategy = "balanced", opts = {}) {
     };
     /** The nearest ancestor a task is about: its generation and line. */
     const place = (t) => {
-        const map = linesOf(t.research);
+        // a task of no research of its own: the direction its people are in (directions.ts), as the menu and the app say
+        const map = linesOf(t.research ?? directionOf(tree, t, all));
         const found = [...t.subject, ...subjectPeople(tree, t.subject)].map((s) => map?.get(s)).filter((x) => !!x);
         return found.sort((a, b) => a.gen - b.gen)[0];
     };

package/dist/core/stromapp.js

@@ -60,6 +60,28 @@ export function appOpensLinks(settings, version) {
             return (a[i] ?? 0) > (b[i] ?? 0);
     return true;
 }
+/**
+ * The Strom app shows where the tree ends (the app's spec docs/ZADANI_VYZKUM_kraj-stromu.md): per person above whom
+ * the tree does not go on, what the research knows there (_STROM_EDGE), and the families nothing links to the tree
+ * (_STROM_ISLAND). The first version of stromapp.info that does (3.6.0, 2026-09-30); 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;
+ * an unknown one is taken as today's (an older app only skips the tags).
+ */
+export const APP_SHOWS_EDGES = "3.6.0";
+export function appShowsEdges(settings, version) {
+    if (stromAppUrl(settings) !== STROM_APP_URL)
+        return true;
+    if (!APP_SHOWS_EDGES)
+        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_SHOWS_EDGES)];
+    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)}`;

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

package/dist/gedcom/export.js

@@ -35,6 +35,8 @@ import { VERSION } from "../core/tree.js";
 import { dataUrl } from "../core/excerpt.js";
 import { mainPerson } from "../core/kin.js";
 import * as git from "../core/git.js";
+import { treeEdges } from "../core/edge.js";
+import { humanTask } from "../cli/human.js";
 export const GED_PROFILES = ["standard", "strom"];
 /** The first Strom version that reads AGE, CAUS, ADDR, _FREL/_MREL and more source notes itself (not released yet). */
 export const STROM_READS_TAGS = undefined;
@@ -135,6 +137,8 @@ export function exportGedcom(tree, opts = {}) {
                 .filter((x) => x.people.length)
             : [],
     };
+    // Where the tree ends, and the families nothing links to it (the Strom profile, opts.edges).
+    const ends = opts.edges && opts.for === "strom" ? treeEdges(tree) : undefined;
     // ── header ──
     w.line(0, "HEAD");
     w.line(1, "SOUR", "STROM_RESEARCH");
@@ -203,6 +207,14 @@ export function exportGedcom(tree, opts = {}) {
         story(p.story);
         if (opts.research && opts.for === "strom")
             known(p);
+        if (ends) {
+            const e = ends.edges.get(p.id);
+            if (e)
+                edge(e);
+            const isle = ends.islands.get(p.id);
+            if (isle)
+                island(isle);
+        }
         for (const link of famc.get(p.id) ?? []) {
             w.line(1, "FAMC", x(link.fam));
             if (link.relation === "adopted" || link.relation === "foster")
@@ -457,7 +469,7 @@ export function exportGedcom(tree, opts = {}) {
                 w.text(2, "DECI", c.resolution);
         }
         for (const h of research.hypotheses.filter((x) => about(x.subject))) {
-            w.line(1, "_STROM_HYPO");
+            w.line(1, "_STROM_HYPO", h.id);
             w.text(2, "TITL", h.question);
             w.text(2, "NOTE", h.variants.map((v) => `${v.label}: ${v.claim}`).join("\n"));
         }
@@ -471,6 +483,98 @@ export function exportGedcom(tree, opts = {}) {
             w.line(2, "_AT", q.created.slice(0, 10));
         }
     }
+    /** Years as a GEDCOM date: one year, or FROM … TO …. */
+    function years(r) {
+        return r.from === r.to ? String(r.from) : `FROM ${r.from} TO ${r.to}`;
+    }
+    /**
+     * Where the tree ends above a person: what is missing, whether the research reaches them, what the records say
+     * so far, what comes next — and what that rests on (core/edge.ts; the app's ZADANI_VYZKUM_kraj-stromu.md).
+     */
+    function edge(e) {
+        w.line(1, "_STROM_EDGE", e.missing);
+        w.line(2, "_SCOPE", e.scope);
+        if (e.research)
+            w.line(2, "_RESEARCH", e.research);
+        if (e.generation !== undefined)
+            w.line(2, "_GEN", String(e.generation));
+        w.line(2, "_END", e.end);
+        w.line(2, "_NEXT", e.next);
+        if (e.estimate) {
+            w.line(2, "_EST", e.estimate.year ? String(e.estimate.year) : "");
+            if (e.estimate.place)
+                w.text(3, "PLAC", e.estimate.place);
+            if (e.estimate.basis)
+                w.line(3, "_BASIS", `${e.estimate.basis.kind} ${e.estimate.basis.year}`);
+        }
+        if (e.window)
+            w.line(2, "DATE", years(e.window));
+        if (e.recordsFrom)
+            w.line(2, "_RECORDS", String(e.recordsFrom));
+        for (const b of e.books) {
+            w.line(2, "_BOOK", b.id);
+            w.text(3, "TITL", b.title);
+            const y = /^(\d{3,4})(?:\s*[-–]\s*(\d{3,4}))?$/.exec(b.years ?? "");
+            if (y)
+                w.line(3, "DATE", years({ from: Number(y[1]), to: Number(y[2] ?? y[1]) }));
+            w.line(3, "_ACCESS", b.access);
+        }
+        for (const r of e.covered)
+            w.line(2, "_COVERED", years(r));
+        for (const r of e.noRecords)
+            w.line(2, "_NORECORDS", years(r));
+        for (const t of e.tasks) {
+            w.line(2, "_TASK", t.id);
+            w.line(3, "_LEVEL", t.level);
+            w.line(3, "STAT", t.state);
+            w.text(3, "TITL", humanTask(tree, t.what, lang));
+            if (t.position)
+                w.line(3, "_POS", String(t.position));
+            if (t.held)
+                w.line(3, "_HELD", t.held);
+            if (t.until)
+                w.line(3, "_UNTIL", t.until);
+            if (t.on)
+                w.text(3, "NOTE", t.on);
+        }
+        for (const id of e.tried)
+            w.line(2, "_TRIED", id);
+        for (const h of e.hypotheses) {
+            w.line(2, "_HYPO", h.id);
+            for (const j of h.joins)
+                w.line(3, "_JOIN", j);
+            if (h.island) {
+                w.line(3, "_ISLAND", String(h.island.people));
+                w.line(3, "_HELD", String(h.island.held));
+            }
+            for (const t of h.tests)
+                w.line(3, "_TEST", t);
+        }
+        for (const c of e.conflicts)
+            w.line(2, "_CONFLICT", c);
+        if (e.searches)
+            w.line(2, "_SEARCHES", String(e.searches));
+        if (e.sessions) {
+            w.line(2, "_SESSIONS", String(e.sessions));
+            if (e.cost !== undefined)
+                w.line(3, "_COST", e.cost.toFixed(2));
+            if (e.costPartial)
+                w.line(3, "_PARTIAL", "Y");
+        }
+        if (e.last)
+            w.line(2, "_LAST", e.last);
+    }
+    /** A person of a family nothing links to the tree: how many people it has, the hypotheses that would join it, the tasks waiting for it. */
+    function island(i) {
+        w.line(1, "_STROM_ISLAND", String(i.people.length));
+        for (const h of i.hypotheses) {
+            w.line(2, "_HYPO", h.id);
+            for (const j of h.joins)
+                w.line(3, "_JOIN", j);
+        }
+        if (i.held)
+            w.line(2, "_HELD", String(i.held));
+    }
     function story(st) {
         if (!st)
             return;

package/dist/gedcom/validate.js

@@ -18,10 +18,12 @@ const CHILDREN = {
     "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", "_STROM_CONFLICT", "_STROM_HYPO", "_STROM_SEARCHED", ...INDI_EVENTS],
+    INDI: ["NAME", "SEX", "FAMC", "FAMS", "NOTE", "SOUR", "REFN", "ASSO", "ALIA", "OBJE", "RESN", "RIN", "CHAN", "_STORY", "_STROM_CONFLICT", "_STROM_HYPO", "_STROM_SEARCHED", "_STROM_EDGE", "_STROM_ISLAND", ...INDI_EVENTS],
     "INDI._STROM_CONFLICT": ["TYPE", "TITL", "STAT", "VAL", "DECI"],
     "INDI._STROM_HYPO": ["TITL", "NOTE"],
     "INDI._STROM_SEARCHED": ["TITL", "DATE", "RESN", "_AT"],
+    "INDI._STROM_EDGE": ["_SCOPE", "_RESEARCH", "_GEN", "_END", "_NEXT", "_EST", "DATE", "_RECORDS", "_BOOK", "_COVERED", "_NORECORDS", "_TASK", "_TRIED", "_HYPO", "_CONFLICT", "_SEARCHES", "_SESSIONS", "_LAST"],
+    "INDI._STROM_ISLAND": ["_HYPO", "_HELD"],
     _STROM_VALUE: ["SOUR"],
     "INDI.NAME": ["TYPE", "GIVN", "SURN", "NPFX", "NSFX", "NICK", "SPFX", "SOUR", "NOTE"],
     "INDI.FAMC": ["PEDI", "NOTE"],
@@ -50,6 +52,10 @@ const TEXT_TAGS = new Set(["NOTE", "TEXT", "TITL", "PAGE", "AUTH", "PUBL", "_STO
 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",
+    // where the tree ends (_STROM_EDGE) and the families nothing links to it (_STROM_ISLAND), with their parts
+    "_STROM_EDGE", "_STROM_ISLAND", "_SCOPE", "_RESEARCH", "_GEN", "_END", "_NEXT", "_EST", "_BASIS", "_RECORDS", "_BOOK", "_ACCESS",
+    "_COVERED", "_NORECORDS", "_TASK", "_LEVEL", "_POS", "_HELD", "_UNTIL", "_TRIED", "_HYPO", "_JOIN", "_ISLAND", "_TEST", "_CONFLICT",
+    "_SEARCHES", "_SESSIONS", "_COST", "_PARTIAL", "_LAST",
 ]);
 /** Context of the children of the last tag in `anc` (the ancestors of a line). */
 function contextOf(anc) {

package/package.json

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