strom-research 1.7.0 → 1.9.0

package/dist/commands/tasks.js

@@ -11,6 +11,7 @@ import { lines, moreLine, paginate, runs, table, truncate } from "../cli/format.
 import { UsageError } from "../core/errors.js";
 import { TASK_LEVELS } from "../core/model.js";
 import { create, csvOpt, listOpt, normId, requireRecord, update } from "../core/records.js";
+import { directionOf, ofResearch, scopes } from "../core/directions.js";
 import { resolvePerson } from "../core/people.js";
 import { foldText } from "../core/text.js";
 import { now, typeOfId } from "../core/tree.js";
@@ -19,6 +20,8 @@ import { makeNote } from "../core/actions.js";
 import { phrase } from "../core/phrases.js";
 import { readJsonLines } from "../core/json.js";
 import { lacksImages, rankTasks } from "../core/queue.js";
+import { joiningHypotheses, offTree } from "../core/kin.js";
+import { aboutPeople } from "../core/directions.js";
 import { clipNote, inboxFolderFor, parseImageList, transcriptNote } from "../core/media.js";
 function written(tree) {
     return lines(...tree.written.map((o) => o.summary), tree.dryRun ? "(dry run — nothing written)" : undefined);
@@ -35,11 +38,17 @@ function subjects(tree, refs) {
         return resolvePerson(tree, r).id;
     });
 }
