strom-research 1.4.0 → 1.5.0

package/dist/cli/ui.js

@@ -241,6 +241,18 @@ export const UI = {
     "ui.review.pick": "Which one?",
     "ui.review.family": "With their spouse and children?",
     "ui.review.run": "Let the agent work on it now, on its own? ({n} tasks)",
+    "ui.menu.unproven": "People without a record of their own ({n})",
+    "ui.unproven.title": "No record of their own proves these people yet:",
+    "ui.unproven.named": "named in a record",
+    "ui.unproven.leads": "only leads",
+    "ui.unproven.none": "no record",
+    "ui.unproven.tasks": "work on them is under way",
+    "ui.unproven.living": "Most likely living (born less than {years} years ago) — the family's to tell, no tasks: {names}",
+    "ui.unproven.how": "What should the agent do?",
+    "ui.unproven.all": "All of them, step by step ({n} at a time)",
+    "ui.unproven.pick": "Only the ones I pick",
+    "ui.unproven.numbers": "Their numbers from the list (e.g. 1 3 5-7, or their IDs; Enter or 0 goes back)",
+    "ui.unproven.bad": "Not in the list: {x}",
     "ui.o.reread": "second reading",
     "ui.o.reread.offer": "{n} facts rest only on readings by another model ({models}); the user reads with {model} now — offer it once, in a sentence: strom review <whom> --reread (a task per person; the user decides)",
     "ui.o.stories": "stories",
@@ -278,6 +290,7 @@ export const UI = {
     "ui.update.downloading": "Downloading strom {version}…",
     "ui.update.failed": "The update did not work: {detail}. strom stays as it was.",
     "ui.update.done": "✓ strom is updated: {previous} → {version}.",
+    "ui.update.restart": "strom is updated — this menu still runs the old version. Start strom again (or the shortcut \"{shortcut}\"), and the new version is at work.",
     "ui.o.update": "update",
     "ui.o.update.new": "{version} is out (this is {current}) — tell the user; strom update installs it with their yes",
     "ui.app.where.installed": "the installed app",
@@ -380,6 +393,60 @@ export const UI = {
     "ui.browse.plan": "What the agent will do next",
     "ui.review.new": "{name} — {n} new task(s):",
     "ui.review.nothing": "{name} — nothing new to review",
+    "ui.sync.title": "{file}: {n} change(s) against the research",
+    "ui.sync.base": "Compared with what the research gave the Strom app ({head}): only what was changed since counts as your edit.",
+    "ui.sync.nobase": "The file does not say which state of the research it came from: additions are taken, differences only shown (pick them with --only).",
+    "ui.sync.headmissing": "The research's history does not have the state {head} the file names: additions are taken, differences only shown (pick them with --only).",
+    "ui.sync.partial": "The file has far fewer people than it was given: nothing is taken as removed.",
+    "ui.sync.strangers": "These IDs are not the research's people of that name — taken as new people: {ids}",
+    "ui.sync.nothing": "{file}: nothing new — the research has everything in it.",
+    "ui.sync.person.new": "{n}. new person: {name}",
+    "ui.sync.fact.new": "{n}. {who}: new — {fact}",
+    "ui.sync.fact.changed": "{n}. {who}: {kind} changed — {was} → {now}",
+    "ui.sync.fact.differs": "{n}. {who}: {kind} differs — the research {was}, the file {now}",
+    "ui.sync.fact.gone": "{n}. {who}: no longer in it — {fact}",
+    "ui.sync.name.new": "{n}. {who}: another name — {text}",
+    "ui.sync.sex.changed": "{n}. {who}: sex {text}",
+    "ui.sync.note.new": "{n}. {who}: a note — “{text}”",
+    "ui.sync.family.new": "{n}. a new family: {who}{kids}",
+    "ui.sync.child.new": "{n}. {who}: a child — {child}",
+    "ui.sync.child.gone": "{n}. {who}: no longer their child — {child}",
+    "ui.sync.person.gone": "{n}. no longer in it: {name}",
+    "ui.sync.do.add": "added as a lead",
+    "ui.sync.do.correct": "corrects the research's lead",
+    "ui.sync.do.conflict": "a conflict for you to decide (the research has it from a record)",
+    "ui.sync.do.user": "your edit wins (the record's fact withdrawn with the reason)",
+    "ui.sync.do.pick": "only when you pick it (--only)",
+    "ui.sync.do.report": "nothing changes — tell the agent what you meant",
+    "ui.sync.edits": "Your edits to facts a record proves: {mode} (strom config set sync.edits conflict|user)",
+    "ui.sync.mode.conflict": "a conflict for you to decide",
+    "ui.sync.mode.user": "your edit wins",
+    "ui.sync.next": "To write it: strom sync {file} --apply · only some: --apply --only 1,3",
+    "ui.sync.done": "{n} change(s) from {file} written ({input}) — to take them back: strom sync undo {input}",
+    "ui.sync.undone": "Sync {input} taken back: {n} step(s).",
+    "ui.sync.wasundone": "Sync {input} was taken back already.",
+    "ui.sync.bridge.large": "the tree is too large to send — export it as GEDCOM and load it in the research (strom sync <file>)",
+    "ui.sync.bridge.other": "this tree is of another research",
+    "ui.sync.bridge.foreign": "this does not look like the research's family tree — export it and load it in the research as another family tree",
+    "ui.sync.bridge.empty": "the tree came empty or unreadable",
+    "ui.sync.wait": "The Strom app opens with this research — choose which tree to send, and confirm there. Waiting for it (at most {min} min; Ctrl+C stops) …",
+    "ui.sync.waited": "The Strom app did not send the tree within {min} min — try again: strom sync --app, or export it as GEDCOM: strom sync <file>",
+    "ui.sync.got": "The Strom app sent the tree.",
+    "ui.sync.nothing.unchanged": "The Strom app sends nothing: the tree has not changed since it was last loaded from the research.",
+    "ui.sync.nothing.cancelled": "Nothing was sent from the Strom app (cancelled there).",
+    "ui.sync.nothing.no-tree": "The Strom app has no tree of this research — open it there first (the Strom app item of the menu), or export the tree and load the file.",
+    "ui.sync.nosend": "This copy of the Strom app cannot send the tree yet (it comes with a newer version) — export it in the app as GEDCOM and load it: strom sync <file>",
+    "ui.sync.from": "From where?",
+    "ui.sync.from.app": "Straight from the Strom app (it sends the tree itself)",
+    "ui.sync.from.file": "From a file (.ged, .json)",
+    "ui.sync.again": "The research took this file in already ({input}) — once more: --again",
+    "ui.sync.source.app": "Edits in the Strom app ({file}, {day})",
+    "ui.sync.source.file": "Family tree {file} ({day})",
+    "ui.review.living": "{who}: most likely alive (born less than {years} years ago, no death recorded). The family knows more than the registers, and those of recent years are mostly closed. Review all the same?",
+    "ui.review.living.no": "Nothing added.",
+    "ui.review.unproven.none": "Everyone in the tree rests on a record of their own — or strom has nothing more to propose for those who do not (strom person list --unproven).",
+    "ui.review.unproven.left": "{n} more without a record of their own: strom review --unproven again takes the next ones once these are done",
+    "ui.review.unproven.left.human": "{n} more people wait without a record of their own — the next ones come when these are done.",
     "ui.review.would": "  would add: {level} · {what}",
     "ui.review.dry": "(dry run — nothing written)",
     "ui.review.covered": "  {name}: already covered by {task} ({state}) — {what}",
@@ -439,10 +506,19 @@ export const UI = {
     "ui.consent.remote": "Start the Claude Code sessions strom opens with Remote Control, so that you can follow and steer them from claude.ai or the Claude app on your phone?",
     "ui.consent.hook.on": "Let the hook “{name}” be told of everything saved into your researches? It is a program on this computer and does with it what it was written to do.",
     "ui.consent.hook.off": "Stop telling the hook “{name}” what is saved?",
-    "ui.menu.more": "Add to the research: material, a new direction, one person reviewed",
+    "ui.menu.more": "Add to the research: material, a new direction, one person reviewed, another family tree",
+    "ui.menu.more.app": "Add to the research: material, a new direction, one person reviewed, edits from the Strom app",
     "ui.more.title": "Add to the research",
     "ui.more.intake": "Material from the family: documents, photos, a family tree from another program, what you know",
     "ui.more.research": "A new direction: the ancestors or descendants of someone else, or one question",
+    "ui.more.sync": "Take in edits from the Strom app or another family tree (.ged, .json)",
+    "ui.more.sync.noapp": "Take in another family tree's changes (.ged, .json)",
+    "ui.sync.path.noapp": "Drag the family tree file (.ged or .json) here, or type its path (Enter or 0 goes back)",
+    "ui.sync.path": "Drag the file exported from the Strom app (.ged or .json) here, or type its path (Enter or 0 goes back)",
+    "ui.sync.how": "Write it into the research?",
+    "ui.sync.all": "Yes, everything as shown",
+    "ui.sync.some": "Only the ones I pick",
+    "ui.sync.app": "Open the research in the Strom app again (the Strom app item of the menu): it asks whether to update the tree — then it has your edits as the research took them.",
     "ui.intake.what": "What do you bring?",
     "ui.intake.files": "Files or a folder from this computer",
     "ui.intake.text": "What you know — names, dates, places, family memories",

package/dist/commands/browse.js

@@ -14,8 +14,9 @@ import { lacksImages } from "../core/queue.js";
 import { rankedQueue, waitingForUser } from "./tasks.js";
 /** Most rows a section of `recent` lists; the rest is counted. */
 const RECENT_ROWS = 15;
+/** A person as the user reads them, with the ID to name them by later ("strom review P0012", the agent). */
 function whoText(w) {
-    return w.years ? `${w.name} (${w.years})` : w.name;
+    return `${w.years ? `${w.name} (${w.years})` : w.name} [${w.id}]`;
 }
 /** The person asked for, else the main person of the tree. */
 function personOrMain(tree, ref) {
@@ -72,7 +73,7 @@ export function humanTask(tree, text, lang) {
         if (r.type === "session")
             return ui(lang, "ui.plan.session", { day: humanDay(r.started, lang) });
         if (r.type === "person")
-            return displayName(r);
+            return `${displayName(r)} [${r.id}]`;
         if (r.type === "family")
             return r.partners.map((x) => tree.get(x)).filter((x) => !!x).map(displayName).join(" & ") || id;
         return r.title;
@@ -192,7 +193,7 @@ register({
             `  ${t.state === "doing" ? ui(lang, "ui.plan.now") : `${++n}.`}`,
             `${truncate(humanTask(tree, t.what, lang), 110)}${lacksImages(tree, t) ? ui(lang, "ui.plan.images") : ""}`,
         ]);
-        const storyNames = [...new Set(stories.map((t) => tree.get(t.subject[0] ?? "")).filter((p) => !!p).map(displayName))];
+        const storyNames = [...new Set(stories.map((t) => tree.get(t.subject[0] ?? "")).filter((p) => !!p).map((p) => `${displayName(p)} [${p.id}]`))];
         const out = [ui(lang, "ui.plan.title", { name: tree.config.name })];
         if (!queue.length)
             out.push(`  ${ui(lang, "ui.plan.none")}`);

package/dist/commands/checks.js

@@ -5,6 +5,7 @@ import { register } from "../cli/registry.js";
 import { lines, table } from "../cli/format.js";
 import { check } from "../core/check.js";
 import { guard } from "../core/guard.js";
+import { unprovenPeople } from "../core/review.js";
 import { verifyFast, verifyFull } from "../core/integrity.js";
 import { createKey, verifyCommitSeal } from "../core/seal.js";
 import { NeedsConsentError, StromError } from "../core/errors.js";
@@ -23,7 +24,12 @@ register({
     tree: true,
     run(ctx) {
         const tree = ctx.tree();
-        return report([...verifyFull(tree).findings, ...check(tree), ...guard(tree)], "ok — data consistent, sealed, nothing lost");
+        const out = report([...verifyFull(tree).findings, ...check(tree), ...guard(tree)], "ok — data consistent, sealed, nothing lost");
+        // not an error — research to do: who rests on no record of their own
+        const unproven = unprovenPeople(tree).filter((u) => !u.living).length;
+        if (!unproven)
+            return out;
+        return { ...out, text: lines(out.text, `note: ${unproven} people rest on no record of their own → strom person list --unproven`), data: { ...out.data, unproven } };
     },
 }, {
     path: ["verify"],

package/dist/commands/guide.js

@@ -32,6 +32,12 @@ HARD RULES
    the research needs has none yet: build one first (strom connector new,
    its DISCOVERY.md) and tell the user in a sentence. The user saves images
    by hand only where the archive does not allow automation.
+8. Old handwriting is read by your strongest model — you, or a subagent on
+   that same model; never a faster, cheaper or "quick" pass. A name or place
+   the next search depends on is read again on a crop at full resolution
+   (strom media view … --crop) before it is recorded; unsure stays unsure.
+9. A find is told to the user only once it is recorded (the source with its
+   transcript, the facts citing it), and told from strom: strom person card.
 ${language}
 
 GETTING STARTED (once)
@@ -42,14 +48,20 @@ GETTING STARTED (once)
   strom intake --text "<what the user told you, in their words>"
   strom intake <file or folder>        documents, photos, a GEDCOM or Strom tree
 
-EVERY SESSION
-  strom session start                  the brief: task, what is known, method
-  … work; record every finding at once …
+THE WORK, STEP BY STEP (every agent — also one strom did not start: a
+conversation opened anywhere, a bot on its own server)
+  strom                                where things stand and the next step — run it before each step
+  strom session start                  the next task of the queue (or: strom session start T0003, the one
+                                       the user chose): its brief — the task, what is known, the method
+  … work on that task only; record every finding at once …
   strom task done T0001 --result "…"   a complete negative search is a result
-  strom session close --summary "…" --next "…"    (not finished: --continue)
-  in a conversation, the next task is best begun in a fresh context (Claude Code: /clear) —
-  suggest it to the user; many tasks waiting: the agent working on its own (strom run, the
-  user starts it from strom's menu), every task in a fresh session
+  strom session close --summary "…" --next "…"    (not finished: --continue) — it proposes the next tasks
+  then tell the user what was found (strom person card …) and what comes next (strom plan), and ask
+  before the next session. The next step is strom's queue: what the user wants instead becomes a
+  task first (strom task add …, or strom research new …) — never search outside a session and its task.
+  In a conversation the next task is best begun in a fresh context (Claude Code: /clear) — suggest
+  it to the user; many tasks waiting: the agent working on its own (strom run, the user starts it
+  from strom's menu), every task in a fresh session
 
 RECORDING
 A record (register entry, certificate) — the source first, then its facts:
@@ -124,6 +136,15 @@ ONE PERSON, LOOKED AT AGAIN (the user asks you to check or complete someone; a n
   diary say of them outside their data, entries whose images are here but were not read whole, facts
   resting on one reading, conflicts left open (--reread: a second reading with the model the user reads
   with now). Each task's brief lists its items. Tell the user how many and what they cost; they decide.
+  Several at once: strom review P… P… (one review). The people no record of their own proves (strom check
+  counts them): strom person list --unproven (how each stands; the living apart — no tasks for them);
+  strom review --unproven proposes their work a batch at a time — again for the next batch, nothing twice.
+THE STROM APP'S EDITS, ANOTHER FAMILY TREE (the user changed the tree in the Strom app, or brings a .ged/.json)
+  strom sync <file> shows what it would take: what the file adds, what the user changed since the research
+  gave it (_STROM_HEAD), what is no longer in it. Show the user the list; write it on their yes (--apply, some:
+  --only 1,3). Additions become leads; a change to a fact a record proves becomes a conflict (sync.edits: the
+  user's choice). A file of another research, or of few of our people, is refused; strom sync undo I… takes a
+  sync back. After it: the user opens the research in the Strom app again to have the tree updated.
 STORIES OF THE ANCESTORS (the setting stories — on by default; strom shows it)
   Once records tell a person's life (a baptism and more facts from records), strom proposes a narrate
   task: write the story for the family book — plain words, the research language, every statement on a

package/dist/commands/index.js

@@ -4,6 +4,7 @@ import "./start.js";
 import "./trees.js";
 import "./research.js";
 import "./intake.js";
+import "./sync.js";
 import "./tasks.js";
 import "./people.js";
 import "./batch.js";

package/dist/commands/intake.js

@@ -149,6 +149,9 @@ register({
                         report.push(`  ${input.id} tree: ${imported.persons} persons, ${imported.families} families, ${imported.events} facts as leads${imported.matched ? `, ${imported.matched} matched to existing` : ""}${imported.problems.length ? ` (${imported.problems.length} unreadable lines)` : ""}`);
                         if (imported.extended.length)
                             report.push(`  added to what we have (leads — check them): ${imported.extended.slice(0, 6).join(" · ")}${imported.extended.length > 6 ? " …" : ""}`);
+                        // the research's own tree coming back: sync sees what was changed in it too, not only what was added
+                        if (imported.matched && imported.matched >= imported.persons)
+                            report.push(`  it is this research's tree coming back: strom sync "${ctx.display(file)}" shows what was changed in it too`);
                         const system = `gedcom:${sha.slice(0, 12)}`;
                         const dupes = likelyDuplicates(tree, tree.list("person").filter((p) => p.refs?.some((r) => r.system === system)).map((p) => p.id));
                         if (dupes.length)

package/dist/commands/people.js

@@ -9,6 +9,7 @@ import { INFORMATION } from "../core/evidence.js";
 import { EVENT_KINDS, NAME_KINDS } from "../core/model.js";
 import { ancestorGenerations, displayName, familiesAsChild, familiesAsPartner, findPersons, formatName, label, lifespan, relationTo, resolvePerson, } from "../core/people.js";
 import { resolveResearch } from "./research.js";
+import { DEATH_AFTER_YEARS, unprovenPeople } from "../core/review.js";
 import { foldText } from "../core/text.js";
 function list(v) {
     if (v === undefined)
@@ -158,9 +159,10 @@ register({
     options: [
         { name: "research", type: "string", value: "<G…>", description: "only people in scope of this research, with generations" },
         { name: "generation", type: "string", value: "<n>", description: "only this generation (with --research)" },
+        { name: "unproven", type: "boolean", description: "only people no record of their own proves: how each stands, the records naming them, open tasks" },
         { name: "full", type: "boolean", description: "--json: whole records instead of one row each" },
     ],
-    examples: ["strom person list", "strom person list visek", "strom person list --research G0001 --generation 3"],
+    examples: ["strom person list", "strom person list visek", "strom person list --research G0001 --generation 3", "strom person list --unproven"],
     run(ctx, { args, opts }) {
         const tree = ctx.tree();
         let people = tree.list("person").filter((p) => !p.retracted);
@@ -175,6 +177,8 @@ register({
                 people = people.filter((p) => gens.get(p.id) === Number(opts.generation));
             people.sort((a, b) => gens.get(a.id) - gens.get(b.id) || a.id.localeCompare(b.id));
         }
+        if (opts.unproven)
+            return unprovenList(ctx, tree, people, gens);
         const page = paginate(people, ctx.limit, ctx.page);
         const rows = page.items.map((p) => [
             p.id,
@@ -662,3 +666,56 @@ register({
         return { text: written(tree), data: { event: e } };
     },
 });
+const UNPROVEN_KIND = { named: "named in a record", leads: "leads only", none: "no record" };
+/** The people no record of their own proves: how each stands, the records that name them, the tasks already on them. */
+function unprovenList(ctx, tree, people, gens) {
+    const among = new Set(people.map((p) => p.id));
+    const found = unprovenPeople(tree).filter((u) => among.has(u.person.id));
+    // the living come apart: the family's to tell, no research of the registers
+    const all = found.filter((u) => !u.living);
+    const living = found.filter((u) => u.living);
+    const open = tree.list("task").filter((t) => ["open", "doing", "parked", "waiting"].includes(t.state));
+    const tasksOf = (id) => open.filter((t) => t.subject.includes(id)).map((t) => t.id);
+    const counts = { named: 0, leads: 0, none: 0 };
+    for (const u of all)
+        counts[u.kind]++;
+    const page = paginate(all, ctx.limit, ctx.page);
+    const rows = page.items.map((u) => {
+        const tasks = tasksOf(u.person.id);
+        return [
+            u.person.id,
+            displayName(u.person),
+            lifespan(u.person),
+            gens ? `G${gens.get(u.person.id)}` : "",
+            UNPROVEN_KIND[u.kind] + (u.sources.length ? `: ${u.sources.slice(0, 3).join(" ")}${u.sources.length > 3 ? " …" : ""}` : ""),
+            u.kind === "none" && !u.person.notes.length ? "no note where from" : "",
+            tasks.length ? `tasks ${tasks.slice(0, 2).join(" ")}${tasks.length > 2 ? " …" : ""}` : "",
+        ];
+    });
+    const livingLine = living.length
+        ? `living, most likely (born less than ${DEATH_AFTER_YEARS} years ago, no death recorded) — not counted, no tasks: ${living.map((u) => `${u.person.id} ${displayName(u.person)}`).join(" · ")}`
+        : undefined;
+    const text = !all.length
+        ? lines("everyone rests on a record of their own", livingLine)
+        : lines(`${all.length} without a record of their own — named in a record: ${counts.named} · leads only: ${counts.leads} · no record: ${counts.none}`, table(rows), moreLine(page, "strom person list --unproven"), livingLine, "", "tasks for them: strom review --unproven (a batch at a time) · strom review P… P… (these) · strom review P… (one)");
+    return {
+        text,
+        data: {
+            total: page.total,
+            page: page.page,
+            pages: page.pages,
+            counts,
+            living: living.map((u) => u.person.id),
+            persons: page.items.map((u) => ({
+                id: u.person.id,
+                name: displayName(u.person),
+                lifespan: lifespan(u.person),
+                kind: u.kind,
+                sources: u.sources,
+                notes: u.person.notes.length,
+                tasks: tasksOf(u.person.id),
+                ...(gens ? { generation: gens.get(u.person.id) } : {}),
+            })),
+        },
+    };
+}

package/dist/commands/research.js

@@ -4,6 +4,7 @@ import { lines, table } from "../cli/format.js";
 import { addPerson, addResearch } from "../core/actions.js";
 import { applyFrontier, researchProposals } from "./session.js";
 import { frontier } from "../core/frontier.js";
+import { DEATH_AFTER_YEARS, livingBorn, unprovenPeople } from "../core/review.js";
 import { parkedWhy } from "./tasks.js";
 import { ui } from "../cli/ui.js";
 import { phrase } from "../core/phrases.js";
@@ -145,31 +146,57 @@ register({
         };
     },
 });
+/** People without a record in one review at a time. */
+export const UNPROVEN_BATCH = 10;
 register({
     path: ["review"],
-    summary: "Review one person: what the tree already says of them elsewhere, entries to read whole, facts to check — as tasks",
+    summary: "Review a person, several, or those no record proves: what the tree says of them elsewhere, entries to read, facts to check — as tasks",
     group: "research",
     tree: true,
     writes: true,
-    description: "Sends the research straight to one person. strom looks at what is recorded and proposes the work, at\n" +
-        "most one task of each kind: what records, notes and the diary say of them outside their data; entries whose\n" +
-        "images are here but were not read whole (transcript, godparents, witnesses, house); facts resting on one\n" +
-        "reading; conflicts left open; with --reread, a second reading of what only another model read — after the\n" +
-        "agent or the model changed. Birth, parents and the story come as in any research. Run again later: what a\n" +
-        "task took up is not proposed again. Nothing is deleted; corrections go through strom with their reasons.",
-    args: [{ name: "person", description: "whom (ID or name)", required: true }],
+    description: "Sends the research straight to one person — or to several named at once (one review for them all), or with\n" +
+        "--unproven to the people no record of their own proves (strom person list --unproven), a batch at a time: run\n" +
+        "it again for the next batch; who is proved leaves the review. strom looks at what is recorded and proposes\n" +
+        "the work, at most one task of each kind for a person: what records, notes and the diary say of them outside\n" +
+        "their data; entries whose images are here but were not read whole (transcript, godparents, witnesses,\n" +
+        "house); facts resting on one reading; conflicts left open; with --reread, a second reading of what only\n" +
+        "another model read — after the agent or the model changed. Birth, parents and the story come as in any\n" +
+        "research. Run again later: what a task took up, or a task open elsewhere covers, is not proposed again.\n" +
+        "Nothing is deleted; corrections go through strom with their reasons.",
+    args: [{ name: "person", description: "whom (ID or name); several: one review for them all; none with --unproven", variadic: true }],
     options: [
-        { name: "scope", type: "string", value: "<scope>", description: "person (default), family (with partners and children), line (with the ancestors)" },
+        { name: "scope", type: "string", value: "<scope>", description: "one person: person (default), family (with partners and children), line (with the ancestors)" },
+        { name: "unproven", type: "boolean", description: "the people no record of their own proves (strom person list --unproven), a batch at a time" },
+        { name: "max", type: "string", value: "<n>", description: `with --unproven: at most so many people in the batch (default ${UNPROVEN_BATCH})` },
+        { name: "living", type: "boolean", description: "review someone most likely alive (born less than 100 years ago) all the same — the user asked for it" },
         { name: "reread", type: "boolean", description: "also a second reading of what only another model read (the model you read with now: model.vision)" },
         { name: "model", type: "string", value: "<model>", description: "with --reread: this model instead of model.vision" },
     ],
-    examples: ["strom review P0001", 'strom review "Josef Novák" --scope family', "strom review P0001 --reread", "strom review P0001 --dry-run"],
-    run(ctx, { args, opts }) {
+    examples: [
+        "strom review P0001",
+        'strom review "Josef Novák" --scope family',
+        "strom review P0001 P0002",
+        "strom review --unproven",
+        "strom review P0001 --reread",
+        "strom review P0001 --dry-run",
+    ],
+    async run(ctx, { args, opts }) {
         const tree = ctx.tree();
-        const p = resolvePerson(tree, args[0]);
+        const unproven = !!opts.unproven;
+        if (unproven && args.length)
+            throw new UsageError("--unproven reviews the people without a record — no person with it", { hint: "strom review --unproven · or strom review <person>" });
+        if (!unproven && !args.length)
+            throw new UsageError("whom? a person, several, or --unproven", { hint: "strom review P0001 · strom review P0001 P0002 · strom review --unproven" });
+        if (!unproven && opts.max !== undefined)
+            throw new UsageError("--max goes with --unproven");
+        if ((unproven || args.length > 1) && opts.scope !== undefined)
+            throw new UsageError("--scope is for one person's review");
         const scope = opts.scope ?? "person";
         if (!REVIEW_SCOPES.includes(scope))
             throw new UsageError(`--scope must be one of ${REVIEW_SCOPES.join(", ")}`);
+        const max = int(opts.max, "max") ?? UNPROVEN_BATCH;
+        if (max < 1)
+            throw new UsageError("--max must be 1 or more");
         let reread;
         if (opts.reread) {
             reread = opts.model ?? ctx.settings.models(ctx.settings.agent(tree.config).value, tree.config).vision;
@@ -178,26 +205,61 @@ register({
         }
         else if (opts.model)
             throw new UsageError("--model goes with --reread");
-        const review = { scope: scope, ...(reread ? { reread } : {}) };
         const lang = tree.lang;
-        // one review research per person: again later, it goes on where it was
-        const existing = tree.list("research").find((r) => r.direction === "person" && r.focus === p.id && r.review);
+        const chosen = [...new Map(args.map((a) => resolvePerson(tree, a)).map((x) => [x.id, x])).values()];
+        // the living are the family's to tell: reviewed only when the person says so
+        const living = chosen.map((x) => ({ x, born: livingBorn(tree, x) })).filter((l) => l.born !== undefined);
+        if (living.length && !opts.living && !ctx.yes && !tree.dryRun) {
+            const who = living.map((l) => `${label(l.x)}`).join(", ");
+            if (ctx.interactive && !isAgent(ctx.env)) {
+                if (!(await ctx.confirm(ui(lang, "ui.review.living", { who, years: DEATH_AFTER_YEARS }), false)))
+                    return { text: ui(lang, "ui.review.living.no"), data: { research: null, created: [], planned: [], open: [], living: living.map((l) => l.x.id) } };
+            }
+            else
+                throw new UsageError(`most likely alive (born less than ${DEATH_AFTER_YEARS} years ago, no death recorded): ${who}`, {
+                    hint: `ask the user whether to review them all the same; if yes: strom review ${args.join(" ")} --living`,
+                });
+        }
+        const p = chosen.length === 1 ? chosen[0] : undefined;
+        const several = chosen.length > 1;
+        const sameSet = (ids) => !!ids && ids.length === chosen.length && chosen.every((x) => ids.includes(x.id));
+        // one review research per person, per set of people, one of the people without a record: again later, it goes on where it was
+        const existing = tree
+            .list("research")
+            .find((r) => r.direction === "person" &&
+            r.review &&
+            (unproven ? !!r.review.unproven : several ? !r.review.unproven && sameSet(r.review.people) : !r.review.people && r.focus === p.id));
+        let review = { scope: scope, ...(reread ? { reread } : {}) };
+        let left = 0;
+        if (unproven) {
+            const batch = unprovenBatch(tree, existing, max, review);
+            if (!batch.people.length)
+                return { text: ui(lang, "ui.review.unproven.none"), data: { research: existing ?? null, created: [], planned: [], open: [] } };
+            review = { ...review, people: batch.people, unproven: true };
+            left = batch.left;
+        }
+        else if (several)
+            review = { ...review, people: chosen.map((x) => x.id) };
+        const names = chosen.map((x) => displayName(x));
+        const name = unproven ? phrase(lang, "review.unproven.research") : names.length > 3 ? `${names.slice(0, 3).join(", ")} +${names.length - 3}` : names.join(", ");
+        const focus = p?.id ?? review.people[0];
         // What it would propose, asked before anything is written: with nothing to do, no research is made for it.
         const draft = existing
-            ? { ...existing, state: "active", review }
-            : { id: "G?", type: "research", name: phrase(lang, "review.research", { name: displayName(p) }), focus: p.id, direction: "person", state: "active", review, notes: [] };
+            ? { ...existing, focus, state: "active", review }
+            : { id: "G?", type: "research", name: unproven ? name : phrase(lang, "review.research", { name }), focus, direction: "person", state: "active", review, notes: [] };
         const planned = researchProposals(tree, draft).map((x) => x.proposal);
         let research = draft;
         let tasks = [];
+        const what = unproven ? `${review.people.length} without a record of their own` : several ? review.people.join(" ") : scope;
         if (planned.length && !tree.dryRun) {
             if (existing)
-                research = update(tree, existing.id, "research", (r) => ({ ...r, state: "active", review }), {
+                research = update(tree, existing.id, "research", (r) => ({ ...r, focus, state: "active", review }), {
                     op: "research.edit",
-                    summary: `${existing.id} review again: ${scope}${reread ? `, second reading with ${reread}` : ""}`,
+                    summary: `${existing.id} review again: ${what}${reread ? `, second reading with ${reread}` : ""}`,
                 });
             else {
-                const r = addResearch(tree, { name: draft.name, focus: p.id, direction: "person" });
-                research = update(tree, r.id, "research", (x) => ({ ...x, review }), { op: "research.edit", summary: `${r.id} review: ${scope}${reread ? `, second reading with ${reread}` : ""}` });
+                const r = addResearch(tree, { name: draft.name, focus, direction: "person" });
+                research = update(tree, r.id, "research", (x) => ({ ...x, review }), { op: "research.edit", summary: `${r.id} review: ${what}${reread ? `, second reading with ${reread}` : ""}` });
             }
             tasks = applyFrontier(tree, research)
                 .map((id) => tree.get(id))
@@ -219,12 +281,39 @@ register({
         // Nothing new: why — the work that covers them already (a parked task says how to go on), a search done in vain.
         const why = list.length ? [] : coveredLines(tree, draft, lang, human);
         const inReview = existing ?? (planned.length && !tree.dryRun ? research : undefined);
-        const text = lines(...(human ? [] : tree.written.map((o) => o.summary)), tree.dryRun ? ui(lang, "ui.review.dry") : undefined, (tree.written.length && !human) || tree.dryRun ? "" : undefined, list.length ? ui(lang, "ui.review.new", { name: label(p), n: list.length }) : ui(lang, "ui.review.nothing", { name: label(p) }), ...list, ...why, open.length || tasks.length
+        const text = lines(...(human ? [] : tree.written.map((o) => o.summary)), tree.dryRun ? ui(lang, "ui.review.dry") : undefined, (tree.written.length && !human) || tree.dryRun ? "" : undefined, list.length ? ui(lang, "ui.review.new", { name: p ? label(p) : name, n: list.length }) : ui(lang, "ui.review.nothing", { name: p ? label(p) : name }), ...list, ...why, open.length || tasks.length
             ? ui(lang, "ui.review.open", { n: open.length || tasks.length, research: inReview.id }) + (avg !== undefined ? ui(lang, "ui.review.cost", { cost: avg.toFixed(2) }) : "")
-            : undefined, (open.length || tasks.length) && inReview ? ui(lang, human ? "ui.review.next.human" : "ui.review.next", { research: inReview.id }) : undefined);
-        return { text, data: { research: inReview ?? null, created: tasks, planned, open: open.map((t) => t.id), ...(why.length ? { why } : {}), ...(avg !== undefined ? { avgCostUsd: avg } : {}) } };
+            : undefined, (open.length || tasks.length) && inReview ? ui(lang, human ? "ui.review.next.human" : "ui.review.next", { research: inReview.id }) : undefined, left ? ui(lang, human ? "ui.review.unproven.left.human" : "ui.review.unproven.left", { n: left }) : undefined);
+        return {
+            text,
+            data: { research: inReview ?? null, created: tasks, planned, open: open.map((t) => t.id), ...(unproven ? { people: review.people, left } : {}), ...(why.length ? { why } : {}), ...(avg !== undefined ? { avgCostUsd: avg } : {}) },
+        };
     },
 });
+const OPEN_TASK = new Set(["open", "doing", "parked", "waiting"]);
+/**
+ * The next batch of people without a record of their own: those whose tasks of the review are still open stay;
+ * then the ones strom has work for — a record naming them first (the quickest to prove), then leads, then
+ * nothing — those never in a batch before those tried already. How many more wait besides.
+ */
+function unprovenBatch(tree, existing, max, review) {
+    // the living are the family's to tell: no research of the registers for them
+    const all = unprovenPeople(tree).filter((u) => !u.living);
+    const tasks = existing ? tree.list("task").filter((t) => t.research === existing.id) : [];
+    const busy = (id) => tasks.some((t) => t.subject.includes(id) && OPEN_TASK.has(t.state));
+    const keep = all.filter((u) => busy(u.person.id)).map((u) => u.person.id);
+    const before = new Set(existing?.review?.people ?? []);
+    const order = { named: 0, leads: 1, none: 2 };
+    const rest = all
+        .filter((u) => !keep.includes(u.person.id))
+        .sort((a, b) => Number(before.has(a.person.id)) - Number(before.has(b.person.id)) || order[a.kind] - order[b.kind] || a.person.id.localeCompare(b.person.id));
+    // only those strom has work for: what it would propose for all of them, asked once
+    const draft = { ...(existing ?? { id: "G?", type: "research", name: "", direction: "person", state: "active", notes: [] }), review: { ...review, people: rest.map((u) => u.person.id), unproven: true } };
+    const planned = researchProposals(tree, { ...draft, focus: rest[0]?.person.id ?? "" }).map((x) => x.proposal);
+    const workable = rest.filter((u) => planned.some((x) => x.subject.includes(u.person.id))).map((u) => u.person.id);
+    const people = [...keep, ...workable].slice(0, Math.max(max, keep.length));
+    return { people, left: all.length - people.length };
+}
 /** Why a review found nothing new, person by person: the work that covers them already, or a search done in vain. */
 function coveredLines(tree, research, lang, human = false) {
     const out = [];