strom-research 1.0.0 → 1.1.0

package/dist/commands/output.js

@@ -10,6 +10,9 @@ import { verifyFast } from "../core/integrity.js";
 import { ancestorGenerations, familiesAsChild, familiesAsPartner } from "../core/people.js";
 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 { 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]));
 }
@@ -30,35 +33,102 @@ function researchScope(tree, r) {
 export function gedFile(tree, profile, research) {
     return path.join(tree.root, "output", `${research ? research.id : "tree"}${profile === "strom" ? "-strom" : ""}.ged`);
 }
-/** Write one GEDCOM file and validate it by the rules of its reader. */
+/**
+ * The Strom file stays out of the tree's history: it carries the entries cut out of their scans (megabytes,
+ * made again at will from the evidence); the history keeps the standard file (output/tree.ged). A tree that
+ * committed it before lets go of it once.
+ */
+const IGNORE_STROM = ["/output/*-strom.ged", "/output/*-images.ged"];
+function ignoreStromGed(tree, file) {
+    const ignore = path.join(tree.root, ".gitignore");
+    const had = fs.existsSync(ignore) ? fs.readFileSync(ignore, "utf8") : "";
+    const have = had.split(/\r?\n/);
+    const add = IGNORE_STROM.filter((l) => !have.includes(l));
+    const rel = tree.relative(file);
+    const inHistory = tracked(tree.root, rel);
+    if (!add.length && !inHistory)
+        return;
+    tree.withTreeLock(() => {
+        if (add.length)
+            fs.writeFileSync(ignore, `${had}${had && !had.endsWith("\n") ? "\n" : ""}${add.join("\n")}\n`);
+        if (inHistory)
+            runGit(tree.root, ["rm", "--cached", "--quiet", "--", rel]);
+        tree.commit("The file for the Strom app (with the images of the entries) stays out of the history", [".gitignore"]);
+    });
+}
+/**
+ * Write one GEDCOM file and validate it by the rules of its reader. The Strom file carries the entries cut out of
+ * their scans by the settings (excerpts.*; `images` overrides them, false: without); budgetMs: new excerpts are
+ * made for at most so long (the rest the next export makes).
+ */
 export function writeTreeGed(tree, opts) {
     const persons = opts.research ? researchScope(tree, opts.research) : undefined;
-    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}) });
+    const set = opts.for !== "strom" || opts.images === false ? undefined : (opts.images ?? excerptSettings(tree));
+    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 } : {}) });
     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)
