strom-research 1.16.0 → 1.17.0-beta.3

package/CHANGELOG.cs.md

@@ -5,6 +5,17 @@
 Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou na
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (anglicky).
 
+## 1.17.0
+
+*Připravuje se: bety do 1.17.0-beta.3. Oddíl bude úplný s vydáním.*
+
+- **Nejdřív, co by hypotézy spojovaly.** Úkoly doplnit, co by spojovaly verze otevřené hypotézy, jdou ve frontě
+  první — i ve stávajícím výzkumu po aktualizaci —, takže aplikace Strom brzy ukáže tyto vazby.
+- **Přerušené stahování se ohlásí a uklidí.** Stahování, jehož proces skončil uprostřed, se ohlásí jako přerušené,
+  s tím, co se uložilo a co chybí; jeho pracovní složka se uklidí.
+- **Nový materiál v jazyce výzkumu.** Co přišlo (zaregistrovaný materiál, co přibylo, pravděpodobné duplicity,
+  jména po sňatku, úkoly), se vypíše v jazyce výzkumu.
+
 ## 1.16.0
 
 *17. 10. 2026 · patří k aplikaci Strom 3.13.0.*

package/CHANGELOG.de.md

@@ -5,6 +5,18 @@
 Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Installationszeilen stehen bei
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (auf Englisch).
 
+## 1.17.0
+
+*In Vorbereitung: die Betas bis 1.17.0-beta.3. Der Abschnitt ist mit dem Release vollständig.*
+
+- **Zuerst, was Hypothesen verbinden würden.** Die Aufgaben, zu ergänzen, was die Varianten einer offenen Hypothese
+  verbinden würden, kommen in der Warteschlange zuerst — auch in einer bestehenden Forschung nach dem Update —, so
+  zeigt die Strom-App diese Verbindungen bald.
+- **Ein unterbrochener Download wird gemeldet und aufgeräumt.** Ein Download, dessen Prozess mittendrin endete, wird
+  als unterbrochen gemeldet, mit dem, was gespeichert ist und was fehlt; sein Arbeitsordner wird entfernt.
+- **Neues Material in der Sprache der Forschung.** Was hereinkam (registriertes Material, was hinzukam, wahrscheinliche
+  Duplikate, Namen nach der Heirat, Aufgaben), wird in der Sprache der Forschung gesagt.
+
 ## 1.16.0
 
 *17.10.2026 · gehört zur Strom-App 3.13.0.*

package/CHANGELOG.md

@@ -5,6 +5,18 @@ English · [Čeština](CHANGELOG.cs.md) · [Deutsch](CHANGELOG.de.md)
 The changes of each version in short. The full notes and the install lines are on
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases).
 
+## 1.17.0
+
+*In preparation: the betas up to 1.17.0-beta.3. The section is complete with the release.*
+
+- **What hypotheses would connect, first.** The tasks to fill in what the variants of an open hypothesis would
+  connect go first in the queue — also in an existing research after the update — so the Strom app can show those
+  links soon.
+- **An interrupted download is said and tidied.** A download whose process ended midway is reported as interrupted,
+  with what was saved and what is missing; its work folder is cleared away.
+- **New material reported in the research's language.** What came in (registered material, what was added, likely
+  duplicates, married names, tasks) is said in the language of the research.
+
 ## 1.16.0
 
 *2026-10-17 · goes with the Strom app 3.13.0.*

package/assets/lang/cs.json

@@ -1549,6 +1549,13 @@
   "ui.intake.tree.matched": " – už ve výzkumu: {n}",
   "ui.intake.tree.back": "Je to rodokmen tohoto výzkumu, který se vrací: strom sync \"{file}\" ukáže i to, co se v něm změnilo.",
   "ui.intake.same": "Už tu bylo dřív: {n}.",
+  "ui.intake.registered": "✓ Podklady zaevidované ve výzkumu: {n}.",
+  "ui.intake.tree.unreadable": " · nečitelné řádky: {n}",
+  "ui.intake.extended": "Doplněno k tomu, co výzkum má (vodítka, k ověření): {list}",
+  "ui.intake.dupes": "Nejspíš už v rodokmenu: {list} (vypíše je úkol kontroly)",
+  "ui.intake.married": "{id}: příjmení po sňatku, která uvádí a která se při převzetí vynechala: {n} → strom input names {id}",
+  "ui.intake.tasks": "Úkoly k rozebrání podkladů: {n} → strom task next",
+  "ui.intake.handed": "{task} dostal {inputs} a je zpět ve frontě – soubor se přečte jako jeho další krok (bez vlastního úkolu k rozebrání).",
   "ui.intake.chat": "Projít to s agentem hned?",
   "ui.intake.say": "Do výzkumu jsem přidal(a) nové podklady – pojďme je projít.",
   "ui.research.kind": "Co zkoumat?",