-function defaultResearch(tree, ref) {
+/** A new task's research: the one named, else the session's that adds it, else the one active research its people belong to. */
+function defaultResearch(tree, ref, subject = []) {
     if (typeof ref === "string")
         return resolveResearch(tree, ref).id;
+    const session = typeOfId(tree.actor) === "session" ? tree.get(tree.actor) : undefined;
+    if (session?.research)
+        return session.research;
     const active = tree.list("research").filter((r) => r.state === "active");
-    return active.length === 1 ? active[0].id : undefined;
+    if (active.length === 1)
+        return active[0].id;
+    return directionOf(tree, { subject }, scopes(tree).filter((s) => s.research.state === "active"));
 }
 /** What the research waits for from outside — mostly from the user: scans to download, a book to find, a reply. */
 export function waitingForUser(tree) {
@@ -75,12 +84,29 @@ export function taskQueue(tree, filter = {}) {
     return rankedQueue(tree, filter).map((r) => r.task);
 }
 export function rankedQueue(tree, filter = {}) {
+    const scope = filter.research ? scopes(tree).find((s) => s.research.id === filter.research) : undefined;
     const tasks = tree
         .list("task")
-        .filter((t) => !filter.research || !t.research || t.research === filter.research)
+        .filter((t) => !filter.research || (scope ? ofResearch(tree, t, scope) : t.research === filter.research))
         .filter((t) => !filter.level || t.level === filter.level);
     return rankTasks(tree, tasks, filter.strategy, { storyTurn: filter.storyTurn });
 }
+/**
+ * What an agent is told of a task about people nothing links to the tree (core/kin.ts offTree): it waits out of the
+ * queue until the user asks for it or the hypothesis that would join them is decided; the task that tests that
+ * hypothesis names it. Undefined for a task of the tree.
+ */
+export function offTreeLine(tree, t, starting = false) {
+    if (!offTree(tree)(t))
+        return undefined;
+    const joins = joiningHypotheses(tree, aboutPeople(tree, t.subject));
+    const first = joins.length
+        ? `test first what would join them: ${joins.map((h) => `${h.id} "${truncate(h.question, 70)}"`).join("; ")} — a task that tests it names it (--about ${joins[0].id})`
+        : "first a link to a person of the tree: a hypothesis (strom hypothesis add … --about P… of the tree) and a task that tests it, naming it (--about H…)";
+    return starting
+        ? `⚠ ${t.id} is about people nothing links to the tree yet: go on only if the user asked for this work. Else close the session (strom session close --continue …) and ${first}`
+        : `· ${t.id} is about people nothing links to the tree yet: it waits out of the queue until the user asks for it or a hypothesis joins them — ${first}`;
+}
 function taskLine(t) {
     return [t.id, `p${t.priority}`, t.level, t.state === "open" ? "" : `[${t.state}]`, truncate(t.what, 70)];
 }
@@ -183,7 +209,7 @@ register({
             throw new UsageError("--priority must be 1..5");
         const where = listOpt(opts.where).map((w) => (/^[Bb]\d+$/.test(w) ? requireRecord(tree, w, "recordset").id : w));
         const subject = subjects(tree, listOpt(opts.about));
-        const research = defaultResearch(tree, opts.research);
+        const research = defaultResearch(tree, opts.research, subject);
         // The same work again: an open task of the same person and level that reads the same (or nearly, in the same
         // books) — not added; what is new goes into that one.
         if (!opts.anyway) {
@@ -223,7 +249,7 @@ register({
         // it is known — not in a session spent finding out that there is nothing to read.
         const noImages = lacksImages(tree, t);
         return {
-            text: lines(written(tree), ...similar.map((x) => `⚠ similar ${x.state} task ${x.id} "${truncate(x.what, 60)}" — if it is the same, keep one: strom task drop ${t.id} --reason "duplicate of ${x.id}" and strom task edit ${x.id} --where … --note "…"`), noImages ? `· no images for it here yet — if the user has to download them, say which now: strom task wait ${t.id} --images B…:<numbers> --on "<the book, its link, which images>"` : undefined),
+            text: lines(written(tree), ...similar.map((x) => `⚠ similar ${x.state} task ${x.id} "${truncate(x.what, 60)}" — if it is the same, keep one: strom task drop ${t.id} --reason "duplicate of ${x.id}" and strom task edit ${x.id} --where … --note "…"`), offTreeLine(tree, t), noImages ? `· no images for it here yet — if the user has to download them, say which now: strom task wait ${t.id} --images B…:<numbers> --on "<the book, its link, which images>"` : undefined),
             data: { task: t, similar: similar.map((x) => x.id), needsImages: noImages },
         };
     },
@@ -242,8 +268,13 @@ register({
         const strategy = ctx.settings.strategy(tree.config);
         const queue = rankedQueue(tree, { ...(research ? { research } : {}), ...(opts.level ? { level: String(opts.level) } : {}), strategy });
         const first = queue[0];
-        if (!first)
-            return { text: 'no open tasks → strom research show <G…> to see what is missing, then strom task add', data: { task: null } };
+        if (!first) {
+            const held = tree.list("task").filter(offTree(tree)).filter((t) => t.state === "open").length;
+            const text = held
+                ? `no open task of the tree — ${held} wait about people nothing links to it yet (strom task list --off-tree): test the hypothesis that would join them, or ask the user`
+                : "no open tasks → strom research show <G…> to see what is missing, then strom task add";
+            return { text, data: { task: null, offTree: held } };
+        }
         const t = first.task;
         return {
             text: lines(taskDetail(tree, t), "", `first because: ${first.why} (queue: ${strategy})`, `start it: strom task start ${t.id}`),
@@ -263,6 +294,7 @@ register({
         { name: "research", type: "string", value: "<G…>", description: "only this research" },
         { name: "level", type: "string", value: "<level>", description: "only this level" },
         { name: "about", type: "string", value: "<who>", description: "only tasks about this person/record (also X…, H…)" },
+        { name: "off-tree", type: "boolean", description: "the open tasks that wait out of the queue: about people nothing links to the tree yet" },
         { name: "full", type: "boolean", description: "--json: whole records instead of one row each" },
     ],
     run(ctx, { opts }) {
@@ -270,7 +302,10 @@ register({
         const research = typeof opts.research === "string" ? resolveResearch(tree, opts.research).id : undefined;
         let all;
         const why = new Map();
-        if (!opts.state) {
+        const off = offTree(tree);
+        if (opts["off-tree"])
+            all = tree.list("task").filter((t) => t.state === "open" && off(t) && (!opts.level || t.level === opts.level));
+        else if (!opts.state) {
             const ranked = rankedQueue(tree, { ...(research ? { research } : {}), ...(opts.level ? { level: String(opts.level) } : {}), strategy: ctx.settings.strategy(tree.config) });
             for (const r of ranked)
                 why.set(r.task.id, r.why);
@@ -278,8 +313,9 @@ register({
         }
         else {
             all = tree.list("task").filter((t) => opts.state === "all" || t.state === opts.state);
-            if (research)
-                all = all.filter((t) => t.research === research);
+            const scope = research ? scopes(tree).find((s) => s.research.id === research) : undefined;
+            if (scope)
+                all = all.filter((t) => ofResearch(tree, t, scope));
             if (opts.level)
                 all = all.filter((t) => t.level === opts.level);
         }
@@ -288,8 +324,10 @@ register({
             all = all.filter((t) => t.subject.includes(id));
         }
         const page = paginate(all, ctx.limit, ctx.page);
+        // the queue says what waits out of it for a link to the tree
+        const held = !opts.state && !opts["off-tree"] && !opts.about ? tree.list("task").filter((t) => t.state === "open" && off(t)).length : 0;
         return {
-            text: all.length ? lines(table(page.items.map(taskLine)), moreLine(page, "strom task list")) : "no tasks",
+            text: lines(all.length ? lines(table(page.items.map(taskLine)), moreLine(page, "strom task list")) : "no tasks", held ? `${held} more wait out of the queue: about people nothing links to the tree yet (strom task list --off-tree)` : undefined),
             data: { total: page.total, tasks: opts.full ? page.items : page.items.map((t) => ({ id: t.id, priority: t.priority, level: t.level, state: t.state, what: t.what, subject: t.subject, ...(why.has(t.id) ? { why: why.get(t.id) } : {}) })) },
         };
     },
@@ -351,7 +389,7 @@ register({
             summary: `${id} ${fields.map((f) => (f === "doneWhen" ? "done-when" : f === "subject" ? "about" : f)).join(", ")}${change.where ? ` → ${truncate(change.where.join("; "), 50)}` : ""}`,
             reason: opts.reason,
         });
-        return { text: written(tree), data: { task: t } };
+        return { text: lines(written(tree), change.subject ? offTreeLine(tree, t) : undefined), data: { task: t } };
     },
 }, {
     path: ["task", "start"],

package/dist/commands/trees.js

@@ -6,13 +6,19 @@ import { register } from "../cli/registry.js";
 import { Context } from "../cli/context.js";
 import { lines, table } from "../cli/format.js";
 import { Tree } from "../core/tree.js";
-import { safeFolderName } from "../core/text.js";
+import { foldText, safeFolderName } from "../core/text.js";
 import { isValidLang, langName } from "../core/lang.js";
-import { UsageError } from "../core/errors.js";
+import { NeedsConsentError, UsageError } from "../core/errors.js";
 import { verifyFast } from "../core/integrity.js";
 import * as git from "../core/git.js";
 import { ensureShared, setTreeSetting } from "./setup.js";
 import { syncAgentFiles } from "../agents/files.js";
+import { ui } from "../cli/ui.js";
+import { atWork } from "../core/relocate.js";
+import { moveToTrash } from "../core/trash.js";
+import { stopLive } from "../core/live.js";
+import { onlyItsFiles, packPlan } from "../core/pack.js";
+import { defaultPackFile, packTree } from "./pack.js";
 register({
     path: ["init"],
     summary: "Create a family tree (a folder with its own history) to hold researches",
@@ -81,6 +87,80 @@ register({
         return { text: `now working on "${tree.config.name}" (${ctx.display(root)})`, data: { name: tree.config.name, root } };
     },
 });
+register({
+    path: ["trees", "remove"],
+    summary: "Take a family tree off this computer — into the system's trash, a backup offered first (the person runs this)",
+    group: "research",
+    description: "Offers a backup first (strom pack --all-images: it comes back with strom unpack), then the images no other tree\n" +
+        "uses; the person types the tree's name to confirm. The tree's folder goes into the system's trash (never deleted\n" +
+        "for good), so do the images they chose. Never while somebody works on it; only the person at the computer —\n" +
+        "never an agent.",
+    args: [{ name: "tree", description: "tree name or folder", required: true }],
+    examples: ['strom trees remove "Novákovi"'],
+    async run(ctx, { args }) {
+        const lang = ctx.uiLang();
+        const probe = Context.fromOptions({ env: ctx.env, cwd: ctx.cwd, io: ctx.io, json: ctx.json, values: { tree: args[0] } });
+        const root = probe.locateTree();
+        if (!ctx.interactive)
+            throw new NeedsConsentError([{ key: "remove", kind: "consent", question: ui(lang, "ui.remove.person"), set: `strom trees remove "${root}"` }]);
+        const tree = Tree.open(root, ctx.env);
+        const name = tree.config.name;
+        // the Strom app following it live is no work: its bridge only reads, and stops before the tree goes
+        if (atWork(root, { bridge: false }))
+            throw new UsageError(ui(lang, "ui.remove.busy", { name }), { hint: "strom" });
+        const shared = ctx.settings.shared().value;
+        const others = ctx.knownTrees().map((k) => k.root).filter((r) => path.resolve(r) !== path.resolve(root));
+        const only = onlyItsFiles(root, others, shared);
+        const onlyBytes = only.reduce((s, f) => s + f.size, 0);
+        const mb = (b) => (b / 1e6 < 10 ? (b / 1e6).toFixed(1) : Math.round(b / 1e6).toString());
+        ctx.io.stdout(ui(lang, "ui.remove.what", { name, root: ctx.display(root), persons: tree.list("person").length }) + "\n");
+        // a way back first
+        let backup;
+        const all = packPlan(tree, shared, true).media.reduce((s, m) => s + m.size, 0);
+        if (await ctx.confirm(ui(lang, "ui.remove.backup", { mb: mb(all) }), true)) {
+            const out = defaultPackFile(ctx, tree);
+            backup = packTree(tree, shared, out, true).file;
+            ctx.io.stdout(ui(lang, "ui.remove.backup.done", { file: ctx.display(backup) }) + "\n");
+        }
+        const images = only.length > 0 && (await ctx.confirm(ui(lang, "ui.remove.images", { n: only.length, mb: mb(onlyBytes) }), backup !== undefined));
+        const typed = (await ctx.ask(ui(lang, "ui.remove.type", { name }))).trim();
+        if (!typed || foldText(typed) !== foldText(name))
+            return { text: ui(lang, "ui.remove.cancelled"), data: { removed: false, ...(backup ? { backup } : {}) } };
+        if (atWork(root, { bridge: false }))
+            throw new UsageError(ui(lang, "ui.remove.busy", { name }), { hint: "strom" });
+        const followed = stopLive(root, "the family tree is taken off this computer");
+        moveToTrash(root, ctx.env, path.basename(root));
+        let moved = 0;
+        if (images) {
+            // the images together, one folder in the trash named after the tree
+            const folder = path.join(shared, `.${safeFolderName(name) || "tree"}-${Date.now()}`);
+            for (const f of only) {
+                const to = path.join(folder, ...f.file.split("/"));
+                fs.mkdirSync(path.dirname(to), { recursive: true });
+                fs.renameSync(path.join(shared, ...f.file.split("/")), to);
+                moved++;
+            }
+            moveToTrash(folder, ctx.env, ui(lang, "ui.remove.images.folder", { name }));
+        }
+        const cfg = ctx.settings.config;
+        if (cfg.extraTrees)
+            cfg.extraTrees = cfg.extraTrees.filter((r) => path.resolve(r) !== path.resolve(root));
+        // the tree worked on went: the next one known is worked on now, never a menu with none chosen
+        let next;
+        if (cfg.currentTree && path.resolve(cfg.currentTree) === path.resolve(root)) {
+            const left = ctx.knownTrees().filter((k) => path.resolve(k.root) !== path.resolve(root));
+            if (left.length) {
+                cfg.currentTree = left[0].root;
+                next = left[0].name;
+            }
+            else
+                delete cfg.currentTree;
+        }
+        ctx.settings.save();
+        const text = lines(ui(lang, "ui.remove.done", { name }), followed ? ui(lang, "ui.remove.live") : undefined, moved ? ui(lang, "ui.remove.images.done", { n: moved, mb: mb(onlyBytes) }) : undefined, backup ? ui(lang, "ui.remove.backup.back", { file: ctx.display(backup) }) : undefined, ui(lang, backup ? "ui.remove.trash" : "ui.remove.trash.alone"), next ? ui(lang, "ui.remove.next", { name: next }) : undefined);
+        return { text, data: { removed: true, root, images: moved, ...(backup ? { backup } : {}), ...(next ? { current: cfg.currentTree } : {}) } };
+    },
+});
 register({
     path: ["status"],
     summary: "State of the current tree: researches, data, checks, recent changes",

package/dist/core/changelog.js

@@ -0,0 +1,223 @@
+// What one commit of a research saved, as a person reads it — in the research
+// language, records by their names: "New person: Jan Novák (*1905) [P0001]",
+// "Downloaded 7 images: Kniha N 1850 (images 16–22)". Made from the operations
+// the commit logged (data/ops/*.jsonl, each line one operation); a commit
+// without them (the readers' notes) by its subject. For the Strom app (the
+// bridge's /log and change events): strom's own commit subjects are English
+// and name records by their IDs.
+import { displayName, lifespan } from "./people.js";
+import { ownerName, cardFact } from "./overview.js";
+import { phrase } from "./phrases.js";
+import { eventName, humanDate, humanPlace, humanTask } from "../cli/human.js";
+/** Operations nobody needs to read: what another line says already, or bookkeeping. */
+const QUIET = new Set(["session.metrics", "task.start", "task.continue", "session.note"]);
+/** The one-line form of an operation, by its kind: {who} a person or family, {name} the record. */
+const SAID = {
+    "person.add": "log.person.add",
+    "person.name": "log.person.name",
+    "person.edit": "log.person.edit",
+    "person.cite": "log.person.cite",
+    "person.retract": "log.person.retract",
+    "family.add": "log.family.add",
+    "family.edit": "log.family.edit",
+    "family.cite": "log.family.cite",
+    "source.add": "log.source.add",
+    "source.edit": "log.source.edit",
+    "recordset.add": "log.recordset.add",
+    "recordset.edit": "log.recordset.edit",
+    "recordset.calibrate": "log.recordset.calibrate",
+    "task.add": "log.task.add",
+    "task.done": "log.task.done",
+    "task.park": "log.task.park",
+    "task.drop": "log.task.drop",
+    "task.wait": "log.task.wait",
+    "task.wake": "log.task.wake",
+    "task.edit": "log.task.edit",
+    "session.start": "log.session.start",
+    "session.close": "log.session.close",
+    "lesson.add": "log.lesson.add",
+    "hypothesis.add": "log.hypothesis.add",
+    "hypothesis.argue": "log.hypothesis.argue",
+    "hypothesis.decide": "log.hypothesis.decide",
+    "conflict.add": "log.conflict.add",
+    "conflict.resolve": "log.conflict.resolve",
+    "place.add": "log.place.add",
+    "place.edit": "log.place.edit",
+    "place.jurisdiction": "log.place.edit",
+    "repository.add": "log.repository.add",
+    "repository.edit": "log.repository.edit",
+    "story.set": "log.story.set",
+    "story.approve": "log.story.approve",
+    "note.add": "log.note.add",
+    "input.add": "log.input.add",
+    "input.sync": "log.input.sync",
+    "input.done": "log.input.done",
+    "research.add": "log.research.add",
+    "research.edit": "log.research.edit",
+    "research.pause": "log.research.pause",
+    "research.resume": "log.research.resume",
+    "research.done": "log.research.done",
+};
+const EVENT_SAID = {
+    "event.add": "log.event.add",
+    "event.edit": "log.event.edit",
+    "event.cite": "log.event.cite",
+    "event.retract": "log.event.retract",
+};
+const SEARCH_SAID = {
+    found: "log.search.found",
+    negative: "log.search.negative",
+    partial: "log.search.partial",
+    inconclusive: "log.search.inconclusive",
+};
+function short(text, max = 90) {
+    const one = text.replace(/\s+/g, " ").trim();
+    return one.length > max ? `${one.slice(0, max - 1).trimEnd()}…` : one;
+}
+/** Image numbers as ranges: 16–22, 30. */
+function ranges(ns) {
+    const sorted = [...new Set(ns)].sort((a, b) => a - b);
+    const out = [];
+    for (let i = 0; i < sorted.length; i++) {
+        let j = i;
+        while (j + 1 < sorted.length && sorted[j + 1] === sorted[j] + 1)
+            j++;
+        out.push(j > i ? `${sorted[i]}–${sorted[j]}` : String(sorted[i]));
+        i = j;
+    }
+    return out.join(", ");
+}
+function kindOf(op) {
+    const [record] = op.split(".");
+    if (record === "person" || record === "family" || record === "event")
+        return "person";
+    if (record === "source" || record === "media" || record === "recordset" || record === "repository")
+        return "source";
+    if (record === "story")
+        return "story";
+    return "other";
+}
+/** Lines of what a commit saved, in the research language, each with what it is about; its subject when it logged no operation. */
+export function changeLines(tree, ops, subject, lang) {
+    const get = (id) => (id ? tree.get(id) : undefined);
+    const who = (id) => {
+        const r = get(id);
+        if (!r)
+            return id ?? "";
+        if (r.type === "person") {
+            const span = lifespan(r);
+            return `${displayName(r)}${span ? ` (${span})` : ""} [${r.id}]`;
+        }
+        return r.type === "family" ? ownerName(tree, r.id) : r.id;
+    };
+    const task = (id) => {
+        const t = get(id);
+        return t ? short(humanTask(tree, t.what, lang)) : (id ?? "");
+    };
+    const name = (id) => {
+        const r = get(id);
+        if (!r)
+            return id ?? "";
+        switch (r.type) {
+            case "person":
+            case "family":
+                return who(r.id);
+            case "task":
+                return task(r.id);
+            case "session":
+                return r.task ? task(r.task) : r.id;
+            case "source":
+            case "recordset":
+            case "conflict":
+                return short(r.title);
+            case "research":
+            case "repository":
+            case "input":
+                return short(r.name);
+            case "search":
+                return short(r.question);
+            case "lesson":
+                return short(r.rule);
+            case "hypothesis":
+                return short(r.question);
+            case "place":
+                return r.names[0]?.name ?? r.id;
+            default:
+                return r.id;
+        }
+    };
+    const fact = (owner, eventId) => {
+        const e = get(owner)?.events.find((x) => x.id === eventId);
+        if (!e)
+            return undefined;
+        const f = cardFact(tree, e);
+        const what = [f.value, humanDate(f.date, lang), humanPlace(f.place, f.house, lang)].filter(Boolean).join(", ");
+        return `${eventName(f.kind, lang, f.label)}${what ? `: ${what}` : ""}`;
+    };
+    const out = [];
+    let kind = "other";
+    const say = (line) => {
+        if (line && !out.some((l) => l.text === line))
+            out.push({ text: line, kind });
+    };
+    // Images downloaded: one line for each book, whatever their order.
+    const images = new Map();
+    for (const o of ops) {
+        if (QUIET.has(o.op))
+            continue;
+        kind = kindOf(o.op);
+        const [first, second] = o.targets;
+        if (o.op === "media.add") {
+            const m = get(first);
+            const key = m?.recordset ?? "";
+            if (!images.has(key)) {
+                images.set(key, []);
+                out.push({ text: `\u0000media:${key}`, kind: "source" }); // its place in the order, filled in below
+            }
+            if (m?.image !== undefined)
+                images.get(key).push(m.image);
+            continue;
+        }
+        if (EVENT_SAID[o.op]) {
+            const f = fact(first, second);
+            say(f ? phrase(lang, EVENT_SAID[o.op], { who: who(first), fact: f }) : o.summary);
+            continue;
+        }
+        if (o.op === "search.add" || o.op === "search.edit") {
+            const s = get(first);
+            say(s ? phrase(lang, SEARCH_SAID[s.result] ?? "log.search.found", { name: short(s.question) }) : o.summary);
+            continue;
+        }
+        if (o.op === "family.child") {
+            say(phrase(lang, "log.family.child", { who: who(first), child: who(second) }));
+            continue;
+        }
+        if (o.op === "person.merge" || o.op === "family.merge") {
+            say(phrase(lang, "log.merge", { who: who(second) }));
+            continue;
+        }
+        const key = SAID[o.op];
+        say(key ? phrase(lang, key, { who: who(first), name: name(first) }) : o.summary);
+    }
+    const lines = out.map(({ text: line, kind }) => {
+        if (!line.startsWith("\u0000media:"))
+            return { text: line, kind };
+        const book = line.slice("\u0000media:".length);
+        const ns = images.get(book) ?? [];
+        const title = get(book)?.title;
+        const n = Math.max(ns.length, 1);
+        const text = !title
+            ? phrase(lang, "log.media.loose", { n })
+            : ns.length === 1
+                ? phrase(lang, "log.media.one", { name: title, image: ns[0] })
+                : phrase(lang, "log.media", { name: title, n, images: ns.length ? ranges(ns) : "" });
+        return { text, kind };
+    });
+    if (lines.length)
+        return lines;
+    // no operations: the readers' notes of a book, else the subject as strom wrote it
+    const reading = /^Reading (B\d+)-(\d+)-(\d+): (\d+) images?/.exec(subject);
+    if (reading)
+        return [{ text: phrase(lang, "log.reading", { name: get(reading[1])?.title ?? reading[1], n: reading[4], images: reading[2] === reading[3] ? reading[2] : `${reading[2]}–${reading[3]}` }), kind: "source" }];
+    return ops.length ? [] : [{ text: subject, kind: "other" }];
+}

package/dist/core/clock.js

@@ -5,12 +5,32 @@
 // brief says it), near the end every strom command it runs reminds it, and at
 // the limit an agent that can be resumed gets a few minutes more to write down
 // what it found and close the session (runners: wrapUp).
+import fs from "node:fs";
+import path from "node:path";
 /** From how long before the end strom's output reminds the agent (a short session: its last quarter). */
 export const REMIND_MS = 10 * 60_000;
 /** From how long before the end the reminder says to write down and close (a short session: its last eighth). */
 export const CLOSE_MS = 3 * 60_000;
 /** The time an agent stopped at its limit gets to write down what it found. */
 export const WRAP_UP_MS = 5 * 60_000;
+/**
+ * The user asked a session to finish now (strom session finish): a file of the tree's own, read by every strom
+ * command the session's agent runs — a run's session cannot be told otherwise (it reads no input).
+ */
+export function finishFile(root, session) {
+    return path.join(root, ".strom", "finish", `${session}.json`);
+}
+export function askFinish(root, session, by) {
+    fs.mkdirSync(path.dirname(finishFile(root, session)), { recursive: true });
+    fs.writeFileSync(finishFile(root, session), JSON.stringify({ at: new Date().toISOString(), by }) + "\n");
+}
+export function finishAsked(root, session) {
+    return fs.existsSync(finishFile(root, session));
+}
+/** What every strom command says to the agent of a session the user asked to finish. */
+export const FINISH_LINE = "⏳ the user asks you to finish this session now: start nothing new; record in strom what you found and have not recorded yet " +
+    '(facts, sources, the images searched, in vain too), then strom session close --continue --summary "…" --next "exactly where you stopped" ' +
+    "(or finish the task, if it is done).";
 /** When this session is stopped (ms since the epoch), if a run set a limit. */
 export function deadlineOf(env) {
     const t = Date.parse(env.STROM_DEADLINE ?? "");

package/dist/core/config.js

@@ -55,6 +55,7 @@ export const SETTINGS = [
     // Read from the config file only — no variable, no flag, no tree: nothing an agent can set.
     { key: "agent.permissions", env: "", tree: false, kind: "choice", choices: PERMISSION_LEVELS, description: "what the agent may do without asking you: ask (what the tree allows; anything else it asks), auto (default: what the tree allows; anything else the agent's own review decides, asking only when risky), full (everything but what the tree denies) — only you raise it" },
     { key: "agent.where", env: "STROM_AGENT_WHERE", tree: false, kind: "choice", choices: ["app", "terminal"], description: "where you talk with the agent: app (its desktop app — the easiest), terminal (its CLI) — unset: the app when it is installed" },
+    { key: "agent.browser", env: "", tree: true, kind: "choice", choices: ["archives", "always"], description: "browser tools (Claude in Chrome) for the Claude Code sessions strom starts: archives (default) — only in a research whose connectors fetch through the browser, for their sites; always — in every session, for the sites of the research's archives (a conversation asks about others) — only you turn it on" },
     { key: "agent.remote", env: "", tree: false, kind: "choice", choices: ["on", "off"], description: "the Claude Code sessions strom starts (strom run, strom chat in the terminal) with Remote Control: on — follow and steer them from claude.ai or the Claude app on your phone; off (default) — only you turn it on" },
     { key: "updates", env: "STROM_UPDATES", tree: false, kind: "choice", choices: ["check", "off"], description: "look for new versions of strom: check (default — at most once a day, one small file from the project's releases; strom says so, strom update installs it) or off" },
     { key: "strom.app", env: "", tree: false, kind: "choice", choices: ["yes", "no"], description: "you use the Strom app: yes (strom says which file to import into it), no (strom never mentions it) — unset: strom notices it itself" },
@@ -72,6 +73,7 @@ const FIELDS = {
     "agent.permissions": "agentPermissions",
     "agent.where": "agentWhere",
     "agent.remote": "agentRemote",
+    "agent.browser": "agentBrowser",
     "strom.app": "stromApp",
     "strom.app.url": "stromAppUrl",
     "main.person": "mainPerson",

package/dist/core/connector.js

@@ -236,6 +236,11 @@ export function treeBrowserConnectors(tree, shared) {
     if (!all.length)
         return [];
     const fetchedBy = new Set(tree.list("media").flatMap((m) => (m.fetched ? [m.fetched.connector] : [])));
+    const hosts = new Set(treeSites(tree));
+    return all.filter((c) => fetchedBy.has(c.name) || c.manifest.hosts.some((h) => hosts.has(siteOf(h))));
+}
+/** The sites of the archives a tree's records name (repositories, record sets, sources with an address). */
+function treeSites(tree) {
     const hosts = new Set();
     for (const r of [...tree.list("repository"), ...tree.list("recordset"), ...tree.list("source")])
         if (r.url && !r.retracted)
@@ -245,7 +250,26 @@ export function treeBrowserConnectors(tree, shared) {
             catch {
                 // not an address
             }
-    return all.filter((c) => fetchedBy.has(c.name) || c.manifest.hosts.some((h) => hosts.has(siteOf(h))));
+    return [...hosts];
+}
+/**
+ * Browser tools for the tree's agent (Claude in Chrome): whether its sessions get them, and for which sites.
+ * `agent.browser` archives (default): only where a connector of the tree fetches through the browser, for its sites;
+ * always (the user's choice): every session, for the sites of the tree's archives and of the connectors — a
+ * conversation asks about any other, a run nobody watches uses none other.
+ */
+export function agentBrowser(tree, shared) {
+    const via = treeBrowserConnectors(tree, shared);
+    const always = new Settings(tree.env, {}).resolve("agent.browser", tree.config)?.value === "always";
+    const hosts = new Set(via.flatMap((c) => c.manifest.hosts));
+    if (always) {
+        for (const c of shared ? scanConnectors(shared).connectors : [])
+            for (const h of c.manifest.hosts)
+                hosts.add(h);
+        for (const h of treeSites(tree))
+            hosts.add(h);
+    }
+    return { on: always || via.length > 0, hosts: [...hosts], always };
 }
 export function findConnector(shared, name) {
     if (!shared)

package/dist/core/directions.js

@@ -0,0 +1,41 @@
+// Which direction of a research (G…) a task belongs to. A task names its
+// research when it was added in a session of one (or named it); a task added
+// elsewhere belongs to the direction its people are in — the narrowest one when
+// several reach them (the ancestors of a grandmother before those of her
+// grandson). The queue, the menu and the Strom app go by the same answer.
+import { researchPeople } from "./frontier.js";
+import { subjectPeople } from "./records.js";
+import { typeOfId } from "./tree.js";
+export function scopes(tree) {
+    return tree.list("research").map((research) => ({ research, people: researchPeople(tree, research) }));
+}
+/** The people a task is about: its persons, the partners of its families, the people of its conflicts and hypotheses. */
+export function aboutPeople(tree, subject) {
+    const partners = subject.filter((id) => typeOfId(id) === "family").flatMap((id) => tree.get(id)?.partners ?? []);
+    return [...new Set([...subjectPeople(tree, subject), ...partners])];
+}
+/** The direction a task belongs to: its own, else the narrowest one its people are in; none for a task about nobody. */
+export function directionOf(tree, t, all) {
+    if (t.research)
+        return t.research;
+    const about = aboutPeople(tree, t.subject);
+    if (!about.length)
+        return undefined;
+    return all
+        .filter((s) => about.some((p) => s.people.has(p)))
+        .sort((a, b) => a.people.size - b.people.size || a.research.id.localeCompare(b.research.id))[0]?.research.id;
+}
+/**
+ * Whether a task is work of a research (strom session start --research, strom
+ * run --research): its own, or about the people it is about (a task added
+ * elsewhere or before it began); a task about nobody and of no research, any
+ * research's.
+ */
+export function ofResearch(tree, t, scope) {
+    if (t.research === scope.research.id)
+        return true;
+    const about = aboutPeople(tree, t.subject);
+    if (!about.length)
+        return !t.research;
+    return about.some((p) => scope.people.has(p)) || (!t.research && !scope.people.size);
+}