strom-research 1.7.0 → 1.9.0

package/dist/core/pack.js

@@ -309,3 +309,34 @@ export function unpack(pack, treesDir, shared, env) {
         throw e;
     }
 }
+/** The files of the shared store a tree names (its images, the family's material kept there), by its folder alone. */
+export function sharedFilesOf(root) {
+    const out = new Map();
+    const read = (dir, f) => {
+        let names = [];
+        try {
+            names = fs.readdirSync(path.join(root, "data", dir)).filter((n) => n.endsWith(".json"));
+        }
+        catch {
+            return;
+        }
+        for (const n of names)
+            try {
+                f(JSON.parse(fs.readFileSync(path.join(root, "data", dir, n), "utf8")));
+            }
+            catch {
+                // an unreadable record names nothing
+            }
+    };
+    read("images", (m) => m.file && out.set(m.file, m.size ?? 0));
+    read("inputs", (i) => i.file?.startsWith("media:") && out.set(i.file.slice(6), i.size ?? 0));
+    return out;
+}
+/** The files of the shared store only this tree names — none of the other trees (their folders) does. */
+export function onlyItsFiles(root, others, shared) {
+    const theirs = new Set();
+    for (const o of others)
+        for (const f of sharedFilesOf(o).keys())
+            theirs.add(f);
+    return [...sharedFilesOf(root)].filter(([f]) => !theirs.has(f) && fs.existsSync(path.join(shared, f))).map(([file, size]) => ({ file, size }));
+}

package/dist/core/phrases.js