@@ -1944,6 +1951,7 @@
   "ui.person.leadsonly": "jen vodítka",
   "ui.person.events": "údaje: {n}",
   "ui.list.more": "… dalších {n}: {command}",
+  "ui.list.past": "(stránka {asked} není: poslední je {pages}, zobrazená výše)",
   "ui.error.archive": "Tento výzkum je Archiv Stromu: data přicházejí z aplikace Strom a nic se nezkoumá. Výzkum se zapíná v menu, první položka.",
   "ui.error.archive.hint": "nebo v terminálu: strom mode research",
   "ui.error.agent.missing": "Výzkum čeká na AI agenta ({name}), který na tomto počítači není: do té doby drží data z aplikace Strom jako Archiv Stromu. Agenta nainstalovat nebo vybrat jiného: menu, první položka.",

package/assets/lang/de.json

@@ -1549,6 +1549,13 @@
   "ui.intake.tree.matched": " – schon in der Forschung: {n}",
   "ui.intake.tree.back": "Es ist der Stammbaum dieser Forschung, der zurückkommt: strom sync \"{file}\" zeigt auch, was darin geändert wurde.",
   "ui.intake.same": "Schon vorher hier: {n}.",
+  "ui.intake.registered": "✓ Unterlagen in der Forschung erfasst: {n}.",
+  "ui.intake.tree.unreadable": " · unlesbare Zeilen: {n}",
+  "ui.intake.extended": "Ergänzt zu dem, was die Forschung hat (Hinweise, zu prüfen): {list}",
+  "ui.intake.dupes": "Wahrscheinlich schon im Stammbaum: {list} (die Prüfaufgabe listet sie auf)",
+  "ui.intake.married": "{id}: Ehenamen, die sie nennt und die bei der Übernahme ausgelassen wurden: {n} → strom input names {id}",
+  "ui.intake.tasks": "Aufgaben zum Auswerten der Unterlagen: {n} → strom task next",
+  "ui.intake.handed": "{task} hat {inputs} bekommen und ist wieder in der Warteschlange – die Datei wird als nächster Schritt gelesen (keine eigene Aufgabe zum Auswerten).",
   "ui.intake.chat": "Jetzt mit dem Agenten durchgehen?",
   "ui.intake.say": "Ich habe der Forschung neue Unterlagen hinzugefügt – gehen wir sie durch.",
   "ui.research.kind": "Was soll erforscht werden?",
@@ -1944,6 +1951,7 @@
   "ui.person.leadsonly": "nur Hinweise",
   "ui.person.events": "Angaben: {n}",
   "ui.list.more": "… {n} weitere: {command}",
+  "ui.list.past": "(keine Seite {asked}: die letzte ist {pages}, oben gezeigt)",
   "ui.error.archive": "Diese Forschung ist ein Strom-Archiv: die Daten kommen aus der Strom-App, und nichts wird erforscht. Die Forschung wird im Menü eingeschaltet, erster Punkt.",
   "ui.error.archive.hint": "oder im Terminal: strom mode research",
   "ui.error.agent.missing": "Die Forschung wartet auf ihren KI-Agenten ({name}), der auf diesem Computer nicht ist: bis dahin bewahrt sie die Daten aus der Strom-App als Strom-Archiv. Den Agenten installieren oder einen anderen wählen: das Menü, erster Punkt.",

package/dist/brief/brief.js

@@ -39,7 +39,7 @@ import { ENRICH_PAGES, STORY_SOURCES_ORIGIN } from "../core/stories.js";
 import { sandboxOf, WITHOUT_READERS } from "../core/sandbox.js";
 import { WEB_SOFT } from "../core/metrics.js";
 import { indexBriefLines } from "../core/indexfirst.js";
-import { activeFetches, endedFetches } from "../core/fetching.js";
+import { activeFetches, endedFetches, withRegistered } from "../core/fetching.js";
 /** The hosts of a connector, as its manifest names them (a wildcard without its star). */
 function connectorHosts(shared, name) {
     try {
@@ -628,13 +628,19 @@ function imagesLines(tree, b, route, shape, finder, noSharper = false, waiting)
                         : ""),
     ].filter(Boolean);
 }
