strom-research 1.13.0 → 1.13.1-beta.2

package/assets/lang/cs.json

@@ -256,6 +256,7 @@
   "ui.doc.links.ours": "ano",
   "ui.doc.links.other": "vedou do jiného programu (nebo tam, kde strom býval)",
   "ui.doc.links.none": "žádné",
+  "ui.doc.links.unknown": "systém neodpověděl (zjistí se příště)",
   "ui.doc.app": "aplikace Strom",
   "ui.doc.tree": "tento rodokmen",
   "ui.doc.innode": "strom {version} v Node {node}",

package/assets/lang/de.json

@@ -256,6 +256,7 @@
   "ui.doc.links.ours": "ja",
   "ui.doc.links.other": "führen zu einem anderen Programm (oder dorthin, wo strom früher war)",
   "ui.doc.links.none": "keine",
+  "ui.doc.links.unknown": "das System hat nicht geantwortet (beim nächsten Mal erneut gefragt)",
   "ui.doc.app": "Strom-App",
   "ui.doc.tree": "dieser Stammbaum",
   "ui.doc.innode": "strom {version} in Node {node}",

package/dist/brief/brief.js

@@ -18,6 +18,7 @@ import { readyConnectors } from "../core/connector.js";
 import { runs, shellArg } from "../cli/format.js";
 import { foldText } from "../core/text.js";
 import { subjectPeople } from "../core/records.js";
+import { hypothesisPeople } from "../core/directions.js";
 export { DEFAULT_BUDGET } from "../core/config.js";
 import { DEFAULT_BUDGET } from "../core/config.js";
 /** Rough token estimate: good enough for a soft budget. */