@@ -78,6 +78,67 @@ export const PHRASES = {
     "intake.done.read": "what it adds to the tree is entered as leads citing it (strom source add … --kind family-tree --form authored --input {id}) — or the input is skipped with a reason (strom input skip {id} --reason …)",
     "intake.done": "every person and fact in it is recorded (a source if it is an original document, leads otherwise) and cited — or the input is skipped with a reason (strom input skip I… --reason …)",
     "task.answer": "The user answered (to: {asked}): {answer}",
+    // who is at work, for the Strom app (the bridge's working)
+    "who.run": "{agent} on its own",
+    "who.chat": "{agent} conversation",
+    // what a commit saved, for the Strom app (core/changelog.ts)
+    "log.person.add": "New person: {who}",
+    "log.person.name": "Name recorded: {who}",
+    "log.person.edit": "Changed: {who}",
+    "log.person.cite": "A record for {who}",
+    "log.person.retract": "Withdrawn: {who}",
+    "log.merge": "Two records of one merged: {who}",
+    "log.family.add": "New family: {who}",
+    "log.family.child": "A child of {who}: {child}",
+    "log.family.edit": "Family changed: {who}",
+    "log.family.cite": "A record for the family {who}",
+    "log.event.add": "{who} – {fact}",
+    "log.event.edit": "Refined: {who} – {fact}",
+    "log.event.cite": "A record for: {who} – {fact}",
+    "log.event.retract": "Withdrawn: {who} – {fact}",
+    "log.source.add": "Record from a source: {name}",
+    "log.source.edit": "Record changed: {name}",
+    "log.search.found": "Searched, found: {name}",
+    "log.search.negative": "Searched, nothing there: {name}",
+    "log.search.partial": "Searched, found in part: {name}",
+    "log.search.inconclusive": "Searched, not clear: {name}",
+    "log.recordset.add": "New book: {name}",
+    "log.recordset.edit": "Book changed: {name}",
+    "log.recordset.calibrate": "Which years are where in the book: {name}",
+    "log.media": "New images: {name} (images {images})",
+    "log.media.one": "New image: {name} (image {image})",
+    "log.media.loose": "New images: {n}",
+    "log.reading": "Read through: {name} (images {images})",
+    "log.task.add": "New task: {name}",
+    "log.task.done": "Done: {name}",
+    "log.task.park": "Put aside: {name}",
+    "log.task.drop": "Dropped: {name}",
+    "log.task.wait": "Waits for you: {name}",
+    "log.task.wake": "Back to the agent: {name}",
+    "log.task.edit": "Task changed: {name}",
+    "log.session.start": "The agent began: {name}",
+    "log.session.close": "The agent finished: {name}",
+    "log.lesson.add": "Learned: {name}",
+    "log.hypothesis.add": "A question weighed: {name}",
+    "log.hypothesis.argue": "Weighed further: {name}",
+    "log.hypothesis.decide": "Decided: {name}",
+    "log.conflict.add": "The records disagree: {name}",
+    "log.conflict.resolve": "Disagreement settled: {name}",
+    "log.place.add": "New place: {name}",
+    "log.place.edit": "Place refined: {name}",
+    "log.repository.add": "New archive: {name}",
+    "log.repository.edit": "Archive changed: {name}",
+    "log.story.set": "Story: {who}",
+    "log.story.approve": "Story approved: {who}",
+    "log.note.add": "Note: {name}",
+    "log.input.add": "Material from the family: {name}",
+    "log.input.sync": "Family tree taken in: {name}",
+    "log.input.done": "Material gone through: {name}",
+    "log.research.add": "New direction of the research: {name}",
+    "log.research.edit": "Direction changed: {name}",
+    "log.research.pause": "Direction paused: {name}",
+    "log.research.resume": "Direction taken up again: {name}",
+    "log.research.done": "Direction ended: {name}",
 };
 const catalogs = new Map();
 /**

package/dist/core/queue.js

@@ -6,12 +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"]);
@@ -53,9 +57,15 @@ export function ancestorLines(tree, focus, max = 50) {
 /** The open tasks in the order to work on them, each with the reason. */
 export function rankTasks(tree, tasks, strategy = "balanced", opts = {}) {
     const today = now().slice(0, 10);
-    const open = tasks.filter((t) => ["open", "doing"].includes(effectiveState(t, today)));
-    const withImages = new Set(tree.list("media").map((m) => m.recordset));
     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 = 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();
     const linesOf = (researchId) => {
         const r = researches.find((x) => x.id === researchId) ?? (researches.length === 1 ? researches[0] : undefined);
@@ -67,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/relocate.js

@@ -33,15 +33,15 @@ export function within(inner, outer, platform = process.platform) {
 export function sameFolder(a, b, platform = process.platform) {
     return within(path.resolve(a), path.resolve(b), platform) && within(path.resolve(b), path.resolve(a), platform);
 }
-/** Somebody at work in a tree: an agent present, a run, a command holding its lock, the live bridge. */
-function atWork(root) {
-    return liveWorkers(root).length > 0 || runsAtWork(root).length > 0 || Boolean(liveHolder(path.join(root, ".strom", "tree.lock"))) || Boolean(liveRunning(root));
+/** Somebody at work in a tree: an agent present, a run, a command holding its lock, the live bridge (unless `bridge: false`: it only reads). */
+export function atWork(root, opts = {}) {
+    return liveWorkers(root).length > 0 || runsAtWork(root).length > 0 || Boolean(liveHolder(path.join(root, ".strom", "tree.lock"))) || (opts.bridge !== false && Boolean(liveRunning(root)));
 }
 /** `trees`: the folders of the trees strom knows (those inside `from` move along). */
 export function planMove(from, to, trees) {
     const names = entries(from);
     const inside = trees.filter((t) => within(t, from));
-    const busy = inside.filter(atWork).map((t) => path.basename(t));
+    const busy = inside.filter((t) => atWork(t)).map((t) => path.basename(t));
     // The top of a disk (its own hidden folders only): into a folder named like the old one there.
     const there = entries(to);
     const target = there.length && there.every((n) => DISK.has(n)) ? path.join(to, path.basename(from) || "Strom") : to;

package/dist/core/session.js

@@ -11,6 +11,7 @@ import { UsageError } from "./errors.js";
 import { now, VERSION } from "./tree.js";
 import { makeNote } from "./actions.js";
 import { detectAgent } from "./which.js";
+import { finishAsked, finishFile } from "./clock.js";
 import { isLiveWorker, isWorkerId } from "./workers.js";
 function currentFile(tree, env = tree.env) {
     const w = env.STROM_WORKER;
@@ -121,7 +122,7 @@ export function sessionNote(tree, s, text) {
 export function closeSession(tree, s, input) {
     if (!input.interrupted && (!input.summary.trim() || !input.next.trim()))
         throw new UsageError("closing needs --summary and --next", { hint: 'e.g. --summary "found the baptism, parents Josef and Marie" --next "marriage of Josef ~1898 in B0002"' });
-    return tree.withTreeLock(() => {
+    const closed = tree.withTreeLock(() => {
         s = tree.get(s.id) ?? s;
         const task = s.task ? tree.get(s.task) : undefined;
         if (task && task.state === "doing") {
@@ -140,7 +141,8 @@ export function closeSession(tree, s, input) {
             ...(input.summary.trim() ? { summary: input.summary.trim() } : {}),
             ...(input.next.trim() ? { next: input.next.trim() } : {}),
             ...(input.metrics ? { metrics: input.metrics } : {}),
-            ...(input.endedBy ? { endedBy: input.endedBy } : {}),
+            // asked to finish by the user (strom session finish): theirs, and a run stops after it
+            ...(input.endedBy ? { endedBy: input.endedBy } : finishAsked(tree.root, s.id) ? { endedBy: "user" } : {}),
         };
         tree.put(closed, { op: "session.close", targets: [s.id], summary: `${s.id} ${closed.state}: ${(input.summary || "no summary").slice(0, 80)}` });
         // Only the session this agent calls its current one is forgotten — not another agent's.
@@ -148,6 +150,10 @@ export function closeSession(tree, s, input) {
             setCurrent(tree, undefined);
         return closed;
     });
+    // asked to finish (strom session finish): done
+    if (!tree.dryRun)
+        fs.rmSync(finishFile(tree.root, closed.id), { force: true });
+    return closed;
 }
 /** The last closed sessions (newest first), optionally of one research. */
 export function recentSessions(tree, research, n = 2) {

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/trash.js

@@ -0,0 +1,72 @@
+// Into the system's trash, never deleted for good: a person can take it back.
+// macOS: ~/.Trash (Finder's own delete when it lies on another disk); Windows:
+// the Recycle Bin (PowerShell's VisualBasic FileSystem); Linux: gio trash, else
+// the XDG trash folder of the user's home.
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { StromError } from "./errors.js";
+import { userHome } from "./paths.js";
+function free(dir, name) {
+    let to = path.join(dir, name);
+    for (let n = 2; fs.existsSync(to); n++)
+        to = path.join(dir, `${name} (${n})`);
+    return to;
+}
+function run(command, args, env) {
+    const r = spawnSync(command, args, { stdio: "ignore", windowsHide: true, timeout: 120_000, env: { ...process.env, ...env } });
+    return !r.error && r.status === 0;
+}
+/** Move a file or folder into the trash; `name` is what it is called there. Throws when no trash takes it. */
+export function moveToTrash(target, env, name = path.basename(target), platform = process.platform) {
+    if (!fs.existsSync(target))
+        return;
+    const fail = () => new StromError(`could not put ${target} into the trash`, { hint: "move the folder into the trash yourself" });
+    if (env.STROM_TRASH) {
+        // a test's own trash: nothing of the computer's
+        fs.mkdirSync(env.STROM_TRASH, { recursive: true });
+        fs.renameSync(target, free(env.STROM_TRASH, name));
+        return;
+    }
+    if (platform === "darwin") {
+        const trash = path.join(userHome(env), ".Trash");
+        try {
+            fs.mkdirSync(trash, { recursive: true });
+            fs.renameSync(target, free(trash, name));
+            return;
+        }
+        catch (e) {
+            if (e.code !== "EXDEV")
+                throw fail();
+        }
+        // on another disk: Finder puts it into that disk's own trash
+        const script = `tell application "Finder" to delete (POSIX file ${JSON.stringify(target)} as alias)`;
+        if (!run("osascript", ["-e", script], env))
+            throw fail();
+        return;
+    }
+    if (platform === "win32") {
+        const kind = fs.statSync(target).isDirectory() ? "DeleteDirectory" : "DeleteFile";
+        const lit = `'${target.replace(/'/g, "''")}'`;
+        const ps = `Add-Type -AssemblyName Microsoft.VisualBasic; [Microsoft.VisualBasic.FileIO.FileSystem]::${kind}(${lit}, 'OnlyErrorDialogs', 'SendToRecycleBin')`;
+        if (!run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", ps], env) || fs.existsSync(target))
+            throw fail();
+        return;
+    }
+    if (run("gio", ["trash", target], env) && !fs.existsSync(target))
+        return;
+    // the XDG trash of the home: the file, and a note of where it came from
+    const base = env.XDG_DATA_HOME || path.join(userHome(env), ".local", "share");
+    const files = path.join(base, "Trash", "files");
+    const info = path.join(base, "Trash", "info");
+    try {
+        fs.mkdirSync(files, { recursive: true });
+        fs.mkdirSync(info, { recursive: true });
+        const to = free(files, name);
+        fs.renameSync(target, to);
+        fs.writeFileSync(path.join(info, `${path.basename(to)}.trashinfo`), `[Trash Info]\nPath=${encodeURI(target)}\nDeletionDate=${new Date().toISOString().slice(0, 19)}\n`);
+    }
+    catch {
+        throw fail();
+    }
+}

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

package/dist/core/workers.js

@@ -9,6 +9,26 @@ import { acquireLock, liveHolder } from "./lock.js";
 function dir(root) {
     return path.join(root, ".strom", "workers");
 }
+function pauseFile(root, id) {
+    return path.join(dir(root), `${id}.paused`);
+}
+/** A run waits for its gate (the app shows it paused, not at work) — or goes on (undefined). */
+export function markPaused(root, id, paused) {
+    const file = pauseFile(root, id);
+    if (!paused)
+        return fs.rmSync(file, { force: true });
+    fs.mkdirSync(dir(root), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(paused));
+}
+function pausedOf(root, id) {
+    try {
+        const p = JSON.parse(fs.readFileSync(pauseFile(root, id), "utf8"));
+        return typeof p.until === "string" ? { until: p.until, ...(typeof p.reason === "string" ? { reason: p.reason } : {}) } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** A worker's name, safe as a file name. */
 export function isWorkerId(id) {
     return !!id && /^[\w.-]{1,80}$/.test(id);
@@ -29,11 +49,16 @@ export function liveWorkers(root) {
     }
     for (const f of files) {
         const file = path.join(dir(root), f);
+        const id = f.slice(0, -5);
         const info = liveHolder(file, 7 * 24 * 3600_000);
-        if (info)
-            out.push({ id: f.slice(0, -5), label: info.owner, since: info.at });
-        else
+        if (info) {
+            const paused = pausedOf(root, id);
+            out.push({ id, label: info.owner, since: info.at, ...(paused ? { paused } : {}) });
+        }
+        else {
             fs.rmSync(file, { force: true });
+            fs.rmSync(pauseFile(root, id), { force: true });
+        }
     }
     return out;
 }

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/dist/runners/claude.js

@@ -13,7 +13,7 @@
 // are on only when a connector fetches through the browser (--chrome), and off
 // otherwise (--no-chrome), whatever Claude Code's own default is.
 import { randomUUID } from "node:crypto";
-import { appendLog, looksLikeLimit, spawnAgent, stopTree } from "./runner.js";
+import { appendLog, looksLikeLimit, OWN_GROUP, spawnAgent, stopTree } from "./runner.js";
 function describeTool(block) {
     const input = block.input ?? {};
     if (block.name === "Bash" && typeof input.command === "string")
@@ -71,6 +71,7 @@ function attempt(opts, args, input, timeoutMs) {
             env: opts.interactive ? opts.env : headlessEnv(opts.env, opts.timeoutMs),
             stdio: opts.interactive ? "inherit" : ["pipe", "pipe", "pipe"],
             windowsHide: !opts.interactive,
+            detached: !opts.interactive && OWN_GROUP,
         });
         // The brief goes in on stdin: no limit on its length on any platform.
         if (!opts.interactive)

package/dist/runners/jsonl.js

@@ -4,7 +4,7 @@
 // recognised — the same for every such agent; each runner only reads its own
 // events. Stopped at its time limit, an agent that can resume its session gets a
 // few minutes to write down what it found (RunOptions.wrapUp).
-import { appendLog, looksLikeLimit, spawnAgent, stopTree } from "./runner.js";
+import { appendLog, looksLikeLimit, OWN_GROUP, spawnAgent, stopTree } from "./runner.js";
 export async function runJsonLines(command, args, env, opts, resume, onEvent) {
     const started = Date.now();
     const heard = { metrics: {}, text: "", isError: false, denied: [] };
@@ -54,7 +54,7 @@ export async function runJsonLines(command, args, env, opts, resume, onEvent) {
 /** One start of the agent; its events go to `heard`. */
 function attempt(command, args, input, env, opts, timeoutMs, heard, onEvent) {
     return new Promise((resolve) => {
-        const child = spawnAgent(command, args, { cwd: opts.cwd, env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+        const child = spawnAgent(command, args, { cwd: opts.cwd, env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true, detached: OWN_GROUP });
         child.stdin?.end(input);
         let timedOut = false;
         const timer = timeoutMs

package/dist/runners/runner.js

@@ -47,17 +47,30 @@ export function spawnAgent(command, args, opts) {
     }
     return spawn(found, args, { ...opts, env: opts.env });
 }
-/** Stop a child and everything it started (Windows: the whole process tree). */
+/**
+ * A headless agent in a process group of its own (not on Windows, whose console sends Ctrl-C to every process of
+ * it): Ctrl-C in the terminal reaches strom alone, which asks the session to finish first (strom run).
+ */
+export const OWN_GROUP = process.platform !== "win32";
+/** Stop a child and everything it started (Windows: the whole process tree; elsewhere its own group, when it has one). */
 export function stopTree(child) {
     if (child.exitCode !== null || child.pid === undefined)
         return;
     if (process.platform === "win32")
         spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
     else {
-        child.kill("SIGTERM");
+        const kill = (sig) => {
+            try {
+                process.kill(-child.pid, sig); // its group: what it started too
+            }
+            catch {
+                child.kill(sig); // no group of its own
+            }
+        };
+        kill("SIGTERM");
         setTimeout(() => {
             if (child.exitCode === null)
-                child.kill("SIGKILL");
+                kill("SIGKILL");
         }, 5000).unref();
     }
 }

package/dist/runners/script.js

@@ -3,7 +3,7 @@
 // (run with node); it gets the same environment an agent would, and the
 // prompt both on stdin (like a headless agent) and in STROM_PROMPT.
 import { spawn } from "node:child_process";
-import { appendLog, looksLikeLimit, stopTree } from "./runner.js";
+import { appendLog, looksLikeLimit, OWN_GROUP, stopTree } from "./runner.js";
 export const scriptRunner = {
     id: "script",
     command: process.execPath,
@@ -26,6 +26,7 @@ function once(opts, prompt, timeoutMs, wrapUp) {
             cwd: opts.cwd,
             env: { ...opts.env, STROM_PROMPT: prompt, ...(wrapUp ? { STROM_WRAP_UP: "1" } : {}) },
             stdio: ["pipe", "pipe", "pipe"],
+            detached: OWN_GROUP,
         });
         child.stdin.end(prompt);
         let timedOut = false;

package/package.json

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