-/** The fetches at work for the research (each book: how far), and those in the background that ended lately with images left. */
-function fetchingLines(root) {
+/** The fetches at work for the research (each book: how far), and those that ended lately with images left (in the background, or interrupted). */
+function fetchingLines(tree) {
+    const root = tree.root;
     const active = activeFetches(root);
+    // an interrupted one: what it registered as the research has it
+    const has = (rs) => new Set(tree.list("media").filter((m) => m.recordset === rs && !m.part && !m.retracted && m.image !== undefined).map((m) => m.image));
     const out = active.map((m) => `- ${m.recordset}: ${m.registered}/${m.images.length} images registered (${m.background ? `in the background${m.task ? `, for ${m.task}` : ""}` : "in the foreground"}) — strom read ${m.recordset} --images ${runsArg(m.images)} reads them as they come; not fetched again`);
-    for (const e of endedFetches(root))
+    for (const e of endedFetches(root).map((x) => withRegistered(x, has(x.recordset))))
         if (e.missed.length && !active.some((m) => m.recordset === e.recordset))
-            out.push(`- ${e.recordset}: a fetch in the background ended with images ${runs(e.missed)} not fetched${e.stopped ? ` (stopped: ${e.stopped})` : ""} — strom fetch ${e.connector} ${shellArg(e.book)} --images ${runsArg(e.missed)} --recordset ${e.recordset} if they are needed`);
+            out.push(e.interrupted
+                ? // its process ended without a word (killed, the computer stopped): what it registered stays
+                    `- ${e.recordset}: a fetch ${e.background ? "in the background" : "in the foreground"} was interrupted (${e.interrupted === "gone" ? "its process ended without a word" : "nothing heard of it for long"}) with images ${runs(e.missed)} not fetched — strom fetch ${e.connector} ${shellArg(e.book)} --images ${runsArg(e.missed)} --recordset ${e.recordset}${e.background ? " --background" : ""} if they are needed (what is registered is not fetched again)`
+                : `- ${e.recordset}: a fetch in the background ended with images ${runs(e.missed)} not fetched${e.stopped ? ` (stopped: ${e.stopped})` : ""} — strom fetch ${e.connector} ${shellArg(e.book)} --images ${runsArg(e.missed)} --recordset ${e.recordset} if they are needed`);
     return out;
 }
 /** What the user put in the shared inbox, waiting to be registered — by folder (one download each). */
@@ -1209,7 +1215,7 @@ export function buildBrief(tree, opts) {
         });
     // 7c. images being fetched for the research now (strom fetch --background of an earlier session, or another strom),
     // and what fetches in the background left unfetched lately: read as they come, never fetched twice
