strom-research 1.4.1 → 1.6.0

package/dist/commands/links.js

@@ -0,0 +1,367 @@
+// strom-research:// links from the Strom app (core/links.ts): strom link open
+// is what the system runs for one; strom link on|off|status registers the
+// scheme for this user, takes it off, says where it leads.
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { register } from "../cli/registry.js";
+import { lines } from "../cli/format.js";
+import { ui } from "../cli/ui.js";
+import { readJsonIfExists } from "../core/json.js";
+import { Tree } from "../core/tree.js";
+import { LinkError, linkHandlerState, linkText, parseLink, registerLinks, unregisterLinks } from "../core/links.js";
+import { displayName, lifespan } from "../core/people.js";
+import { PROFILES } from "../agents/profiles.js";
+import { whereToTalk } from "../core/apps.js";
+import { pause } from "../cli/menu-parts.js";
+import { fullExcerpt } from "../core/excerpt.js";
+import { openForUser } from "../core/open.js";
+import { openInNewTerminal } from "../core/shortcut.js";
+import { systemNotice } from "../core/dialog.js";
+import { configDir } from "../core/paths.js";
+/** The researches here with this id — a copy of a research folder has its id too; the current one first. */
+function researchesWithId(ctx, id) {
+    const current = ctx.settings.config.currentTree;
+    return ctx
+        .knownTrees()
+        .filter((k) => readJsonIfExists(path.join(k.root, "strom.json"))?.id?.toLowerCase() === id)
+        .sort((a, b) => Number(b.root === current) - Number(a.root === current));
+}
+/**
+ * What a link could not do, said where the person is: the terminal, else a window (a link opens strom with none).
+ * The result carries it too.
+ */
+async function say(ctx, key, values = {}, data = {}) {
+    const lang = ctx.uiLang();
+    const text = ui(lang, key, values);
+    if (!ctx.io.tty)
+        systemNotice(ui(lang, "ui.dialog.title"), text, ui(lang, "ui.link.ok"), ctx.env);
+    return { text, data: { done: false, ...data } };
+}
+/** The person's answer about links, kept: the question when the app opens is not asked again. */
+function keepAnswer(ctx, answer) {
+    ctx.settings.reload();
+    ctx.settings.config.links = answer;
+    ctx.settings.save();
+}
+/** macOS: the terminal program this runs in, by its mark (TERM_PROGRAM). */
+const TERMINALS = { Apple_Terminal: "Terminal", "iTerm.app": "iTerm", WezTerm: "WezTerm", ghostty: "Ghostty" };
+/**
+ * The terminal a link opened comes in front of the Strom app when the app has answered (the tree came, or
+ * nothing did): the person sees what came of it. macOS; elsewhere the window stays where it is.
+ */
+function bringForward(env) {
+    const app = TERMINALS[env.TERM_PROGRAM ?? ""];
+    if (process.platform !== "darwin" || !app || env.STROM_NO_OPEN === "1")
+        return;
+    spawnSync("osascript", ["-e", `tell application "${app}" to activate`], { stdio: "ignore", timeout: 5000 });
+}
+/** strom itself in a research's folder (none: where strom is), as the menu runs it — quiet: its output not shown; said: handed over. */
+function runnerOf(ctx) {
+    return async (root) => {
+        const { main } = await import("../cli/main.js");
+        return (argv, quiet, said) => main(argv, said ? { ...ctx.io, stdout: said } : quiet ? { ...ctx.io, stdout: () => undefined } : ctx.io, ctx.env, root ?? ctx.cwd);
+    };
+}
+/** A person of the research a link names: the one they were merged into; one taken out is none. */
+function personOf(root, ctx, id) {
+    const tree = Tree.open(root, ctx.env);
+    let p = tree.get(id);
+    if (p?.mergedInto)
+        p = tree.get(p.mergedInto);
+    return p && !p.retracted ? p : undefined;
+}
+/** A person as the user reads them, with the ID to name them by: "Jan Novák (*1905) [P0012]". */
+function who(p) {
+    const span = lifespan(p);
+    return `${displayName(p)}${span ? ` (${span})` : ""} [${p.id}]`;
+}
+/** The conversation's first message about one person: only who (from the research's own record), what to ask is the person's. */
+function aboutPerson(lang, p) {
+    return ui(lang, "ui.link.chat.say", { person: who(p) });
+}
+/** The conversation's first message about a conflict: its ID and title from the research itself. */
+function aboutConflict(root, ctx, id) {
+    const tree = Tree.open(root, ctx.env);
+    const c = tree.get(id);
+    return c && c.type === "conflict" && c.state === "open" ? ui(tree.lang, "ui.link.conflict.say", { id: c.id, title: c.title }) : undefined;
+}
+/** What a link asks, in this terminal: which copy of the research, then as the menu does it. */
+async function inTerminal(ctx, link) {
+    const lang = ctx.uiLang();
+    const copies = researchesWithId(ctx, link.tree);
+    if (!copies.length)
+        return say(ctx, "ui.link.notree", {}, { tree: link.tree });
+    let root = copies[0].root;
+    if (copies.length > 1) {
+        const i = await ctx.choose(ui(lang, link.action === "send" ? "ui.link.which" : "ui.link.which.one"), copies.map((c) => ({ label: `${c.name} (${ctx.display(c.root)})` })), 0, { back: ui(lang, "ui.browse.back") });
+        if (i === undefined)
+            return { text: "", data: { done: false } };
+        root = copies[i].root;
+    }
+    const run = await runnerOf(ctx)(root);
+    const tree = Tree.open(root, ctx.env);
+    const treeLang = tree.lang;
+    const end = async (done) => {
+        await pause(ctx, treeLang, "ui.enter.close");
+        return { text: "", data: { done, action: link.action, tree: root } };
+    };
+    const said = async (key, values = {}) => {
+        ctx.io.stdout(ui(treeLang, key, values) + "\n");
+        return end(false);
+    };
+    const agent = PROFILES[ctx.settings.agent(tree.config).value]?.name ?? ctx.settings.agent(tree.config).value;
+    switch (link.action) {
+        case "send": {
+            const { syncFromApp } = await import("../cli/menu-research.js");
+            await syncFromApp(ctx, run, treeLang, root, "ui.enter.close", () => bringForward(ctx.env));
+            return { text: "", data: { done: true, action: link.action, tree: root } };
+        }
+        // the research's menu, as `strom` in its folder; the research into the app's window, as strom app; strom's own
+        // commands, which ask themselves
+        case "open":
+        case "app":
+            return { text: "", data: { done: (await run(link.action === "open" ? [] : ["app"])) === 0, action: link.action, tree: root } };
+        case "update":
+        case "setup":
+            return end((await run([link.action])) === 0);
+        case "sessions": {
+            const { sessionsView } = await import("../cli/menu-links.js");
+            sessionsView(ctx, treeLang, root);
+            return end(true);
+        }
+        case "task": {
+            if (link.do) {
+                const { taskDo } = await import("../cli/menu-links.js");
+                return end(await taskDo(ctx, run, treeLang, root, link.task, link.do));
+            }
+            const { waitingTask } = await import("../cli/menu-waiting.js");
+            if (!(await waitingTask(ctx, run, treeLang, root, link.task)))
+                return said("ui.link.notask");
+            return end(true);
+        }
+        case "conflict": {
+            if (link.do === "decide") {
+                const { decideConflict } = await import("../cli/menu-links.js");
+                return end(await decideConflict(ctx, run, treeLang, root, link.id));
+            }
+            // left to the agent: it costs — said and asked first, then the conversation about it
+            const say = aboutConflict(root, ctx, link.id);
+            if (!say)
+                return said("ui.link.conflict.none", { id: link.id });
+            const { asks } = await import("../cli/menu-links.js");
+            if (!(await asks(ctx, treeLang, root, ui(treeLang, "ui.link.what.conflict.agent", { agent, title: tree.get(link.id).title }), ui(treeLang, "ui.link.cost"))))
+                return end(false);
+            return { text: "", data: { done: (await run(["chat", `--say=${say}`])) === 0, action: link.action, tree: root } };
+        }
+        case "sync-undo": {
+            const { undoSending } = await import("../cli/menu-links.js");
+            return end(await undoSending(ctx, run, treeLang, root, link.intake));
+        }
+    }
+    const named = "person" in link ? link.person : undefined;
+    const person = named ? personOf(root, ctx, named) : undefined;
+    if (named && !person)
+        return said("ui.link.noperson", { person: named });
+    const { asks } = await import("../cli/menu-links.js");
+    switch (link.action) {
+        case "chat": {
+            // the agent costs: said and asked first, then the conversation as strom chat starts it
+            const what = person ? ui(treeLang, "ui.link.what.chat.person", { agent, person: who(person) }) : ui(treeLang, "ui.link.what.chat", { agent });
+            if (!(await asks(ctx, treeLang, root, what, ui(treeLang, "ui.link.cost"))))
+                return { text: "", data: { done: false, action: link.action, tree: root } };
+            return { text: "", data: { done: (await run(["chat", ...(person ? [`--say=${aboutPerson(treeLang, person)}`] : [])])) === 0, action: link.action, tree: root } };
+        }
+        case "story": {
+            const { approveStory } = await import("../cli/menu-links.js");
+            return end(await approveStory(ctx, run, treeLang, root, person, who(person)));
+        }
+        case "review": {
+            const what = ui(treeLang, `ui.link.what.review.${link.scope}`, { person: who(person) });
+            if (await asks(ctx, treeLang, root, what, ui(treeLang, "ui.link.tasks"))) {
+                const { reviewOne } = await import("../cli/menu-research.js");
+                await reviewOne(ctx, run, treeLang, root, person.id, link.scope);
+            }
+            return end(true);
+        }
+        case "research": {
+            // the same direction still going: only named, nothing asked
+            const same = tree.list("research").find((r) => r.focus === person.id && r.direction === link.direction && r.state === "active");
+            if (same)
+                return said("ui.research.exists", { name: same.name });
+            const what = ui(treeLang, `ui.link.what.research.${link.direction}`, { person: who(person) });
+            if (await asks(ctx, treeLang, root, what, ui(treeLang, "ui.link.tasks"))) {
+                const { startDirection } = await import("../cli/menu-research.js");
+                await startDirection(ctx, run, treeLang, root, link.direction, ["--person", person.id], displayName(person));
+            }
+            return end(true);
+        }
+    }
+}
+/**
+ * What needs no terminal: the research as it is now into the app's window (strom app), a conversation in the
+ * agent's desktop app (its first message waits there for the person to send it). Undefined: a terminal is needed.
+ */
+async function withoutTerminal(ctx, link, root) {
+    const run = await runnerOf(ctx)(root);
+    if (link.action === "app")
+        return { text: "", data: { done: (await run(["app"], true)) === 0, action: "app", tree: root } };
+    if (link.action !== "chat" && !(link.action === "conflict" && link.do === "agent"))
+        return undefined;
+    const tree = Tree.open(root, ctx.env);
+    if (whereToTalk(ctx.settings.agent(tree.config).value, ctx.settings.agentWhere(), ctx.env) !== "app")
+        return undefined;
+    let first;
+    if (link.action === "conflict") {
+        first = aboutConflict(root, ctx, link.id);
+        if (!first)
+            return say(ctx, "ui.link.conflict.none", { id: link.id }, { tree: link.tree });
+    }
+    else if (link.action === "chat" && link.person) {
+        const person = personOf(root, ctx, link.person);
+        if (!person)
+            return say(ctx, "ui.link.noperson", { person: link.person }, { tree: link.tree });
+        first = aboutPerson(tree.lang, person);
+    }
+    return { text: "", data: { done: (await run(["chat", ...(first ? [`--say=${first}`] : [])], true)) === 0, action: link.action, tree: root } };
+}
+/** An excerpt in full: the first research here that has it. */
+function excerptOf(ctx, link) {
+    const shared = ctx.settings.shared()?.value;
+    const copies = researchesWithId(ctx, link.tree);
+    if (!copies.length || !shared)
+        return { missing: "tree" };
+    let found = { missing: "clip" };
+    for (const c of copies) {
+        const s = Tree.open(c.root, ctx.env).get(link.source);
+        if (!s || s.retracted)
+            continue;
+        found = fullExcerpt(Tree.open(c.root, ctx.env), shared, s, link.clip);
+        if (!("missing" in found))
+            return found;
+    }
+    return found;
+}
+register({
+    path: ["link", "open"],
+    summary: "Do what a strom-research:// link from the Strom app asks (the system runs it): send the edited tree back, an excerpt in full, …",
+    group: "setup",
+    description: "strom-research://send?tree=<research id> — the Strom app sends the edited tree to this research (a terminal opens,\n" +
+        "what it brings is shown and written on the user's word, as the menu's \"straight from the Strom app\").\n" +
+        "strom-research://excerpt?tree=<id>&source=S0042&clip=<its mark> — the excerpt from the scan, not made smaller, in the\n" +
+        "viewer of the system (the page in the online archive when the scan is not here). Nothing is written.\n" +
+        "strom-research://app?tree=<id> — the research as it is now into the app's open window (strom app).\n" +
+        "strom-research://open?tree=<id> — the research's menu in a terminal.\n" +
+        "strom-research://chat?tree=<id>[&person=P0012] — a conversation with the agent (strom chat; of one person: its first\n" +
+        "message names only who). strom-research://task?tree=<id>&task=T0007 — the task that waits for the user, answered.\n" +
+        "strom-research://review?tree=<id>&person=P0012&scope=person|family|line — the person reviewed (strom review).\n" +
+        "strom-research://research?tree=<id>&person=P0012&direction=ancestors|descendants — a new direction (research new).\n" +
+        "strom-research://task?…&task=T0007&do=park|drop|wake — the task put aside, given up, back in the queue (the reason asked).\n" +
+        "strom-research://conflict?tree=<id>&id=X0007&do=decide|agent — decided by the user (which claim, why) or left to the agent.\n" +
+        "strom-research://story?tree=<id>&person=P0012&do=final — the story approved (strom story approve).\n" +
+        "strom-research://sync-undo?tree=<id>&intake=I0042 — a sending from the app taken back (strom sync undo).\n" +
+        "strom-research://update|sessions|setup?tree=<id> — strom update, the agent's sessions and their cost, strom setup.\n" +
+        "strom-research://new?app=<the app's mark> — a tree of the app becomes a new research: named, made, the app hands the\n" +
+        "tree to its bridge (?adopt=, GET/POST /adopt), taken in as leads, sent back to the app.\n" +
+        "What writes tasks or starts the agent is said and asked in the terminal first. Any page can open such a link:\n" +
+        "each part is checked (only IDs and fixed values, never text), an unknown research, person, task or excerpt is\n" +
+        "only said. No link: the menu.",
+    args: [{ name: "link", description: "the strom-research:// link" }],
+    examples: ["strom link open 'strom-research://send?tree=0f8c2d4e-1b2a-4c3d-9e8f-7a6b5c4d3e2f'"],
+    async run(ctx, { args }) {
+        let link;
+        try {
+            link = parseLink(args[0]);
+        }
+        catch (e) {
+            if (!(e instanceof LinkError))
+                throw e;
+            return say(ctx, "ui.link.bad", { why: e.message });
+        }
+        if (link.action === "menu") {
+            const where = ctx.settings.home()?.value ?? configDir(ctx.env);
+            fs.mkdirSync(where, { recursive: true });
+            openInNewTerminal([], where, ctx.env);
+            return { text: "", data: { done: true, action: "menu" } };
+        }
+        // a tree of the app becomes a research: always in a terminal (it asks the name, waits for the app)
+        if (link.action === "new") {
+            if (ctx.io.tty) {
+                const { newFromApp } = await import("../cli/menu-links.js");
+                const { openAppAt } = await import("./sync.js");
+                const done = await newFromApp(ctx, runnerOf(ctx), link.app, (url) => openAppAt(ctx, url), () => bringForward(ctx.env));
+                if (!done)
+                    await pause(ctx, ctx.uiLang(), "ui.enter.close");
+                return { text: "", data: { done, action: "new" } };
+            }
+            const where = ctx.settings.home()?.value ?? configDir(ctx.env);
+            fs.mkdirSync(where, { recursive: true });
+            if (openInNewTerminal(["link", "open", linkText(link)], where, ctx.env) === false)
+                return say(ctx, "ui.link.noterminal.new");
+            return { text: "", data: { done: true, action: "new" } };
+        }
+        if (link.action !== "excerpt") {
+            // a terminal to show it in: this one, or a new window (the system started strom with none)
+            if (ctx.io.tty)
+                return inTerminal(ctx, link);
+            const copies = researchesWithId(ctx, link.tree);
+            if (!copies.length)
+                return say(ctx, "ui.link.notree", {}, { tree: link.tree });
+            const quiet = await withoutTerminal(ctx, link, copies[0].root);
+            if (quiet)
+                return quiet;
+            const opened = openInNewTerminal(["link", "open", linkText(link)], copies[0].root, ctx.env);
+            if (opened === false)
+                return link.action === "send"
+                    ? say(ctx, "ui.link.noterminal", { item: `${ui(ctx.uiLang(), "ui.more.title")} → ${ui(ctx.uiLang(), "ui.more.sync")}` })
+                    : say(ctx, "ui.link.noterminal.any", { name: copies[0].name });
+            return { text: "", data: { done: true, action: link.action, tree: copies[0].root } };
+        }
+        const got = excerptOf(ctx, link);
+        if ("file" in got) {
+            openForUser(got.file, ctx.env);
+            return { text: ctx.display(got.file), data: { done: true, action: "excerpt", file: got.file } };
+        }
+        if ("url" in got) {
+            openForUser(got.url, ctx.env);
+            return { text: got.url, data: { done: true, action: "excerpt", url: got.url } };
+        }
+        return say(ctx, got.missing === "tree" ? "ui.link.notree" : got.missing === "scan" ? "ui.link.noscan" : "ui.link.noclip", { source: link.source }, { tree: link.tree, source: link.source, clip: link.clip });
+    },
+}, {
+    path: ["link", "on"],
+    summary: "Let the Strom app start the research on this computer: register strom-research:// links for this user (the user's yes)",
+    group: "setup",
+    description: "The Strom app on this computer then sends the edited tree back with one click and opens an excerpt in full quality.\n" +
+        "For this user alone, no admin rights: macOS an applet in ~/Applications, Windows a key under HKCU, Linux a .desktop\n" +
+        "entry. The user's decision: an agent asks them (a window of the system). strom link off takes it away.",
+    run(ctx) {
+        const lang = ctx.uiLang();
+        if (linkHandlerState(ctx.env) === "ours")
+            return { text: ui(lang, "ui.link.on.done"), data: { on: true } };
+        ctx.requireHuman("Let the Strom app start strom on this computer (strom-research:// links)?", "strom link on", "links", ui(lang, "ui.setup.links"));
+        const on = registerLinks(ctx.env);
+        if (on)
+            keepAnswer(ctx, "yes");
+        return { text: ui(lang, on ? "ui.link.on.done" : "ui.link.on.failed"), data: { on }, ...(on ? {} : { exitCode: 1 }) };
+    },
+}, {
+    path: ["link", "off"],
+    summary: "Take the strom-research:// links off this computer: the Strom app no longer starts the research",
+    group: "setup",
+    run(ctx) {
+        const off = unregisterLinks(ctx.env);
+        if (off)
+            keepAnswer(ctx, "no");
+        return { text: ui(ctx.uiLang(), off ? "ui.link.off.done" : "ui.link.off.failed"), data: { on: !off }, ...(off ? {} : { exitCode: 1 }) };
+    },
+}, {
+    path: ["link", "status"],
+    summary: "Where strom-research:// links lead on this computer: to this strom, to another program, nowhere",
+    group: "setup",
+    run(ctx) {
+        const state = linkHandlerState(ctx.env);
+        const lang = ctx.uiLang();
+        return { text: lines(`${ui(lang, "ui.doc.links")}: ${ui(lang, `ui.doc.links.${state}`)}`, state === "ours" ? undefined : "→ strom link on"), data: { state } };
+    },
+});