+    if (!hasGedErrors(findings) && !tree.dryRun) {
+        if (opts.for === "strom" && file.startsWith(path.join(tree.root, "output") + path.sep))
+            ignoreStromGed(tree, file);
         writeFileAtomic(file, result.text);
-    return { ...result, findings, file, for: opts.for };
+    }
+    return { ...result, findings, file, for: opts.for, ...(images && set ? { images: images.report, imageSettings: set } : {}) };
+}
+const mb = (bytes) => `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+/** What an export with images took in and left out, and what to do about it — what strom decided itself is said as a warning. */
+export function imagesLines(r, images) {
+    const few = (ids) => `${ids.slice(0, 8).join(", ")}${ids.length > 8 ? ` … (${ids.length})` : ""}`;
+    return lines(`  ${r.excerpts} excerpt(s) of ${r.sources} source(s), ${mb(r.bytes)} · quality ${r.level}`, r.level !== r.asked ? `  WARNING made smaller to fit the limit of ${images.mb} MB: ${r.level} instead of ${r.asked} — more room: --images-max-mb <n> (strom config set excerpts.mb <n>)` : undefined, r.dropped.length
+        ? `  WARNING left out to fit the limit of ${images.mb} MB, the farthest from the research first: ${r.dropped.length} source(s) (${few(r.dropped)}) — more room: --images-max-mb <n>`
+        : undefined, r.outOfScope ? `  ${r.outOfScope} source(s) of people farther from the research than excerpts.for=${images.for} — all of them: --images-for all` : undefined, r.missing.length ? `  the image is not on this computer: ${few(r.missing)}` : undefined, r.unclipped.length ? `  sources on images with no clip (where the entry is): ${few(r.unclipped)} — strom clips (readers find them)` : undefined, r.later.length ? `  the images of ${r.later.length} source(s) are still being made: the next export has them (all now: strom export gedcom)` : undefined);
 }
+/** The images of an export: the settings, each overridden by its option. */
+export function imageSettings(ctx, tree, opts) {
+    const shared = ctx.settings.shared()?.value;
+    if (!shared)
+        throw new UsageError("no shared folder with the images is set", { hint: "strom setup" });
+    const set = ctx.settings.excerpts(tree.config);
+    const quality = opts["images-quality"] === undefined ? set.quality : String(opts["images-quality"]);
+    if (!EXCERPT_QUALITIES.includes(quality))
+        throw new UsageError(`invalid --images-quality "${quality}"`, { hint: EXCERPT_QUALITIES.join(", ") });
+    const scope = opts["images-for"] === undefined ? set.for : String(opts["images-for"]);
+    if (!EXCERPT_SCOPES.includes(scope))
+        throw new UsageError(`invalid --images-for "${scope}"`, { hint: EXCERPT_SCOPES.join(", ") });
+    const mbv = opts["images-max-mb"] === undefined ? set.mb : Number(opts["images-max-mb"]);
+    if (!(mbv > 0))
+        throw new UsageError("--images-max-mb must be a positive number");
+    return { shared, quality: quality, for: scope, mb: mbv };
+}
+/** New excerpts after a session are made for at most so long: what is left, the next export makes. */
+export const AFTER_SESSION_MS = 20_000;
 /** The GEDCOM files the settings ask for (both by default), from the same evidence. Used after sessions. */
 export function writeGedcoms(ctx, tree, research) {
-    return ctx.settings.gedcomFor(tree.config).map((p) => writeTreeGed(tree, { for: p, stromVersion: ctx.settings.stromVersion(tree.config), ...(research ? { research } : {}) }));
+    return ctx.settings.gedcomFor(tree.config).map((p) => writeTreeGed(tree, { for: p, stromVersion: ctx.settings.stromVersion(tree.config), ...(research ? { research } : {}), budgetMs: AFTER_SESSION_MS }));
 }
 register({
     path: ["export", "gedcom"],
-    summary: "Generate the GEDCOM files, validated: output/tree.ged for any program, output/tree-strom.ged for the Strom app",
+    summary: "Generate the GEDCOM files, validated: output/tree.ged for any program, output/tree-strom.ged for the Strom app (with the entries' images)",
     group: "output",
     tree: true,
     description: "Both come from the same evidence (GEDCOM 5.5.1, UTF-8). The standard one uses no extension tags; the Strom\n" +
         "one is shaped to what the Strom app reads (_WITN, _STORY, _FREL/_MREL, a source per page). QUAY is the\n" +
         "quality of each citation's evidence; leads say so in a note; retracted and disproven facts are left out;\n" +
-        "of several facts of a kind the best supported comes first. Which files: --for or the setting gedcom.for.",
+        "of several facts of a kind the best supported comes first. Which files: --for or the setting gedcom.for.\n" +
+        "The Strom file carries each entry cut out of its scan (the sources' clips; the settings excerpts.*, excerpts.for\n" +
+        "none: without) and stays out of the tree's history — the history keeps the standard file.",
     options: [
         { name: "for", type: "string", value: "<reader>", description: "standard (any program), strom (the Strom app) or both (default: the setting gedcom.for, both)" },
         { name: "research", type: "string", value: "<G…>", description: "only the people of one research (focus, ancestors, partners)" },
         { name: "out", type: "string", value: "<file>", description: "write here instead of output/ (with --for standard or strom)" },
+        { name: "images", type: "boolean", description: "the Strom file with the entries' images (the default; kept for older scripts)" },
+        { name: "images-quality", type: "string", value: "<q>", description: "small (1000 px, grey), normal, sharp (1600 px) — default: the setting excerpts.quality (normal)" },
+        { name: "images-for", type: "string", value: "<whose>", description: "none, line, family, connected or all — default: the setting excerpts.for (family: the ancestors and their families)" },
+        { name: "images-max-mb", type: "string", value: "<n>", description: "limit of all excerpts together — over it smaller, then the farthest left out (default: the setting excerpts.mb, 200)" },
     ],
-    examples: ["strom export gedcom", "strom export gedcom --research G0001", "strom export gedcom --for standard --out ~/Desktop/novak.ged"],
+    examples: ["strom export gedcom", "strom export gedcom --research G0001", "strom export gedcom --for standard --out ~/Desktop/novak.ged", "strom export gedcom --for strom --images-for all"],
     run(ctx, { opts }) {
         const tree = ctx.tree();
         const research = typeof opts.research === "string" ? resolveResearch(tree, opts.research) : undefined;
@@ -66,10 +136,20 @@ register({
         const which = typeof opts.for === "string" ? opts.for.toLowerCase() : undefined;
         if (which && which !== "both" && !GED_PROFILES.includes(which))
             throw new UsageError(`invalid --for "${opts.for}"`, { hint: "standard, strom or both" });
+        const asked = ["images-max-mb", "images-quality", "images-for"].some((k) => opts[k] !== undefined);
+        if ((asked || opts.images) && which === "standard")
+            throw new UsageError("images go into the file for the Strom app only", { hint: "strom export gedcom --for strom" });
         const profiles = which === "both" ? [...GED_PROFILES] : which ? [which] : ctx.settings.gedcomFor(tree.config);
         if (out && profiles.length > 1)
             throw new UsageError("--out writes one file", { hint: "add --for standard or --for strom" });
-        const results = profiles.map((p) => writeTreeGed(tree, { for: p, stromVersion: ctx.settings.stromVersion(tree.config), ...(research ? { research } : {}), ...(out ? { out } : {}) }));
+        const images = asked ? imageSettings(ctx, tree, opts) : undefined;
+        const results = profiles.map((p) => writeTreeGed(tree, {
+            for: p,
+            stromVersion: ctx.settings.stromVersion(tree.config),
+            ...(research ? { research } : {}),
+            ...(out ? { out } : {}),
+            ...(images ? { images } : {}),
+        }));
         const bad = results.filter((r) => hasGedErrors(r.findings));
         if (bad.length) {
             return {
@@ -78,8 +158,8 @@ register({
                 exitCode: 1,
             };
         }
-        // Commit the output when it lives in the tree and the evidence is intact.
-        const inTree = results.filter((r) => r.file.startsWith(tree.root + path.sep));
+        // Commit the output when it lives in the tree and the evidence is intact (the Strom file, with its images: never).
+        const inTree = results.filter((r) => r.for === "standard" && r.file.startsWith(tree.root + path.sep));
         let committed = false;
         if (inTree.length && !tree.dryRun && verifyFast(tree).findings.every((f) => f.level !== "error")) {
             const s0 = results[0].stats;
@@ -88,10 +168,20 @@ register({
         }
         const text = lines(...results.map((r) => {
             const s = r.stats;
-            return lines(`${ctx.display(r.file)} (${r.for === "strom" ? "for the Strom app" : "standard, any program"}) — ${s.persons} persons · ${s.families} families · ${s.events} facts · ${s.sources} sources${s.skipped ? ` · ${s.skipped} retracted/disproven left out` : ""}`, `  valid GEDCOM 5.5.1${r.findings.length ? ` (${r.findings.length} warning(s))` : ""}`, r.findings.length ? findingRows(r.findings) : undefined);
+            return lines(`${ctx.display(r.file)} (${r.for === "strom" ? `for the Strom app${r.images ? ", with images" : ""}` : "standard, any program"}) — ${s.persons} persons · ${s.families} families · ${s.events} facts · ${s.sources} sources${s.skipped ? ` · ${s.skipped} retracted/disproven left out` : ""}`, `  valid GEDCOM 5.5.1${r.findings.length ? ` (${r.findings.length} warning(s))` : ""}`, r.images && r.imageSettings ? imagesLines(r.images, r.imageSettings) : undefined, r.findings.length ? findingRows(r.findings) : undefined);
         }), committed ? "committed" : undefined);
         const first = results[0];
-        return { text, data: { ok: true, file: first.file, stats: first.stats, findings: first.findings, files: results.map((r) => ({ for: r.for, file: r.file, stats: r.stats, findings: r.findings })) } };
+        return {
+            text,
+            data: {
+                ok: true,
+                file: first.file,
+                stats: first.stats,
+                findings: first.findings,
+                ...(results.find((r) => r.images) ? { images: results.find((r) => r.images).images } : {}),
+                files: results.map((r) => ({ for: r.for, file: r.file, stats: r.stats, findings: r.findings })),
+            },
+        };
     },
 }, {
     path: ["gedcom", "validate"],

package/dist/commands/read.js

@@ -24,7 +24,7 @@ function range(v) {
         throw new UsageError(`invalid --images "${v}"`, { hint: "e.g. 40-69" });
     return [Number(m[1]), Number(m[2] ?? m[1])];
 }
-async function pool(items, size, fn) {
+export async function pool(items, size, fn) {
     const results = new Array(items.length);
     let next = 0;
     const worker = async () => {

package/dist/commands/readers.js

@@ -0,0 +1,62 @@
+// Readers strom starts for a whole research at once (strom clips, strom
+// transcripts): each a short run of the agent in its own folder outside the
+// tree, allowed to open the views it is given and to write its report into
+// notes/readings — never anything else. strom writes to the research from
+// what the reports say.
+import fs from "node:fs";
+import path from "node:path";
+import { StromError, UsageError } from "../core/errors.js";
+import { readerSettings } from "../core/reader.js";
+import { RUNNERS } from "../runners/index.js";
+import { which } from "../core/which.js";
+import { permissionPath } from "../agents/files.js";
+/** Set up the readers of a run (--model, --parallel, --minutes; the agent of the tree). */
+export function readers(ctx, tree, shared, kind, first, opts) {
+    const agentId = ctx.settings.agent(tree.config).value;
+    const runner = RUNNERS[agentId];
+    if (!runner)
+        throw new UsageError(`no reader for agent "${agentId}" yet`, { hint: `strom ${kind} works with Claude Code: strom ${kind} … --agent claude` });
+    if (agentId !== "script" && !which(runner.command, ctx.env))
+        throw new StromError(`${runner.command} is not installed`);
+    const model = typeof opts.model === "string" ? opts.model : ctx.settings.models(agentId, tree.config).vision;
+    const parallel = opts.parallel === undefined ? 3 : Math.max(1, Number(opts.parallel) || 1);
+    const minutes = opts.minutes === undefined ? 15 : Number(opts.minutes);
+    const day = new Date().toISOString().slice(0, 10);
+    const reportsDir = path.join(tree.root, "notes", "readings");
+    fs.mkdirSync(reportsDir, { recursive: true });
+    let stem = `${day}-${kind}`;
+    for (let n = 2; fs.existsSync(path.join(reportsDir, `${stem}-${first}-1.md`)); n++)
+        stem = `${day}-${kind}-run${n}`;
+    const work = path.join(shared, "cache", "readers");
+    const progress = (s) => (ctx.json ? ctx.io.stderr : ctx.io.stdout)(s + "\n");
+    let cost = 0;
+    const failed = [];
+    const read = async (name, views, title, prompt) => {
+        const report = path.join(reportsDir, `${stem}-${name}.md`);
+        const cwd = path.join(work, `${stem}-${name}`);
+        fs.mkdirSync(cwd, { recursive: true });
+        const settingsFile = path.join(cwd, "reader-settings.json");
+        fs.writeFileSync(settingsFile, JSON.stringify(readerSettings(views, report, permissionPath), null, 2));
+        fs.writeFileSync(report, `# ${title}\n\n`);
+        const text = prompt(report);
+        const { STROM_SESSION: _s, ...env } = ctx.env;
+        const r = await runner.run({
+            cwd,
+            prompt: text,
+            kickoff: text,
+            env: { ...env, STROM_NONINTERACTIVE: "1", STROM_READER: "1" },
+            settingsFile,
+            timeoutMs: minutes * 60_000,
+            logFile: path.join(tree.root, ".strom", "runs", `${kind}-${stem}-${name}.log`),
+            ...(model ? { model } : {}),
+        });
+        cost += r.metrics.costUsd ?? 0;
+        if (r.outcome !== "ok")
+            failed.push(`${name} (${r.outcome})`);
+        const written = fs.readFileSync(report, "utf8");
+        if (!/^##\s/m.test(written) && r.text.trim())
+            fs.appendFileSync(report, r.text.trim() + "\n");
+        return { report, text: fs.readFileSync(report, "utf8"), outcome: r.outcome };
+    };
+    return { model, parallel, stem, reportsDir, read, cost: () => cost, failed, progress };
+}

