strom-research 1.13.0 → 1.13.1-beta.1

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/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/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.1";
 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.1",
   "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"
   }
 }