@@ -254,7 +255,7 @@ export function buildBrief(tree, opts) {
     // the task's own conflicts and hypotheses come first, whatever their state
     const own = (id) => subjects.has(id);
     const conflicts = tree.list("conflict").filter((c) => own(c.id) || (c.state === "open" && c.subject.some((s) => ids.has(s))));
-    const hyps = tree.list("hypothesis").filter((h) => own(h.id) || (h.state === "open" && h.subject.some((s) => ids.has(s))));
+    const hyps = tree.list("hypothesis").filter((h) => own(h.id) || (h.state === "open" && hypothesisPeople(tree, h).some((s) => ids.has(s))));
     const first = (list) => [...list.filter((x) => own(x.id)), ...list.filter((x) => !own(x.id))];
     const mark = (id, state) => `${own(id) ? "→ " : "  "}${id}${state === "open" ? "" : ` [${state}]`}`;
     if (conflicts.length || hyps.length)

package/dist/cli/ui.js

@@ -223,6 +223,7 @@ export const UI = {
     "ui.doc.links.ours": "yes",
     "ui.doc.links.other": "lead to another program (or where strom was before)",
     "ui.doc.links.none": "none",
+    "ui.doc.links.unknown": "the system did not answer (asked again next time)",
     "ui.doc.app": "Strom app",
     "ui.doc.tree": "this family tree",
     "ui.doc.innode": "strom {version} in Node {node}",

package/dist/core/directions.js

@@ -14,6 +14,25 @@ export function aboutPeople(tree, subject) {
     const partners = subject.filter((id) => typeOfId(id) === "family").flatMap((id) => tree.get(id)?.partners ?? []);
     return [...new Set([...subjectPeople(tree, subject), ...partners])];
 }
+/** Whether a text names a record by its ID (any script around it: never \b, which knows only ASCII letters). */
+export function namesId(text, id) {
+    return new RegExp(`(?<![\\p{L}\\p{M}\\p{N}])${id}(?![\\p{L}\\p{M}\\p{N}])`, "u").test(text);
+}
+const PERSON_ID = /(?<![\p{L}\p{M}\p{N}])P\d{4,}(?![\p{L}\p{M}\p{N}])/gu;
+/**
+ * The people a hypothesis is about: those of its subject, and the people of the tree its question and its variants'
+ * claims name by ID ("the son of P0012 and P0013") — a variant that names a family nothing links to the tree would
+ * join it, though the subject names only the person of the tree. What each variant cites for or against it is
+ * evidence, not who it is about.
+ */
+export function hypothesisPeople(tree, h) {
+    const named = [h.question, ...h.variants.map((v) => v.claim)].flatMap((text) => text.match(PERSON_ID) ?? []);
+    const people = named.filter((id) => {
+        const p = tree.get(id);
+        return p && !p.retracted;
+    });
+    return [...new Set([...aboutPeople(tree, h.subject), ...people])];
+}
 /** The direction a task belongs to: its own, else the narrowest one its people are in; none for a task about nobody. */
 export function directionOf(tree, t, all) {
     if (t.research)

package/dist/core/edge.js

@@ -6,7 +6,7 @@
 // tree ends (_STROM_EDGE, _STROM_ISLAND) and what `strom edge` says.
 import { now } from "./tree.js";
 import { Settings } from "./config.js";
-import { aboutPeople, directionOf, scopes } from "./directions.js";
+import { aboutPeople, directionOf, hypothesisPeople, namesId, scopes } from "./directions.js";
 import { birthEstimate, birthRecordProven, birthWindow, frontier, FRONTIER_LEVELS, RECORD_KINDS, recordsetsCovering } from "./frontier.js";
 import { kinship, offTree } from "./kin.js";
 import { familiesAsChild, familiesAsPartner, parentsOf, primaryName } from "./people.js";
@@ -81,7 +81,7 @@ function islands(tree, kin, tasks, hypotheses) {
         const island = {
             people: [...people],
             hypotheses: hypotheses
-                .map((h) => ({ h, about: aboutPeople(tree, h.subject) }))
+                .map((h) => ({ h, about: hypothesisPeople(tree, h) }))
                 .filter(({ about }) => about.some((x) => people.has(x)) && about.some((x) => kin.has(x)))
                 .map(({ h, about }) => ({ id: h.id, joins: about.filter((x) => kin.has(x)) })),
             held: tasks.filter((t) => LIVE.has(t.state) && off(t) && aboutPeople(tree, t.subject).some((x) => people.has(x))).length,
@@ -113,7 +113,7 @@ export function treeEdges(tree) {
             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 hypAbout = hypotheses.map((h) => ({ h, about: hypothesisPeople(tree, h) }));
     const edges = new Map();
     for (const p of tree.list("person")) {
         if (p.retracted)
@@ -256,7 +256,8 @@ export function treeEdges(tree) {
                 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),
+                // a task about it, or one whose words name it ("the baptism … (H0007 B)")
+                tests: tasks.filter((t) => LIVE.has(t.state) && (t.subject.includes(h.id) || namesId(t.what, h.id))).map((t) => t.id),
             };
         });
         const edgeConflicts = conflicts

package/dist/core/kin.js

@@ -2,7 +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 { aboutPeople, hypothesisPeople } from "./directions.js";
 import { ancestorGenerations, familiesAsChild, familiesAsPartner } from "./people.js";
 function researches(tree) {
     return tree
@@ -125,5 +125,10 @@ export function joiningHypotheses(tree, people) {
     }
     return tree
         .list("hypothesis")
-        .filter((h) => h.state === "open" && h.subject.some((s) => family.has(s)) && h.subject.some((s) => kin.has(s)));
+        .filter((h) => {
+        if (h.state !== "open")
+            return false;
+        const about = hypothesisPeople(tree, h);
+        return about.some((s) => family.has(s)) && about.some((s) => kin.has(s));
+    });
 }

package/dist/core/links.js

@@ -329,22 +329,22 @@ const sys = (cmd, args) => {
     return { status: r.error ? null : r.status, stdout: r.stdout ?? "" };
 };
 const LSREGISTER = "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister";
-/** The app the system opens a link of this scheme with (macOS), or "". */
+/** The app the system opens a link of this scheme with (macOS), "" for none, undefined when the system did not answer. */
 function macHandlerPath(run, scheme) {
     const js = `ObjC.import("AppKit");var u=$.NSWorkspace.sharedWorkspace.URLForApplicationToOpenURL($.NSURL.URLWithString("${scheme}://status"));u.isNil()?"":u.path.js`;
     const r = run("osascript", ["-l", "JavaScript", "-e", js]);
-    return r.status === 0 ? r.stdout.trim() : "";
+    return r.status === 0 ? r.stdout.trim() : undefined;
 }
 /** The mark inside strom's applet: what it runs (another strom's applet, or one of an older place, is not ours). */
 function macMark(app) {
     return path.join(app, "Contents", "Resources", "strom-link.json");
 }
-/**
- * linkHandlerState without waiting: the system asked by a program in the background (the bridge answers meanwhile).
- * What it answers is read the same way.
- */
-export async function linkHandlerStateLater(env, platform = process.platform) {
-    if (env.STROM_NO_INSTALL === "1")
+const sysLater = (cmd, args) => new Promise((resolve) => {
+    // a program that failed to start or was stopped for taking too long: no status (no answer)
+    execFile(cmd, args, { encoding: "utf8", timeout: 30_000, windowsHide: true }, (err, stdout) => resolve({ status: err ? (typeof err.code === "number" ? err.code : null) : 0, stdout: stdout ?? "" }));
+});
+export async function linkHandlerStateLater(env, platform = process.platform, exec = sysLater) {
+    if (env.STROM_NO_INSTALL === "1" && exec === sysLater)
         return "none";
     const calls = [];
     // the commands it would run, found by a dry pass, then each asked in the background
@@ -353,18 +353,22 @@ export async function linkHandlerStateLater(env, platform = process.platform) {
         return { status: null, stdout: "" };
     });
     for (const c of calls)
-        c.r = await new Promise((resolve) => {
-            execFile(c.cmd, c.args, { encoding: "utf8", timeout: 30_000, windowsHide: true }, (err, stdout) => resolve({ status: err ? (typeof err.code === "number" ? err.code : null) : 0, stdout: stdout ?? "" }));
-        });
+        c.r = await exec(c.cmd, c.args);
     return linkHandlerState(env, platform, (cmd, args) => calls.find((c) => c.cmd === cmd && JSON.stringify(c.args) === JSON.stringify(args))?.r ?? { status: null, stdout: "" });
 }
-/** Does the scheme lead to this strom? No system is asked from a test (STROM_NO_INSTALL). */
+/**
+ * Does the scheme lead to this strom? No system is asked from a test (STROM_NO_INSTALL). "none" only when the system
+ * answered that nothing takes the links; a query that failed or timed out is "unknown" (found: a bridge said no links
+ * for a minute while osascript was slow, and the Strom app forgot them).
+ */
 export function linkHandlerState(env, platform = process.platform, run = sys) {
     if (env.STROM_NO_INSTALL === "1" && run === sys)
         return "none";
     const argv = handlerArgv(env, platform);
     if (platform === "darwin") {
         const at = macHandlerPath(run, linkScheme(env));
+        if (at === undefined)
+            return "unknown";
         if (!at)
             return "none";
         const app = macApp(env);
@@ -379,12 +383,17 @@ export function linkHandlerState(env, platform = process.platform, run = sys) {
     }
     if (platform === "win32") {
         const r = run("reg.exe", ["query", `${winKey(env)}\\shell\\open\\command`, "/ve"]);
+        // reg.exe that answered: no such key (1); one that did not run or answer: nothing known
+        if (r.status === null)
+            return "unknown";
         if (r.status !== 0)
             return "none";
         const value = /REG_(?:EXPAND_)?SZ\s+(.*)$/m.exec(r.stdout)?.[1]?.trim();
         return value === windowsCommand(argv) ? "ours" : value ? "other" : "none";
     }
     const r = run("xdg-mime", ["query", "default", `x-scheme-handler/${linkScheme(env)}`]);
+    if (r.status === null)
+        return "unknown";
     const entry = r.status === 0 ? r.stdout.trim() : "";
     if (!entry)
         return "none";
@@ -415,28 +424,42 @@ export function registerLinks(env, platform = process.platform, run = sys) {
     if (platform === "darwin") {
         const app = macApp(env);
         fs.mkdirSync(path.dirname(app), { recursive: true });
-        fs.rmSync(app, { recursive: true, force: true });
-        const script = path.join(path.dirname(app), ".strom-link.applescript");
-        fs.writeFileSync(script, macScript(argv));
-        const made = run("osacompile", ["-o", app, script]);
-        fs.rmSync(script, { force: true });
-        if (made.status !== 0)
-            return false;
-        const plist = path.join(app, "Contents", "Info.plist");
-        run("plutil", ["-replace", "CFBundleIdentifier", "-string", `info.stromapp.research.link${suffix ? `.${suffix}` : ""}`, plist]);
-        run("plutil", ["-replace", "CFBundleName", "-string", name, plist]);
-        run("plutil", ["-replace", "LSUIElement", "-bool", "true", plist]);
-        run("plutil", ["-replace", "CFBundleURLTypes", "-json", JSON.stringify([{ CFBundleURLName: name, CFBundleURLSchemes: [scheme] }]), plist]);
-        // its icon: Strom Research's own
-        if (fs.existsSync(ICON.png))
-            run("sips", ["-s", "format", "icns", ICON.png, "--out", path.join(app, "Contents", "Resources", "applet.icns")]);
-        fs.writeFileSync(macMark(app), JSON.stringify({ argv }, null, 2));
-        // the applet's seal covers its Info.plist: sealed again, by itself (no one's certificate)
-        run("codesign", ["--force", "--sign", "-", app]);
+        // The new applet is made beside, whole (its mark, its seal), and only then put in the old one's place: the links
+        // lead here at every moment (found on Mac: made again in place, a bridge said no links meanwhile and the Strom app
+        // forgot them). An applet that cannot be made leaves the one there as it was.
+        const work = path.join(path.dirname(app), `.strom-link-${process.pid}`);
+        fs.rmSync(work, { recursive: true, force: true });
+        fs.mkdirSync(work);
+        try {
+            const fresh = path.join(work, path.basename(app));
+            const script = path.join(work, "strom-link.applescript");
+            fs.writeFileSync(script, macScript(argv));
+            if (run("osacompile", ["-o", fresh, script]).status !== 0 || !fs.existsSync(fresh))
+                return false;
+            const plist = path.join(fresh, "Contents", "Info.plist");
+            run("plutil", ["-replace", "CFBundleIdentifier", "-string", `info.stromapp.research.link${suffix ? `.${suffix}` : ""}`, plist]);
+            run("plutil", ["-replace", "CFBundleName", "-string", name, plist]);
+            run("plutil", ["-replace", "LSUIElement", "-bool", "true", plist]);
+            run("plutil", ["-replace", "CFBundleURLTypes", "-json", JSON.stringify([{ CFBundleURLName: name, CFBundleURLSchemes: [scheme] }]), plist]);
+            // its icon: Strom Research's own
+            if (fs.existsSync(ICON.png))
+                run("sips", ["-s", "format", "icns", ICON.png, "--out", path.join(fresh, "Contents", "Resources", "applet.icns")]);
+            fs.writeFileSync(macMark(fresh), JSON.stringify({ argv }, null, 2));
+            // the applet's seal covers its Info.plist: sealed again, by itself (no one's certificate)
+            run("codesign", ["--force", "--sign", "-", fresh]);
+            // into its place: a folder is not renamed over another, so the old one aside first — a moment of two renames
+            if (fs.existsSync(app))
+                fs.renameSync(app, path.join(work, "old.app"));
+            fs.renameSync(fresh, app);
+        }
+        finally {
+            fs.rmSync(work, { recursive: true, force: true });
+        }
         run(LSREGISTER, ["-f", app]);
         return linkHandlerState(env, platform, run) === "ours";
     }
     if (platform === "win32") {
+        // each value written over the one there (reg add /f): the command is never missing meanwhile
         const add = (key, args) => run("reg.exe", ["add", key, ...args, "/f"]).status === 0;
         const key = winKey(env);
         const ok = add(key, ["/ve", "/d", `URL:${name}`]) &&
@@ -447,7 +470,9 @@ export function registerLinks(env, platform = process.platform, run = sys) {
     }
     const file = linuxEntry(env);
     fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, linuxDesktopEntry(argv, scheme, name));
+    // written beside, then put in its place: never read half written
+    fs.writeFileSync(`${file}.${process.pid}`, linuxDesktopEntry(argv, scheme, name));
+    fs.renameSync(`${file}.${process.pid}`, file);
     run("xdg-mime", ["default", linuxEntryName(env), `x-scheme-handler/${scheme}`]);
     run("update-desktop-database", [path.dirname(file)]);
     return linkHandlerState(env, platform, run) === "ours";

package/dist/core/live.js

@@ -172,22 +172,91 @@ export function liveLogFile(root) {
     return path.join(root, ".strom", "live.log");
 }
 const LIVE_LOG_BYTES = 200 * 1024;
+/** The tree's folder as the system names it (its links followed: /tmp is /private/tmp on a Mac) — never normalized. */
+function realRoot(root) {
+    try {
+        return fs.realpathSync(root);
+    }
+    catch {
+        return path.resolve(root);
+    }
+}
+/** Whether two paths are one folder: the same name, else the same folder of the same disk; undefined when one is not there. */
+function sameFolder(a, b) {
+    if (a === b)
+        return true;
+    try {
+        const x = fs.statSync(a, { bigint: true });
+        const y = fs.statSync(b, { bigint: true });
+        return x.dev === y.dev && x.ino === y.ino;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Where a process runs (its working folder): a bridge runs in its tree's folder. Undefined where it cannot be asked
+ * (Windows; lsof missing) — then a process is taken for what its note says, as before.
+ */
+function processCwd(pid) {
+    if (process.platform === "linux") {
+        try {
+            return fs.readlinkSync(`/proc/${pid}/cwd`);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (process.platform !== "darwin")
+        return undefined;
+    const r = spawnSync("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], { encoding: "utf8", timeout: 10_000 });
+    if (r.error || r.status !== 0)
+        return undefined;
+    const line = (r.stdout ?? "").split("\n").find((l) => l.startsWith("n"));
+    return line ? line.slice(1) : undefined;
+}
+/** A bridge running in another folder than this tree's — never ended for this tree. Its folder, else undefined. */
+function bridgeElsewhere(pid, root) {
+    const cwd = processCwd(pid);
+    return cwd && sameFolder(cwd, realRoot(root)) === false ? cwd : undefined;
+}
+/**
+ * The folder a bridge's note (live.json, live-last.json) belongs to when it is not this tree's: a research copied with
+ * its .strom (by hand, Finder) carries the original's notes — its bridge never taken for the copy's own, never ended by
+ * it, its address never taken over (found on Mac: the copy's strom ended the original's bridge and served the Strom app
+ * following the original at its address). A note of an older strom names no folder: its process, while it is a bridge,
+ * is asked where it runs. A folder named that is no longer there is not another one: the research was moved.
+ */
+function foreignNote(root, note) {
+    if (typeof note.root === "string")
+        return sameFolder(note.root, realRoot(root)) === false ? note.root : undefined;
+    if (typeof note.pid === "number" && note.pid !== process.pid && isBridge(note.pid))
+        return bridgeElsewhere(note.pid, root);
+    return undefined;
+}
 function lastFile(root) {
     return path.join(root, ".strom", "live-last.json");
 }
-function readLast(root) {
+/** The last bridge of this tree — and, when the note there is another folder's (a research copied with its .strom), that folder. */
+function readLastOf(root) {
     try {
         const last = JSON.parse(fs.readFileSync(lastFile(root), "utf8"));
-        return Number.isInteger(last.port) && (last.token === undefined || /^[0-9a-f]{32}$/.test(last.token)) ? last : undefined;
+        if (!Number.isInteger(last.port) || !(last.token === undefined || /^[0-9a-f]{32}$/.test(last.token)))
+            return {};
+        const foreign = foreignNote(root, last);
+        return foreign ? { foreign } : { last };
     }
     catch {
-        return undefined;
+        return {};
     }
 }
+function readLast(root) {
+    return readLastOf(root).last;
+}
 function writeLast(root, last) {
     try {
         const file = lastFile(root);
-        fs.writeFileSync(`${file}.${process.pid}`, JSON.stringify(last, null, 2));
+        fs.writeFileSync(`${file}.${process.pid}`, JSON.stringify({ ...last, root: realRoot(root) }, null, 2));
         fs.renameSync(`${file}.${process.pid}`, file);
     }
     catch {
@@ -227,11 +296,11 @@ function alive(pid) {
         return e.code === "EPERM";
     }
 }
-/** The bridge of this tree when it runs. */
+/** The bridge of this tree when it runs (never another folder's whose note came with a copy of the research). */
 export function liveRunning(root) {
     try {
-        const info = JSON.parse(fs.readFileSync(liveFile(root), "utf8"));
-        if (info.pid && alive(info.pid))
+        const { root: of, ...info } = JSON.parse(fs.readFileSync(liveFile(root), "utf8"));
+        if (info.pid && alive(info.pid) && !foreignNote(root, { root: of, pid: info.pid }))
             return info;
     }
     catch {
@@ -351,9 +420,12 @@ function isBridge(pid) {
  * End a bridge's process: asked to (SIGTERM — it closes as it should), and when it does not end within a while
  * (a bridge stuck on something) ended for good (SIGKILL). How it ended; "alive" when even that did not end it.
  */
-function endBridge(pid, waitMs = 3000) {
+function endBridge(pid, root, waitMs = 3000) {
     if (!isBridge(pid))
         return "gone";
+    // a bridge of another folder (a note copied with the research) is never ended for this tree
+    if (bridgeElsewhere(pid, root))
+        return "elsewhere";
     // ended: no such process, or one that only waits for its parent to hear it ended (a zombie)
     const ended = () => {
         if (!alive(pid))
@@ -396,7 +468,12 @@ export function stopLive(root, why = "strom live stop") {
     const last = readLast(root);
     if (last?.pid === info.pid)
         writeLast(root, { ...last, ended: { at: new Date().toISOString(), reason: why } });
-    const how = endBridge(info.pid);
+    const how = endBridge(info.pid, root);
+    if (how === "elsewhere") {
+        noteLive(root, `a bridge of another folder (${info.pid}) is named in live.json: not ended, not this tree's`);
+        fs.rmSync(liveFile(root), { force: true });
+        return "none";
+    }
     if (how === "killed")
         noteLive(root, `the bridge ${info.pid} did not end when asked: ended for good (SIGKILL)`);
     if (how === "alive") {
@@ -450,7 +527,7 @@ function masked(url) {
 function writeLive(root, info) {
     const file = liveFile(root);
     fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(`${file}.${process.pid}`, JSON.stringify(info, null, 2));
+    fs.writeFileSync(`${file}.${process.pid}`, JSON.stringify({ ...info, root: realRoot(root) }, null, 2));
     fs.renameSync(`${file}.${process.pid}`, file);
 }
 function head(root) {
@@ -693,27 +770,59 @@ function directions(tree, all, queued, workingOn) {
 }
 /** How long what the system says of the links is taken as true (asking it costs a program started). */
 const LINKS_FRESH_MS = 60_000;
-let linksSeen;
-let linksAsking = false;
+/** No links after links that worked: asked again so soon, and taken only when said again. */
+const LINKS_AGAIN_MS = 5_000;
 /**
- * The strom-research:// links this computer takes: said to the app only while the scheme leads to this strom. The
- * system is asked in the background (it starts a program, slow on a busy computer): until it answers, what it said
- * last — the bridge never waits for it.
+ * What the bridge says of the links, asked of the system now and then: the first time at once, then in the background
+ * (the bridge never waits for it) — until it answers, what it said last. The system that does not answer (a failed or
+ * slow query: unknown) changes nothing. No links after links that worked are taken only when the system says so twice
+ * in a row: an applet being made again, a moment of LaunchServices — and the Strom app forgot the links (found on Mac).
  */
+export function linksWatch(read, opts = {}) {
+    const freshMs = opts.freshMs ?? LINKS_FRESH_MS;
+    const againMs = opts.againMs ?? LINKS_AGAIN_MS;
+    const clock = opts.clock ?? Date.now;
+    let seen;
+    let asking = false;
+    // none said once after links that worked: not taken yet
+    let doubt = false;
+    // asked again in a few seconds rather than in a minute
+    const soon = () => clock() - freshMs + againMs;
+    return () => {
+        if (!seen) {
+            const state = read.now();
+            seen = { at: state === "unknown" ? soon() : clock(), actions: linkActions(state) };
+        }
+        else if (clock() - seen.at > freshMs && !asking) {
+            asking = true;
+            read.later().then((state) => {
+                asking = false;
+                const was = seen?.actions ?? [];
+                if (state === "unknown") {
+                    seen = { at: was.length ? clock() : soon(), actions: was };
+                    return;
+                }
+                const actions = linkActions(state);
+                if (!actions.length && was.length && !doubt) {
+                    doubt = true;
+                    seen = { at: soon(), actions: was };
+                    return;
+                }
+                doubt = false;
+                seen = { at: clock(), actions };
+            }, () => {
+                asking = false;
+                seen = { at: clock(), actions: seen?.actions ?? [] };
+            });
+        }
+        return seen.actions;
+    };
+}
+let linksOf;
+/** The strom-research:// links this computer takes: said to the app only while the scheme leads to this strom. */
 function links(env) {
-    if (!linksSeen)
-        linksSeen = { at: Date.now(), actions: linkActions(linkHandlerState(env)) };
-    else if (Date.now() - linksSeen.at > LINKS_FRESH_MS && !linksAsking) {
-        linksAsking = true;
-        linkHandlerStateLater(env).then((state) => {
-            linksSeen = { at: Date.now(), actions: linkActions(state) };
-            linksAsking = false;
-        }, () => {
-            linksSeen = { at: Date.now(), actions: linksSeen?.actions ?? [] };
-            linksAsking = false;
-        });
-    }
-    return linksSeen.actions;
+    linksOf ??= linksWatch({ now: () => linkHandlerState(env), later: () => linkHandlerStateLater(env) });
+    return linksOf();
 }
 /**
  * A second installation's own scheme (strom-research-beta), for the app to build its links with — said whenever it is
@@ -883,7 +992,11 @@ export function serveLive(root, env) {
     }
     // the address of the last bridge, so the app that followed it finds this one (its secret: none once it was ended for
     // good — a new one); replaced while it runs when a page that is no Strom app comes with it (leaked)
-    const last = readLast(root);
+    const { last, foreign } = readLastOf(root);
+    // the notes of another folder's bridge (the research copied with its .strom): a new address of its own — a port the
+    // system picks and a new secret, so the app following the original never comes here
+    if (foreign)
+        noteLive(root, `the bridge's notes came from another folder (${foreign}): a new address`);
     let token = last?.token ?? crypto.randomBytes(16).toString("hex");
     // what this bridge says of itself (live.json), once it listens
     let live;
@@ -1847,7 +1960,14 @@ export function serveLive(root, env) {
                 // the bridge before this one still holds it (stuck, or ending just now): ended, its port taken again — the
                 // app following the address goes on; a port another program holds: another one (the app needs ?live= again)
                 const before = last && last.pid !== process.pid ? last.pid : undefined;
-                if (before && tries === 0 && endBridge(before) !== "gone") {
+                const ended = before && tries === 0 ? endBridge(before, root) : "gone";
+                if (ended === "elsewhere") {
+                    // a bridge of another folder (its note copied with the research): never ended, never its address — a new one
+                    noteLive(root, `a bridge of another folder (${before}) holds port ${wanted}: not ended`);
+                    token = crypto.randomBytes(16).toString("hex");
+                    tries = 20;
+                }
+                else if (ended !== "gone") {
                     noteLive(root, `the bridge before (${before}) still held port ${wanted}: ended`);
                     tries = 1;
                 }

package/dist/core/review.js

@@ -7,6 +7,7 @@
 // Each kind is at most one task per person at a time, and what a task of that
 // kind took up is never proposed again.
 import { dateYears } from "./gdate.js";
+import { hypothesisPeople } from "./directions.js";
 import { birthEstimate, RECORD_KINDS, recordsetsCovering, researchPeople } from "./frontier.js";
 import { birthEvent, displayName, familiesAsPartner, lifespan } from "./people.js";
 import { phrase } from "./phrases.js";
@@ -209,7 +210,7 @@ function openConflicts(tree, p) {
     const about = (subject) => subject.includes(p.id) || subject.some((s) => families.has(s));
     return [
         ...tree.list("conflict").filter((c) => c.state === "open" && about(c.subject)),
-        ...tree.list("hypothesis").filter((h) => h.state === "open" && about(h.subject)),
+        ...tree.list("hypothesis").filter((h) => h.state === "open" && hypothesisPeople(tree, h).includes(p.id)),
     ].map((x) => x.id);
 }
 /** The tasks strom proposes for the people of a person research (strom review). */

package/dist/core/tree.js

@@ -27,7 +27,7 @@ import { lastBackup } from "./backup.js";
 export const TREE_FILE = "strom.json";
 // between releases the candidate being made (a bridge run from the sources says what it is: the Strom app goes by it);
 // at a release the release's own (package.json)
-export const VERSION = "1.13.0";
+export const VERSION = "1.13.1-beta.2";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/dist/gedcom/export.js

@@ -34,6 +34,7 @@ import { quay } from "../core/evidence.js";
 import { VERSION } from "../core/tree.js";
 import { dataUrl, turned } from "../core/excerpt.js";
 import { mainPerson } from "../core/kin.js";
+import { hypothesisPeople } from "../core/directions.js";
 import * as git from "../core/git.js";
 import { treeEdges } from "../core/edge.js";
 import { readersOf } from "../core/review.js";
@@ -141,7 +142,13 @@ export function exportGedcom(tree, opts = {}) {
     // What the research knows beyond the facts (the Strom profile, opts.research): read once.
     const research = {
         conflicts: opts.research ? tree.list("conflict") : [],
-        hypotheses: opts.research ? tree.list("hypothesis").filter((h) => h.state === "open") : [],
+        // with the people each is about: its subject's, and those its variants name (core/directions.ts hypothesisPeople)
+        hypotheses: opts.research
+            ? tree
+                .list("hypothesis")
+                .filter((h) => h.state === "open")
+                .map((h) => ({ h, people: hypothesisPeople(tree, h) }))
+            : [],
         // a search is of the people of the task it served
         searched: opts.research
             ? tree
@@ -559,7 +566,7 @@ export function exportGedcom(tree, opts = {}) {
             if (c.state === "resolved" && c.resolution)
                 w.text(2, "DECI", c.resolution);
         }
-        for (const h of research.hypotheses.filter((x) => about(x.subject))) {
+        for (const { h } of research.hypotheses.filter((x) => x.people.includes(p.id))) {
             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"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.13.0",
+  "version": "1.13.1-beta.2",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {
@@ -45,5 +45,8 @@
   "devDependencies": {
     "@types/node": "^22.20.4",
     "typescript": "^7.0.2"
+  },
+  "publishConfig": {
+    "tag": "beta"
   }
 }