package/dist/commands/research.js

@@ -2,9 +2,13 @@
 import { register } from "../cli/registry.js";
 import { lines, table } from "../cli/format.js";
 import { addPerson, addResearch } from "../core/actions.js";
+import { applyFrontier, researchProposals } from "./session.js";
+import { phrase } from "../core/phrases.js";
 import { UsageError } from "../core/errors.js";
+import { REVIEW_SCOPES } from "../core/model.js";
 import { ancestorGenerations, displayName, label, lifespan, parentsOf, resolvePerson } from "../core/people.js";
 import { foldText } from "../core/text.js";
+import { update } from "../core/records.js";
 function int(v, name) {
     if (v === undefined)
         return undefined;
@@ -137,3 +141,61 @@ register({
         };
     },
 });
+register({
+    path: ["review"],
+    summary: "Review one person: what the tree already says of them elsewhere, entries to read whole, facts to check — as tasks",
+    group: "research",
+    tree: true,
+    writes: true,
+    description: "Sends the research straight to one person. strom looks at what is recorded and proposes the work, at\n" +
+        "most one task of each kind: what records, notes and the diary say of them outside their data; entries whose\n" +
+        "images are here but were not read whole (transcript, godparents, witnesses, house); facts resting on one\n" +
+        "reading; conflicts left open; with --reread, a second reading of what only another model read — after the\n" +
+        "agent or the model changed. Birth, parents and the story come as in any research. Run again later: what a\n" +
+        "task took up is not proposed again. Nothing is deleted; corrections go through strom with their reasons.",
+    args: [{ name: "person", description: "whom (ID or name)", required: true }],
+    options: [
+        { name: "scope", type: "string", value: "<scope>", description: "person (default), family (with partners and children), line (with the ancestors)" },
+        { name: "reread", type: "boolean", description: "also a second reading of what only another model read (the model you read with now: model.vision)" },
+        { name: "model", type: "string", value: "<model>", description: "with --reread: this model instead of model.vision" },
+    ],
+    examples: ["strom review P0001", 'strom review "Josef Novák" --scope family', "strom review P0001 --reread", "strom review P0001 --dry-run"],
+    run(ctx, { args, opts }) {
+        const tree = ctx.tree();
+        const p = resolvePerson(tree, args[0]);
+        const scope = opts.scope ?? "person";
+        if (!REVIEW_SCOPES.includes(scope))
+            throw new UsageError(`--scope must be one of ${REVIEW_SCOPES.join(", ")}`);
+        let reread;
+        if (opts.reread) {
+            reread = opts.model ?? ctx.settings.models(ctx.settings.agent(tree.config).value, tree.config).vision;
+            if (!reread)
+                throw new UsageError("--reread needs the model to read with", { hint: "strom config set model.vision <model> — or strom review … --reread --model <model>" });
+        }
+        else if (opts.model)
+            throw new UsageError("--model goes with --reread");
+        const review = { scope: scope, ...(reread ? { reread } : {}) };
+        // one review research per person: again later, it goes on where it was
+        const existing = tree.list("research").find((r) => r.direction === "person" && r.focus === p.id && r.review);
+        let research;
+        if (existing)
+            research = update(tree, existing.id, "research", (r) => ({ ...r, state: "active", review }), {
+                op: "research.edit",
+                summary: `${existing.id} review again: ${scope}${reread ? `, second reading with ${reread}` : ""}`,
+            });
+        else {
+            const r = addResearch(tree, { name: phrase(tree.lang, "review.research", { name: displayName(p) }), focus: p.id, direction: "person" });
+            research = update(tree, r.id, "research", (x) => ({ ...x, review }), { op: "research.edit", summary: `${r.id} review: ${scope}${reread ? `, second reading with ${reread}` : ""}` });
+        }
+        const planned = tree.dryRun ? researchProposals(tree, research).map((x) => x.proposal) : [];
+        const created = tree.dryRun ? [] : applyFrontier(tree, research);
+        const tasks = created.map((id) => tree.get(id)).filter((t) => !!t);
+        const open = tree.list("task").filter((t) => t.research === research.id && ["open", "doing"].includes(t.state));
+        // what a session costs here, from those so far: the user decides with the price in view
+        const costs = tree.list("session").map((s) => s.metrics?.costUsd).filter((c) => typeof c === "number");
+        const avg = costs.length ? costs.reduce((a, b) => a + b, 0) / costs.length : undefined;
+        const list = tree.dryRun ? planned.map((t) => `  would add: ${t.level} · ${t.what}`) : tasks.map((t) => `  ${t.id} ${t.level} · ${t.what}`);
+        const text = lines(...tree.written.map((o) => o.summary), tree.dryRun ? "(dry run — nothing written)" : undefined, "", list.length ? `${label(p)} — ${tree.dryRun ? planned.length : tasks.length} new task(s):` : `${label(p)} — nothing new to review${open.length ? `; ${open.length} task(s) of the review still open` : ""}`, ...list, open.length ? `${open.length} open in ${research.id}, about ${open.length} session(s)${avg !== undefined ? ` — sessions here cost $${avg.toFixed(2)} on average` : ""}` : undefined, open.length ? `next   strom run --research ${research.id}   (the agent alone) · or in a conversation: strom session start --research ${research.id}` : undefined);
+        return { text, data: { research, created: tasks, planned, open: open.map((t) => t.id), ...(avg !== undefined ? { avgCostUsd: avg } : {}) } };
+    },
+});