package/dist/commands/output.js

@@ -12,6 +12,8 @@ import { resolveResearch } from "./research.js";
 import { UsageError } from "../core/errors.js";
 import { excerptSettings, planExcerpts } from "../core/excerpt.js";
 import { runGit, tracked } from "../core/git.js";
+import { Settings } from "../core/config.js";
+import { appOpensLinks } from "../core/stromapp.js";
 import { EXCERPT_QUALITIES, EXCERPT_SCOPES } from "../core/model.js";
 function findingRows(f) {
     return table(f.slice(0, 30).map((x) => [x.level === "error" ? "ERROR" : "warn", `line ${x.line}`, x.message]));
@@ -67,7 +69,11 @@ export function writeTreeGed(tree, opts) {
     const images = set && set.for !== "none"
         ? planExcerpts(tree, set.shared, { quality: set.quality, for: set.for, maxBytes: set.mb * 1024 * 1024, persons, budgetMs: opts.budgetMs })
         : undefined;
-    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}) });
+    // each excerpt's mark, for an app that asks for it in full (a strom-research:// link)
+    // an app that opens links shows what the research knows of a person too (the same version)
+    const research = opts.for === "strom" && appOpensLinks(new Settings(tree.env, {}), opts.stromVersion);
+    const clips = research && !!images;
+    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}), ...(clips ? { clips } : {}), ...(research ? { research } : {}) });
     const findings = validateGedcom(result.text, opts.for === "standard" ? { strict: true } : {});
     const file = opts.out ?? gedFile(tree, opts.for, opts.research);
     if (!hasGedErrors(findings) && !tree.dryRun) {

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) } : {}),
+            })),
+        },
+    };
+}