-    const fetching = fetchingLines(tree.root);
+    const fetching = fetchingLines(tree);
     if (fetching.length)
         sections.push({
             name: "fetching",

package/dist/cli/commit.js

@@ -4,6 +4,7 @@ import { hasErrors } from "../core/check.js";
 import { guard } from "../core/guard.js";
 import { snapshot, verifyFast } from "../core/integrity.js";
 import { isArchive } from "../core/mode.js";
+import { counted } from "./format.js";
 export function commitMessage(summaries, command) {
     const unique = [...new Set(summaries)];
     const subject = unique.length === 1 ? unique[0] : `${command}: ${unique.length} changes`;
@@ -17,34 +18,43 @@ export function autoCommit(ctx, def) {
     const ops = tree?.uncommitted() ?? [];
     if (!tree || tree.dryRun || ops.length === 0)
         return undefined;
-    // Incremental gate: records were validated when written; here only what
-    // changed since the last commit is checked, so the cost stays flat.
-    const snap = snapshot(tree);
-    const findings = [...verifyFast(tree, snap).findings, ...guard(tree, snap)];
-    if (hasErrors(findings)) {
-        const errors = findings.filter((f) => f.level === "error");
-        return {
-            message: [
-                `error: written but NOT committed — ${errors.length} problem(s) in the data:`,
-                ...errors.slice(0, 5).map((f) => `  ${f.id ?? f.file ?? ""} ${f.message}`),
-                "→ strom check",
-            ].join("\n"),
-            problems: errors.map((f) => ({ ...(f.id ? { id: f.id } : {}), ...(f.file ? { file: f.file } : {}), message: f.message })),
-        };
-    }
-    const message = commitMessage(ops.map((o) => o.summary), `strom ${def.path.join(" ")}`);
-    // Only the files this command wrote, plus the free-form folders the agent
-    // may edit — `git add` then never has to scan the whole data/ tree.
-    const written = new Set(["data/_counters.json"]);
-    for (const op of ops)
-        for (const f of op.files)
-            written.add(f.path);
-    for (const f of tree.opsFilesTouched())
-        written.add(f);
-    // an archive: no agent edits its free-form folders — a person's own file in notes/ is theirs, never swept into a
-    // commit of something else (found on Windows: strom mode committed a file of the user's) — nor by the switch itself
-    const free = isArchive(tree) || def.path[0] === "mode" ? ["inputs", "output"] : ["notes", "tools", "inputs", "output"];
-    tree.withTreeLock(() => tree.commit(message, [...written, ...free]));
+    // The check and the commit under one hold of the tree (a command that locks only while it writes reaches here
+    // without it): another strom in the middle of its commit — staged, its log not yet in HEAD — would otherwise be seen
+    // half done, its records as edited outside strom (found: a fetch in the foreground ending while one in the
+    // background committed its last batch).
+    const blocked = tree.withTreeLock(() => {
+        // Incremental gate: records were validated when written; here only what
+        // changed since the last commit is checked, so the cost stays flat.
+        const snap = snapshot(tree);
+        const findings = [...verifyFast(tree, snap).findings, ...guard(tree, snap)];
+        if (hasErrors(findings)) {
+            const errors = findings.filter((f) => f.level === "error");
+            return {
+                message: [
+                    `error: written but NOT committed — ${counted(errors.length, "problem")} in the data:`,
+                    ...errors.slice(0, 5).map((f) => `  ${f.id ?? f.file ?? ""} ${f.message}`),
+                    "→ strom check",
+                ].join("\n"),
+                problems: errors.map((f) => ({ ...(f.id ? { id: f.id } : {}), ...(f.file ? { file: f.file } : {}), message: f.message })),
+            };
+        }
+        const message = commitMessage(ops.map((o) => o.summary), `strom ${def.path.join(" ")}`);
+        // Only the files this command wrote, plus the free-form folders the agent
+        // may edit — `git add` then never has to scan the whole data/ tree.
+        const written = new Set(["data/_counters.json"]);
+        for (const op of ops)
+            for (const f of op.files)
+                written.add(f.path);
+        for (const f of tree.opsFilesTouched())
+            written.add(f);
+        // an archive: no agent edits its free-form folders — a person's own file in notes/ is theirs, never swept into a
+        // commit of something else (found on Windows: strom mode committed a file of the user's) — nor by the switch itself
+        const free = isArchive(tree) || def.path[0] === "mode" ? ["inputs", "output"] : ["notes", "tools", "inputs", "output"];
+        tree.commit(message, [...written, ...free]);
+        return undefined;
+    });
+    if (blocked)
+        return blocked;
     tree.markCommitted();
     tree.settle();
     return undefined;

package/dist/cli/context.js

@@ -19,6 +19,7 @@ import { isAgent } from "../core/which.js";
 import { treeAgentHere } from "../core/state.js";
 import { canShowDialog, systemDialog, WAIT_SECONDS } from "../core/dialog.js";
 import { UI, ui } from "./ui.js";
+import { DEFAULT_LIMIT } from "./format.js";
 export class Context {
     env;
     cwd;
@@ -46,7 +47,7 @@ export class Context {
         this.json = opts.json;
         this.yes = opts.yes;
         this.treeFlag = opts.tree;
-        this.limit = opts.limit ?? 50;
+        this.limit = opts.limit ?? DEFAULT_LIMIT;
         this.page = opts.page ?? 1;
     }
     /** A context from parsed command-line values (global options and settings flags). */

package/dist/cli/format.js

@@ -16,10 +16,12 @@ export function table(rows, opts = {}) {
         .trimEnd())
         .join("\n");
 }
+/** The rows of a page when --limit is not given. */
+export const DEFAULT_LIMIT = 50;
 export function paginate(items, limit, page) {
     const pages = Math.max(1, Math.ceil(items.length / limit));
     const p = Math.min(Math.max(1, page), pages);
-    return { items: items.slice((p - 1) * limit, p * limit), total: items.length, page: p, pages, limit };
+    return { items: items.slice((p - 1) * limit, p * limit), total: items.length, page: p, pages, limit, ...(page > pages && items.length ? { asked: page } : {}) };
 }
 /**
  * The most rows a page of a long listing gives, whatever --limit says: a row is at most ~170 bytes, a page under ~20 kB
@@ -28,10 +30,14 @@ export function paginate(items, limit, page) {
 export const LIST_PAGE_MAX = 100;
 /** Footer telling the caller how to see more — in the research's language where the listing is (lang), else English. */
 export function moreLine(page, command, lang) {
+    // a page past the last: the last one shown, and said so (found on Windows: --page 99 gave the last page silently)
+    if (page.asked)
+        return lang ? ui(lang, "ui.list.past", { asked: String(page.asked), pages: String(page.pages) }) : `(no page ${page.asked}: the last is ${page.pages}, shown above)`;
     if (page.page >= page.pages)
         return "";
     const left = page.total - page.page * page.limit;
-    const next = `${command} --page ${page.page + 1}`;
+    // the next page of the same size: a --limit of its own goes along (found on Windows: --page 2 alone took 50 rows)
+    const next = `${command}${page.limit !== DEFAULT_LIMIT ? ` --limit ${page.limit}` : ""} --page ${page.page + 1}`;
     return lang ? ui(lang, "ui.list.more", { n: String(left), command: next }) : `… ${left} more: ${next}`;
 }
 export function truncate(text, max) {

package/dist/cli/main.js

@@ -16,7 +16,7 @@ import { assertIntact } from "../core/integrity.js";
 import { resetCache } from "../core/git.js";
 import { newerTree, Tree, VERSION } from "../core/tree.js";
 import { settleArchive } from "../core/mode.js";
-import { settleHypothesisLinks } from "../core/hypolinks.js";
+import { raiseHypothesisLinkTasks, settleHypothesisLinks } from "../core/hypolinks.js";
 import { liveRunning, reviveLive, startLive } from "../core/live.js";
 import { fireHooks, HOOK_INTERFACE } from "../core/hooks.js";
 import { prependPath } from "../runners/runner.js";
@@ -314,7 +314,14 @@ export async function main(argv, io, env, cwd) {
                 catch {
                     // another computer's seal, a tree at work: its next bridge or switch settles it
                 }
-                // …and older hypotheses get the links of their variants their claims say beyond doubt, the rest a task (once)
+                // …and the tasks an older strom made to say those links come first in the queue (once), then older hypotheses get
+                // the links of their variants their claims say beyond doubt, the rest a task (once)
+                try {
+                    raiseHypothesisLinkTasks(Tree.open(k.root, env));
+                }
+                catch {
+                    // another computer's seal, a tree at work: its bridge's start raises them
+                }
                 try {
                     settleHypothesisLinks(Tree.open(k.root, env));
                 }

package/dist/cli/ui.js

@@ -1462,6 +1462,13 @@ export const UI = {
     "ui.intake.tree.matched": " – already in the research: {n}",
     "ui.intake.tree.back": "It is this research's own family tree coming back: strom sync \"{file}\" shows what was changed in it too.",
     "ui.intake.same": "Already here before: {n}.",
+    "ui.intake.registered": "✓ Material registered in the research: {n}.",
+    "ui.intake.tree.unreadable": " · unreadable lines: {n}",
+    "ui.intake.extended": "Added to what the research has (leads, to be checked): {list}",
+    "ui.intake.dupes": "Probably in the tree already: {list} (the review task lists them)",
+    "ui.intake.married": "{id}: married names it gives, left out when it was imported: {n} → strom input names {id}",
+    "ui.intake.tasks": "Tasks to go through the material: {n} → strom task next",
+    "ui.intake.handed": "{task} got {inputs} and is back in the queue — the file is read as its next step (no task of its own to go through it).",
     "ui.intake.chat": "Go through it with the agent now?",
     "ui.intake.say": "I added new material to the research — let us go through it.",
     "ui.research.kind": "What should be found out?",
@@ -1748,6 +1755,7 @@ export const UI = {
     "ui.person.leadsonly": "leads only",
     "ui.person.events": "{n} ev",
     "ui.list.more": "… {n} more: {command}",
+    "ui.list.past": "(no page {asked}: the last is {pages}, shown above)",
     "ui.error.archive": "This research is a Strom archive: its data come from the Strom app and nothing is researched. Research is switched on in the menu, its first item.",
     "ui.error.archive.hint": "or in a terminal: strom mode research",
     "ui.error.agent.missing": "The research waits for its AI agent ({name}), which is not on this computer: until then it keeps the data from the Strom app as a Strom archive. Installing the agent or choosing another: the menu, its first item.",

package/dist/commands/analysis.js

@@ -1,7 +1,7 @@
 // search · searched · conflict · hypothesis · lesson · find · gaps
 import { register } from "../cli/registry.js";
 import { ui } from "../cli/ui.js";
-import { lines, moreLine, paginate, table, truncate } from "../cli/format.js";
+import { counted, lines, moreLine, paginate, table, truncate } from "../cli/format.js";
 import { UsageError } from "../core/errors.js";
 import { LESSON_DETAIL_MAX, LESSON_MAX, LESSON_SCOPES, RECORD_TYPES, SEARCH_METHODS, SEARCH_RESULTS, VARIANT_LINK_KINDS, } from "../core/model.js";
 import { create, csvOpt, listOpt, normId, requireRecord, update } from "../core/records.js";
@@ -19,6 +19,7 @@ import { childLink, LINK_HOW, linkHints, linkText, personsLink, recordedLinks, r
 import { yearsOption, yearsOverlap } from "../core/years.js";
 import { searchedAs } from "../core/evidence.js";
 import { refuseNegativeOverUnclear } from "./readings.js";
+import { hypothesisPeople } from "../core/directions.js";
 function written(tree) {
     return lines(...tree.written.map((o) => o.summary));
 }
@@ -72,6 +73,17 @@ function conflictConcerns(tree, id) {
         (c.edit !== undefined && (ids.has(c.edit.event) || (c.edit.cites ?? []).some((ci) => ids.has(ci.source)))) ||
         (c.parents !== undefined && [c.parents.child, c.parents.from, c.parents.to ?? "", ...c.parents.partners].some((s) => ids.has(s)));
 }
+/**
+ * Whether a hypothesis is about a person or family (strom hypothesis list --about): named in its subject, among the
+ * people it is about (hypothesisPeople: its subject's, those its variants would connect or name), or in what its
+ * variants' links have named; a person also through the families they are a partner of.
+ */
+function hypothesisConcerns(tree, id) {
+    const ids = new Set([id, ...(typeOfId(id) === "person" ? familiesAsPartner(tree, id).map((f) => f.id) : [])]);
+    return (h) => h.subject.some((s) => ids.has(s)) ||
+        hypothesisPeople(tree, h).some((p) => ids.has(p)) ||
+        h.variants.some((v) => (v.linked ?? []).some((x) => ids.has(x)) || (v.links ?? []).some((l) => l.kind === "child" && l.family !== undefined && ids.has(l.family)));
+}
 /** The tasks that work on a conflict or hypothesis (--about X…/H…). */
 function tasksAbout(tree, id) {
     return tree.list("task").filter((t) => t.subject.includes(id));
@@ -380,7 +392,7 @@ register({
         // a negative of an index is the index's: the book itself not searched in vain by it
         const ofIndex = hits.filter((s) => s.result === "negative" && s.method === "index").length;
         const text = hits.length
-            ? lines(`${hits.length} search(es) for ${what}${years ? ` in ${years}` : ""} — ${negative} negative${ofIndex ? ` (${ofIndex} in an index only — not the book searched in vain)` : ""}, ${hits.length - negative} with results`, table(hits.map(searchLine)))
+            ? lines(`${counted(hits.length, "search", "searches")} for ${what}${years ? ` in ${years}` : ""} — ${negative} negative${ofIndex ? ` (${ofIndex} in an index only — not the book searched in vain)` : ""}, ${hits.length - negative} with results`, table(hits.map(searchLine)))
             : `nothing searched yet for ${what}${years ? ` in ${years}` : ""}`;
         return { text: lines(text, ...said), data: { searches: hits } };
     },
@@ -753,21 +765,22 @@ register({
     options: [
         { name: "all", type: "boolean", description: "include decided and abandoned" },
         { name: "unlinked", type: "boolean", description: "only those no variant of which says what it would connect (strom hypothesis link), but those whose every variant naming people says what the tree records already" },
+        { name: "about", type: "string", value: "<P…|F…>", description: "only the hypotheses about this person or family: its subject, or the people and families its variants would connect" },
     ],
-    examples: ["strom hypothesis list", "strom hypothesis list --unlinked"],
+    examples: ["strom hypothesis list", "strom hypothesis list --unlinked", "strom hypothesis list --about P0001"],
     run(ctx, { opts }) {
         const tree = ctx.tree();
         // a hypothesis whose variants say only what the tree records already has nothing to link
         const linked = (h) => h.variants.some((v) => v.links?.length) || (h.variants.some((v) => recordedLinks(tree, h, v).length) && !h.variants.some((v) => toLink(tree, h, v)));
-        const all = tree.list("hypothesis").filter((h) => (opts.all || h.state === "open") && !(opts.unlinked && linked(h)));
+        const about = typeof opts.about === "string" ? anyRefs(tree, [opts.about])[0] : undefined;
+        const concerns = about ? hypothesisConcerns(tree, about) : undefined;
+        const all = tree.list("hypothesis").filter((h) => (opts.all || h.state === "open") && !(opts.unlinked && linked(h)) && (!concerns || concerns(h)));
         const links = (h) => h.variants.reduce((n, v) => n + (v.links?.length ?? 0), 0);
         return {
             text: all.length
                 ? table(all.map((h) => [h.id, h.state, truncate(h.question, 60), h.variants.map((v) => v.label).join("/"), links(h) ? `${links(h)} link${links(h) === 1 ? "" : "s"}` : ""]))
-                : opts.unlinked
-                    ? "no open hypothesis without links"
-                    : "no open hypotheses",
-            data: { hypotheses: all },
+                : `no ${opts.all ? "" : "open "}${opts.unlinked ? "hypothesis without links" : about ? "hypothesis" : "hypotheses"}${about ? ` about ${about} → all of them: strom hypothesis list${opts.all ? "" : " --all"}` : ""}`,
+            data: { ...(about ? { about } : {}), hypotheses: all },
         };
     },
 }, {

package/dist/commands/archives.js

@@ -6,7 +6,7 @@
 import path from "node:path";
 import { register } from "../cli/registry.js";
 import { ui } from "../cli/ui.js";
-import { lines, secondsIn, shellArg, table } from "../cli/format.js";
+import { counted, lines, secondsIn, shellArg, table } from "../cli/format.js";
 import { EXIT, StromError, UsageError } from "../core/errors.js";
 import { isAgent } from "../core/which.js";
 import { canShowDialog, systemChoice, WAIT_SECONDS } from "../core/dialog.js";
@@ -558,7 +558,7 @@ register({
             return { text: `${hosts.join(", ")}: kept as before — ${milder.map((p) => `${p.connector} ${p.from}`).join(", ")}`, data: { hosts, kept: kept.map((c) => c.name) } };
         }
         if (opts.accept) {
-            ctx.requireHuman(`Accept what ${connectors.map((c) => c.name).join(", ")} say(s) of ${hosts.join(", ")} now (${connectors.map((c) => claimOf(c)).join(", ")}), its pace too?`, `strom allow archive ${target} --accept`, `archive:accept:${hosts.join(",")}`, ui(lang, "ui.archive.accept", { names: connectors.map((c) => `${c.manifest.title} (${levelWords(lang, claimOf(c))})`).join(", ") }));
+            ctx.requireHuman(`Accept what ${connectors.map((c) => c.name).join(", ")} ${connectors.length === 1 ? "says" : "say"} of ${hosts.join(", ")} now (${connectors.map((c) => claimOf(c)).join(", ")}), its pace too?`, `strom allow archive ${target} --accept`, `archive:accept:${hosts.join(",")}`, ui(lang, "ui.archive.accept", { names: connectors.map((c) => `${c.manifest.title} (${levelWords(lang, claimOf(c))})`).join(", ") }));
             acceptConnectors(ctx.env, connectors);
             return { text: `${hosts.join(", ")}: the connectors' readings accepted — ${connectors.map((c) => `${c.name} ${claimOf(c)}`).join(", ")}`, data: { hosts, accepted: connectors.map((c) => c.name) } };
         }

package/dist/commands/batch.js

@@ -8,7 +8,7 @@
 // creates; later lines use it as "@name".
 import fs from "node:fs";
 import { register } from "../cli/registry.js";
-import { lines, table } from "../cli/format.js";
+import { counted, lines, table } from "../cli/format.js";
 import { AmbiguousError, StromError, UsageError } from "../core/errors.js";
 /** A label: a word in any script ("anna", "šimon", "otec_2"), its accents composed or not. */
 const LABEL = "[\\p{L}_][\\p{L}\\p{M}\\p{N}_-]*";
@@ -254,7 +254,7 @@ register({
             throw errors[0];
         if (errors.length)
             throw manyWrong(errors, batch.length);
-        const text = lines(table(report.flatMap((r) => r.summaries.map((s, i) => [i === 0 ? `${r.line}` : "", s, i === 0 && r.label ? `#${r.label}` : ""]))), `${report.length} command(s) as one change`);
+        const text = lines(table(report.flatMap((r) => r.summaries.map((s, i) => [i === 0 ? `${r.line}` : "", s, i === 0 && r.label ? `#${r.label}` : ""]))), `${counted(report.length, "command")} as one change`);
         return { text, data: { lines: report, labels: Object.fromEntries(labels) } };
     },
 });

package/dist/commands/checks.js

@@ -4,7 +4,7 @@ import { actsAsArchive } from "../core/state.js";
 import fs from "node:fs";
 import path from "node:path";
 import { register } from "../cli/registry.js";
-import { lines, table } from "../cli/format.js";
+import { counted, lines, table } from "../cli/format.js";
 import { check } from "../core/check.js";
 import { guard } from "../core/guard.js";
 import { unprovenPeople } from "../core/review.js";
@@ -21,7 +21,7 @@ export function report(findings, okText, lang) {
     const sum = { errors: errors.length, warnings: findings.length - errors.length };
     const text = findings.length === 0
         ? okText
-        : lines(table(findings.map((f) => [f.level === "error" ? "ERROR" : "warn", f.code, f.id ?? f.file ?? "", f.message, f.hint ? `→ ${f.hint}` : ""])), "", lang ? ui(lang, "ui.check.found", sum) : `${sum.errors} error(s), ${sum.warnings} warning(s)`);
+        : lines(table(findings.map((f) => [f.level === "error" ? "ERROR" : "warn", f.code, f.id ?? f.file ?? "", f.message, f.hint ? `→ ${f.hint}` : ""])), "", lang ? ui(lang, "ui.check.found", sum) : `${counted(sum.errors, "error")}, ${counted(sum.warnings, "warning")}`);
     return { text, data: { ok: errors.length === 0, findings }, exitCode: errors.length ? 1 : 0 };
 }
 register({
@@ -127,7 +127,7 @@ register({
         const after = verifyFast(tree).findings.filter((f) => f.level === "error");
         const text = r.restored.length + r.quarantined.length === 0
             ? "nothing to repair — every record matches its seal"
-            : lines(...r.restored.map((f) => `restored  ${f}`), ...r.quarantined.map((f) => `removed   ${f}`), `sealed state: ${r.from.slice(0, 8)} · copies of replaced files: .strom/quarantine/`, after.length ? `still ${after.length} problem(s) → strom verify` : undefined);
+            : lines(...r.restored.map((f) => `restored  ${f}`), ...r.quarantined.map((f) => `removed   ${f}`), `sealed state: ${r.from.slice(0, 8)} · copies of replaced files: .strom/quarantine/`, after.length ? `still ${counted(after.length, "problem")} → strom verify` : undefined);
         return { text, data: { ...r, ok: after.length === 0 }, exitCode: after.length ? 1 : 0 };
     },
 }, {

package/dist/commands/clips.js

@@ -6,7 +6,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { register } from "../cli/registry.js";
-import { lines, truncate } from "../cli/format.js";
+import { counted, lines, truncate } from "../cli/format.js";
 import { UsageError } from "../core/errors.js";
 import { normId, requireRecord, update } from "../core/records.js";
 import { makeView } from "../core/views.js";
@@ -90,10 +90,10 @@ register({
             throw new UsageError("--batch must be a positive number");
         const groups = batches(todo, size);
         if (!todo.length)
-            return { text: lines("nothing to do: every source on images has its clip", away.length ? `${away.length} source(s) on images not on this computer (or not JPEG/PNG)` : undefined), data: { sources: 0 } };
+            return { text: lines("nothing to do: every source on images has its clip", away.length ? `${counted(away.length, "source")} on images not on this computer (or not JPEG/PNG)` : undefined), data: { sources: 0 } };
         if (tree.dryRun)
             return {
-                text: lines(`${todo.length} source(s) to find on their images — ${groups.length} reader(s) to find them, as many to check`, away.length ? `${away.length} more on images not on this computer (or not JPEG/PNG)` : undefined, "(dry run — no reader started)"),
+                text: lines(`${counted(todo.length, "source")} to find on their images — ${counted(groups.length, "reader")} to find them, as many to check`, away.length ? `${away.length} more on images not on this computer (or not JPEG/PNG)` : undefined, "(dry run — no reader started)"),
                 data: { sources: todo.length, readers: groups.length, away: away.map((s) => s.id) },
             };
         const r0 = readers(ctx, tree, shared, "clips", "find", opts);
@@ -174,7 +174,7 @@ register({
         // a search over many entries, not one entry: no clip, and said so
         const many = [...new Set(locs.filter((l) => l.result === "many").map((l) => l.source))];
         const missed = todo.filter((s) => !clipsOf.has(s.id));
-        const text = lines(`${clipsOf.size} of ${todo.length} source(s) got their clip${model ? ` · ${model}` : ""}${r0.cost() ? ` · $${r0.cost().toFixed(2)}` : ""}`, many.length ? `not one entry but a search over many (no clip — a page of it would show nothing): ${many.join(", ")}` : undefined, rejected.length ? `the check turned down: ${rejected.map((v) => `${v.source} (${v.verdict}${v.why ? `: ${truncate(v.why, 40)}` : ""})`).join(", ")}` : undefined, missed.length ? `without a clip: ${missed.map((s) => s.id).slice(0, 20).join(", ")}${missed.length > 20 ? ` … (${missed.length})` : ""} — strom source edit S… --clip M…@x,y,w,h, or strom clips again` : undefined, away.length ? `on images not on this computer (or not JPEG/PNG): ${away.length}` : undefined, failed.length ? `readers that failed: ${failed.join(", ")}` : undefined, "the entries cut out for the Strom app: strom app (output/tree-strom.ged)");
+        const text = lines(`${clipsOf.size} of ${counted(todo.length, "source")} got their clip${model ? ` · ${model}` : ""}${r0.cost() ? ` · $${r0.cost().toFixed(2)}` : ""}`, many.length ? `not one entry but a search over many (no clip — a page of it would show nothing): ${many.join(", ")}` : undefined, rejected.length ? `the check turned down: ${rejected.map((v) => `${v.source} (${v.verdict}${v.why ? `: ${truncate(v.why, 40)}` : ""})`).join(", ")}` : undefined, missed.length ? `without a clip: ${missed.map((s) => s.id).slice(0, 20).join(", ")}${missed.length > 20 ? ` … (${missed.length})` : ""} — strom source edit S… --clip M…@x,y,w,h, or strom clips again` : undefined, away.length ? `on images not on this computer (or not JPEG/PNG): ${away.length}` : undefined, failed.length ? `readers that failed: ${failed.join(", ")}` : undefined, "the entries cut out for the Strom app: strom app (output/tree-strom.ged)");
         return {
             text,
             data: {