package/dist/commands/session.js

@@ -16,7 +16,8 @@ import { DEFAULT_BUDGET, DEFAULT_RUN_MINUTES, Settings } from "../core/config.js
 import { prependPath } from "../runners/runner.js";
 import { frontier } from "../core/frontier.js";
 import { storyProposals } from "../core/stories.js";
-import { create, requireRecord, update } from "../core/records.js";
+import { OFF_MAP_HOW, offMapLine, placesOffMap } from "../core/places.js";
+import { create, csvOpt, requireRecord, update } from "../core/records.js";
 import { taskQueue, waitingLines } from "./tasks.js";
 import { resolveResearch } from "./research.js";
 import { writeGedcoms } from "./output.js";
@@ -28,13 +29,13 @@ import { AGENTS, detectAgent, which } from "../core/which.js";
 import { keepAwake } from "../core/awake.js";
 import { stromLauncher } from "../core/self.js";
 import { phrase } from "../core/phrases.js";
-import { enterWorker } from "../core/workers.js";
-import { acquireLock } from "../core/lock.js";
+import { enterWorker, runAlive, runsAtWork } from "../core/workers.js";
 import { assertIntact, snapshot, verifyFast } from "../core/integrity.js";
 import { guard } from "../core/guard.js";
 import { hasErrors } from "../core/check.js";
 import { Tree } from "../core/tree.js";
-import { browserConnectors, routeOf } from "../core/connector.js";
+import { treeBrowserConnectors } from "../core/connector.js";
+import { reviewProposals } from "../core/review.js";
 function written(tree) {
     return lines(...tree.written.map((o) => o.summary), tree.dryRun ? "(dry run — nothing written)" : undefined);
 }
@@ -44,21 +45,29 @@ function researchOf(tree, ref) {
     const active = tree.list("research").filter((r) => r.state === "active");
     return active.length === 1 ? active[0] : undefined;
 }
-/** Create the frontier's proposed tasks, and the stories due (unless the user said no); returns their IDs. */
-export function applyFrontier(tree, research) {
-    const created = [];
-    for (const item of frontier(tree, research)) {
-        if (!item.proposal)
-            continue;
-        const t = create(tree, "task", { ...item.proposal, state: "open", origin: "frontier" }, (id) => `+${id} task "${truncate(item.proposal.what, 60)}" (frontier)`);
-        created.push(t.id);
-    }
+/** The places of facts not on the map yet, when a session ends: the few with most facts, to complete while they are fresh. */
+function offMap(tree) {
+    const off = placesOffMap(tree);
+    if (!off.length)
+        return undefined;
+    return lines(`· for the map — places of facts without coordinates (${off.length}):`, ...off.slice(0, 3).map((m) => `    ${offMapLine(m)}`), `    ${OFF_MAP_HOW} · all: strom place list --off-map`);
+}
+/** The tasks strom would propose for a research now: its frontier, the review of a person, the stories due (unless the user said no). */
+export function researchProposals(tree, research) {
+    const out = [];
+    for (const item of frontier(tree, research))
+        if (item.proposal)
+            out.push({ proposal: { ...item.proposal, origin: "frontier" }, kind: "frontier" });
+    for (const proposal of reviewProposals(tree, research))
+        out.push({ proposal, kind: "review" });
     if (new Settings(tree.env, {}).stories(tree.config).on)
-        for (const proposal of storyProposals(tree, research)) {
-            const t = create(tree, "task", { ...proposal, state: "open", origin: "frontier" }, (id) => `+${id} task "${truncate(proposal.what, 60)}" (story)`);
-            created.push(t.id);
-        }
-    return created;
+        for (const proposal of storyProposals(tree, research))
+            out.push({ proposal: { ...proposal, origin: "frontier" }, kind: "story" });
+    return out;
+}
+/** Create the tasks strom proposes for a research; returns their IDs. */
+export function applyFrontier(tree, research) {
+    return researchProposals(tree, research).map(({ proposal, kind }) => create(tree, "task", { ...proposal, state: "open" }, (id) => `+${id} task "${truncate(proposal.what, 60)}" (${kind})`).id);
 }
 /** Commit behind the same gate as every write. */
 export function commitNow(tree, message) {
@@ -139,7 +148,7 @@ register({
         const geds = tree.dryRun ? [] : writeGedcoms(ctx, tree);
         const ged = geds[0];
         return {
-            text: lines(written(tree), ged ? `GEDCOM ${geds.map((g) => ctx.display(g.file)).join(" · ")}: ${ged.stats.persons} persons, ${ged.stats.families} families` : undefined, newTasks.length ? `${newTasks.length} new task(s) from the research frontier` : undefined, 
+            text: lines(written(tree), ged ? `GEDCOM ${geds.map((g) => ctx.display(g.file)).join(" · ")}: ${ged.stats.persons} persons, ${ged.stats.families} families` : undefined, newTasks.length ? `${newTasks.length} new task(s) from the research frontier` : undefined, offMap(tree), 
             // In a conversation, the next task is best begun in a fresh context: all of this one is in strom.
             !s.runner && ctx.env.STROM_NONINTERACTIVE !== "1" ? freshContext(ctx, tree, s) : undefined),
             data: { session: closed, newTasks, ged: ged?.file, geds: geds.map((g) => g.file) },
@@ -171,7 +180,7 @@ register({
             throw new UsageError("no sessions yet");
         const m = s.metrics ?? {};
         return {
-            text: lines(`${s.id} ${s.state}${s.task ? ` · task ${s.task}` : ""}${s.runner ? ` · ${s.runner}` : ""} · ${s.started.slice(0, 16).replace("T", " ")}${s.ended ? ` – ${s.ended.slice(11, 16)}` : ""}`, s.summary ? `summary  ${s.summary}` : undefined, s.next ? `next     ${s.next}` : undefined, Object.keys(m).length
+            text: lines(`${s.id} ${s.state}${s.task ? ` · task ${s.task}` : ""}${s.runner ? ` · ${s.runner}` : ""}${s.agent && s.agent !== s.runner ? ` · ${s.agent}` : ""}${s.model ? ` · ${s.model}` : ""} · ${s.started.slice(0, 16).replace("T", " ")}${s.ended ? ` – ${s.ended.slice(11, 16)}` : ""}`, s.summary ? `summary  ${s.summary}` : undefined, s.next ? `next     ${s.next}` : undefined, Object.keys(m).length
                 ? `metrics  ${[
                     m.turns && `${m.turns} turns`,
                     m.inputTokens && `${m.inputTokens} in`,
@@ -373,9 +382,10 @@ register({
         "the tree's permissions (anything else is denied), or with the terminal (--interactive). Stops at the\n" +
         "subscription limit, when the queue is empty, or at --until (a session already running finishes, within\n" +
         "--minutes). A session longer than --minutes is stopped (its task goes back to the queue); a task that comes\n" +
-        "back twice in a row with nothing recorded is parked. Arguments after -- go to the agent CLI unchanged.",
+        "back twice in a row with nothing recorded is parked. --task picks the tasks (one session each, in that order;\n" +
+        "one done or held by another agent meanwhile is left out). Arguments after -- go to the agent CLI unchanged.",
     options: [
-        { name: "task", type: "string", value: "<T…>", description: "work on this task (default: the next one)" },
+        { name: "task", type: "string", multiple: true, value: "<T…>", description: "work on these tasks, in this order (repeatable or T0003,T0007; default: the next one of the queue)" },
         { name: "research", type: "string", value: "<G…>", description: "only tasks of this research" },
         { name: "max", type: "string", value: "<n>", description: "at most n sessions (default 1; with --until, no limit)" },
         { name: "until", type: "string", value: "<HH:MM>", description: "start no session after this time" },
@@ -384,7 +394,7 @@ register({
         { name: "model", type: "string", value: "<model>", description: "model of the main agent (default: model.lead)" },
         { name: "interactive", type: "boolean", description: "give the agent the terminal (you can talk to it)" },
     ],
-    examples: ["strom run", "strom run --max 3 --until 23:00", "strom run --interactive", "strom run --agent codex", "strom run --minutes 30 -- --add-dir ~/Scans"],
+    examples: ["strom run", "strom run --max 3 --until 23:00", "strom run --task T0003,T0007", "strom run --interactive", "strom run --agent codex", "strom run --minutes 30 -- --add-dir ~/Scans"],
     run: async (ctx, { opts, extra }) => {
         const root = ctx.tree().root;
         const treeCfg = ctx.tree().config;
@@ -396,20 +406,25 @@ register({
         if (runnerId !== "script" && !which(runner.command, ctx.env))
             throw new StromError(`${runner.command} is not installed`, { hint: runnerId === "claude" ? "install Claude Code: https://claude.com/claude-code — then log in once by running: claude" : `install ${runner.command}` });
         const until = parseUntil(opts.until);
-        const max = opts.max === undefined ? (until ? Infinity : 1) : Number(opts.max);
+        // Tasks the user picked: one session each, in their order (then the queue, when --max asks for more).
+        const picked = csvOpt(opts.task).map((id) => requireRecord(Tree.open(root, ctx.env), id, "task").id);
+        const max = opts.max === undefined ? (picked.length ? picked.length : until ? Infinity : 1) : Number(opts.max);
         if (max !== Infinity && (!Number.isInteger(max) || max < 1))
             throw new UsageError("--max must be a positive number");
         const minutes = ctx.settings.number("run.minutes", treeCfg, DEFAULT_RUN_MINUTES);
         const budget = ctx.settings.number("brief.budget", treeCfg, DEFAULT_BUDGET);
-        const release = acquireLock(path.join(root, ".strom", "run.lock"), { owner: "strom run", waitMs: 0, staleMs: 24 * 3600_000 });
+        // Each run has a name of its own (as a conversation does): several work side by side, never on one task.
+        const worker = `run-${process.pid}-${Date.now().toString(36)}`;
+        const runEnv = { ...ctx.env, STROM_WORKER: worker };
         // Present in the tree for the others at work (conversations with agents): strom shows who works.
-        const leave = enterWorker(root, "run", `${PROFILES[runnerId]?.name ?? runnerId} on its own`);
+        const beside = runsAtWork(root);
+        const leave = enterWorker(root, worker, `${PROFILES[runnerId]?.name ?? runnerId} on its own`);
         const stopAwake = keepAwake(ctx.env);
         // Progress goes to stderr when stdout carries JSON.
         const out = (s) => (ctx.json ? ctx.io.stderr : ctx.io.stdout)(s + "\n");
         const report = [];
         // Why the run stopped: a code for the exit status and for data, words for the user (their language).
-        const lang = Tree.open(root, ctx.env).lang;
+        const lang = Tree.open(root, runEnv).lang;
         let stopCode = "done";
         let stopValues = {};
         // Ctrl-C, a closed terminal, a shutdown: stop the agent, close its session, give the task back.
@@ -423,33 +438,34 @@ register({
         const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
         for (const sig of signals)
             process.on(sig, onSignal);
+        if (beside.length)
+            out(ui(lang, "ui.run.others", { since: new Date(beside[0].since).toLocaleTimeString(lang, { hour: "2-digit", minute: "2-digit" }) }));
         try {
             {
-                const tree = Tree.open(root, ctx.env);
+                const tree = Tree.open(root, runEnv);
                 assertIntact(tree);
                 const files = syncAgentFiles(tree);
                 if (files.length)
                     tree.withTreeLock(() => tree.commit(`Agent instructions: ${files.join(", ")}`, files));
-                // A session of a run that is no longer running (we hold the run lock): the run was
-                // killed or the computer went down. Close it; its task goes back to the queue.
-                for (const s of openSessions(tree).filter((x) => x.runner)) {
+                // A session of a run that is no longer at work: the run was killed or the computer went down.
+                // Close it; its task goes back to the queue. (The sessions of other runs at work stay theirs.)
+                for (const s of openSessions(tree).filter((x) => x.runner && !runAlive(root, x))) {
                     closeSession(tree, s, { summary: phrase(tree.lang, "session.run"), next: "", interrupted: true, endedBy: "run" });
                     commitNow(tree, `${s.id} interrupted: its run had stopped`);
                     out(ui(lang, "ui.run.gone", { session: s.id, back: s.task ? ui(lang, "ui.run.back", { task: s.task }) : "" }));
                 }
             }
-            const bin = shimDir(Tree.open(root, ctx.env));
+            const bin = shimDir(Tree.open(root, runEnv));
             // How the agent is let work, said once: browser tools for whose sites, and a loosening the user chose.
-            const browser = runnerId === "claude" ? browserConnectors(ctx.env, ctx.settings.shared()?.value) : [];
+            // Browser tools only for the archives this tree works with (the plugins folder is shared by every tree).
+            const browser = runnerId === "claude" ? treeBrowserConnectors(Tree.open(root, runEnv), ctx.settings.shared()?.value) : [];
             const permissions = ctx.settings.agentPermissions();
-            for (const c of browser) {
-                const chosen = routeOf(ctx.env, c).chosen;
-                out(`· ${c.name}: images through your browser — the agent gets browser tools for ${c.manifest.hosts.join(", ")}${chosen ? ` (chosen ${chosen.at.slice(0, 10)} ${chosen.by})` : ""}; Chrome with the Claude extension must be running`);
-            }
+            for (const c of browser)
+                out(ui(lang, "ui.run.browser", { name: c.manifest.title ?? c.name, hosts: c.manifest.hosts.join(", ") }));
             if (browser.length && /haiku/i.test(models.lead ?? ""))
-                out(`  note: browser tools need a model that can review its actions — Sonnet or Opus, not ${models.lead}: strom config set model.lead sonnet`);
+                out(ui(lang, "ui.run.browser.model", { model: models.lead }));
             if (permissions === "full")
-                out("· permissions: full — the agent does everything but what the tree's permissions deny (back: strom config set agent.permissions auto)");
+                out(ui(lang, "ui.run.full"));
             for (let i = 0; i < max; i++) {
                 if (stop.signal.aborted) {
                     stopCode = "user";
@@ -459,12 +475,23 @@ register({
                     stopCode = "time";
                     break;
                 }
-                const tree = Tree.open(root, ctx.env); // fresh: the agent wrote from other processes
+                const tree = Tree.open(root, runEnv); // fresh: the agent wrote from other processes
                 const research = researchOf(tree, opts.research);
                 // Other agents may be at work in this tree (conversations): never their tasks.
                 const others = othersAtWork(tree, tree.env, runnerId).tasks;
-                const free = () => taskQueue(tree, { ...(research ? { research: research.id } : {}), strategy: ctx.settings.strategy(tree.config) }).find((t) => !others.has(t.id));
-                let task = typeof opts.task === "string" && i === 0 ? requireRecord(tree, opts.task, "task") : free();
+                // Working alone: now and then a story's turn (in a conversation the user leads).
+                const free = () => taskQueue(tree, { ...(research ? { research: research.id } : {}), strategy: ctx.settings.strategy(tree.config), storyTurn: true }).find((t) => !others.has(t.id));
+                let task;
+                if (i < picked.length) {
+                    task = tree.get(picked[i]);
+                    const left = !task || !["open", "doing", "parked", "waiting"].includes(task.state) ? task?.state : others.has(task.id) ? "held" : undefined;
+                    if (left) {
+                        out(ui(lang, left === "held" ? "ui.run.skip.held" : "ui.run.skip", { task: picked[i] }));
+                        continue;
+                    }
+                }
+                else
+                    task = free();
                 if (!task && research) {
                     applyFrontier(tree, research);
                     task = free();
@@ -473,7 +500,7 @@ register({
                     stopCode = "empty";
                     break;
                 }
-                const session = startSession(tree, { task, ...(research ? { research: research.id } : {}), runner: runnerId });
+                const session = startSession(tree, { task, ...(research ? { research: research.id } : {}), runner: runnerId, ...(models.lead ? { model: models.lead } : {}) });
                 commitNow(tree, `${session.id} session started on ${task.id}`);
                 const brief = buildBrief(tree, { task, session, budget, shared: ctx.settings.shared()?.value });
                 const briefFile = path.join(root, ".strom", "briefs", `${session.id}.md`);
@@ -485,7 +512,7 @@ register({
                     brief.text;
                 const kickoff = `You are the researcher in strom session ${session.id}. Run \`strom brief\` and follow it; work only through strom; finish with \`strom session close\`.`;
                 const env = {
-                    ...prependPath(ctx.env, bin),
+                    ...prependPath(runEnv, bin),
                     STROM_SESSION: session.id,
                     ...(opts.interactive ? {} : { STROM_NONINTERACTIVE: "1" }),
                 };
@@ -508,7 +535,7 @@ register({
                     signal: stop.signal,
                 });
                 // Close what the agent left open, record the metrics, export, commit.
-                const after = Tree.open(root, ctx.env);
+                const after = Tree.open(root, runEnv);
                 let s = after.get(session.id);
                 if (s.state === "open")
                     s = closeSession(after, s, {
@@ -520,6 +547,9 @@ register({
                     });
                 else
                     update(after, s.id, "session", (x) => ({ ...x, metrics: result.metrics }), { op: "session.metrics", summary: `${s.id} metrics` });
+                // the model it really ran on, as the agent said (an alias such as "opus" names no version)
+                if (result.metrics.model && s.model !== result.metrics.model)
+                    s = update(after, s.id, "session", (x) => ({ ...x, model: result.metrics.model }), { op: "session.metrics", summary: `${s.id} model ${result.metrics.model}` });
                 // A task that comes back again and again without anything being recorded
                 // is stuck: park it (the user decides), work on the next one.
                 const back = after.get(task.id);
@@ -575,10 +605,9 @@ register({
                 process.off(sig, onSignal);
             stopAwake();
             leave();
-            release();
         }
         // What the research now waits for from the user who started it.
-        const waiting = waitingLines(Tree.open(root, ctx.env), { shared: ctx.settings.shared()?.value, display: (p) => ctx.display(p) });
+        const waiting = waitingLines(Tree.open(root, runEnv), { shared: ctx.settings.shared()?.value, display: (p) => ctx.display(p) });
         const reason = ui(lang, `ui.run.stop.${stopCode}`, stopValues);
         return {
             text: lines(ui(lang, "ui.run.summary", { n: report.length, reason }), waiting ? `\n${waiting}` : undefined),