strom-research 1.6.1 → 1.8.0

package/dist/cli/menu-research.js

@@ -6,6 +6,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { agentReady, droppedPaths, outOfAnswers, pause, pickPerson, subMenu, translator } from "./menu-parts.js";
 import { Tree } from "../core/tree.js";
+import { directionOf, scopes } from "../core/directions.js";
 import { displayName, lifespan } from "../core/people.js";
 import { DEATH_AFTER_YEARS, unprovenPeople } from "../core/review.js";
 import { planSync, readTreeFile, receivedSince } from "../core/sync.js";
@@ -26,10 +27,12 @@ export async function addToResearch(ctx, run, lang, root) {
             items.push({ key: "3", label: t("ui.menu.review"), act: async () => void (await reviewPerson(ctx, run, lang, root)) });
             items.push({ key: "4", label: t(noApp(ctx) ? "ui.more.sync.noapp" : "ui.more.sync"), act: async () => void (await syncTree(ctx, run, lang, root)) });
         }
+        if (tree.count("research") > 0)
+            items.push({ key: "5", label: t("ui.more.directions"), act: async () => void (await directions(ctx, run, lang, root)) });
         // only when there are some: the people no record of their own proves — last, it shows only sometimes
         const unproven = unprovenPeople(tree).filter((u) => !u.living).length;
         if (unproven)
-            items.push({ key: "5", label: t("ui.menu.unproven", { n: unproven }), act: async () => void (await reviewUnproven(ctx, run, lang, root)) });
+            items.push({ key: String(items.length + 1), label: t("ui.menu.unproven", { n: unproven }), act: async () => void (await reviewUnproven(ctx, run, lang, root)) });
         return { title: t("ui.more.title"), items };
     });
 }
@@ -175,6 +178,13 @@ export async function startDirection(ctx, run, lang, root, direction, who, name,
         : undefined;
     if (same)
         return void ctx.io.stdout(t("ui.research.exists", { name: same.name }) + "\n");
+    // …paused or ended: taken up again rather than made twice
+    const stopped = focus && direction !== "question" ? Tree.open(root, ctx.env).list("research").find((r) => r.focus === focus && r.direction === direction) : undefined;
+    if (stopped) {
+        if (await ctx.confirm(t("ui.research.resume", { name: stopped.name, state: t(`ui.dirs.${stopped.state}`) })))
+            await setDirection(ctx, run, lang, root, stopped, "resume");
+        return;
+    }
     const suggested = question ?? t(direction === "ancestors" ? "ui.research.title.ancestors" : "ui.research.title.descendants", { name });
     const title = (await ctx.ask(t("ui.research.title"), suggested)).trim();
     if (title === "0")
@@ -193,7 +203,36 @@ export async function startDirection(ctx, run, lang, root, direction, who, name,
     if (knows && knows !== "0")
         await run(["intake", `--text=${knows}`, "--research", made.id], true);
     ctx.io.stdout(t("ui.research.done", { name: made.name }) + "\n");
-    await offerChat(ctx, run, lang, root, t("ui.research.chat"), t("ui.research.say", { name: made.name }));
+    await offerChat(ctx, run, lang, root, t("ui.research.chat"), t("ui.research.say", { name: made.name, id: made.id }));
+}
+/** A direction's tasks not finished: open, at work, put aside or waiting for the user. */
+export function directionTasks(tree, research) {
+    const all = scopes(tree);
+    return tree.list("task").filter((x) => ["open", "doing", "parked", "waiting"].includes(x.state) && directionOf(tree, x, all) === research).length;
+}
+/** The directions of the research, each with how it goes and its tasks: one paused, ended or taken up again. */
+async function directions(ctx, run, lang, root) {
+    const t = translator(lang);
+    const tree = Tree.open(root, ctx.env);
+    const all = tree.list("research");
+    const label = (r) => t("ui.dirs.item", { name: r.name, state: t(`ui.dirs.${r.state}`), n: directionTasks(tree, r.id) });
+    const i = await ctx.choose(t("ui.dirs.pick"), all.map((r) => ({ label: label(r) })), all.length, { back: t("ui.browse.back") });
+    if (i === undefined)
+        return;
+    const r = all[i];
+    const acts = r.state === "active" ? ["pause", "done"] : r.state === "paused" ? ["resume", "done"] : ["resume"];
+    const a = await ctx.choose(t("ui.dirs.what", { name: r.name }), acts.map((x) => ({ label: t(`ui.dirs.do.${x}`) })), acts.length, { back: t("ui.browse.back") });
+    if (a === undefined)
+        return;
+    await setDirection(ctx, run, lang, root, r, acts[a]);
+}
+/** A direction paused, ended or taken up again (with the person's reason), and what that means for its tasks. */
+export async function setDirection(ctx, run, lang, root, r, act, reason) {
+    const t = translator(lang);
+    if ((await run(["research", act, r.id, ...(reason ? [`--reason=${reason}`] : [])], true)) !== 0)
+        return;
+    const state = act === "pause" ? "paused" : act === "resume" ? "active" : "done";
+    ctx.io.stdout(t(`ui.dirs.${state}.now`, { name: r.name, n: directionTasks(Tree.open(root, ctx.env), r.id) }) + "\n");
 }
 /** The person said no to the Strom app: it is not named. */
 const noApp = (ctx) => stromAppState(ctx.settings) === "no";

package/dist/cli/menu-settings.js

@@ -226,7 +226,9 @@ async function archives(ctx, run, lang, shared, root) {
         const saved = loadLogins(ctx.env);
         const connectors = listConnectors(shared);
         const consent = ctx.settings.connectorsConsent();
-        const agent = ctx.settings.agent(root ? Tree.open(root, ctx.env).config : undefined).value;
+        const treeConfig = root ? Tree.open(root, ctx.env).config : undefined;
+        const agent = ctx.settings.agent(treeConfig).value;
+        const always = ctx.settings.resolve("agent.browser", treeConfig)?.value === "always";
         const via = (c) => (c.manifest.policy.automation === "manual" ? "manual" : routeOf(ctx.env, c).via);
         // Each downloader on a line of its own: how its images come, and its login where it can use one.
         const lines = connectors.map((c) => {
@@ -260,6 +262,20 @@ async function archives(ctx, run, lang, shared, root) {
                         await run(["config", "set", "connectors.consent", consent ? "off" : "on"], true);
                 },
             },
+            // The browser for the agent in every session: Claude Code's alone, shown only when it does the research and is here.
+            ...(claudeHere(ctx, treeConfig)
+                ? [
+                    {
+                        key: "b",
+                        label: t("ui.archives.agentbrowser", { state: t(always ? "ui.archives.agentbrowser.always" : "ui.archives.agentbrowser.archives") }),
+                        act: async () => {
+                            out(t("ui.archives.agentbrowser.about"));
+                            if (await ctx.confirm(t(always ? "ui.archives.agentbrowser.off" : "ui.archives.agentbrowser.on"), false))
+                                await run(always ? ["config", "unset", "agent.browser"] : ["config", "set", "agent.browser", "always"], true);
+                        },
+                    },
+                ]
+                : []),
             ...switchable.map((c) => {
                 const next = via(c) === "browser" ? "direct" : "browser";
                 const name = c.manifest.title ?? c.name;

package/dist/cli/menu.js

@@ -25,7 +25,9 @@ import { liveWorkers, runsAtWork } from "../core/workers.js";
 import { askStromApp } from "./wizard.js";
 import { openForUser } from "../core/open.js";
 import { displayName } from "../core/people.js";
-import { agentReady, guarded, pause as partsPause, pickPerson, subMenu } from "./menu-parts.js";
+import { agentReady, droppedPaths, guarded, pause as partsPause, pickPerson, subMenu } from "./menu-parts.js";
+import { packPlan } from "../core/pack.js";
+import { expandHome } from "../core/paths.js";
 import { offerAgent } from "./fixes.js";
 import { addToResearch } from "./menu-research.js";
 import { waitingForYou } from "./menu-waiting.js";
@@ -201,8 +203,11 @@ export async function runMenu(ctx, run) {
                             ctx.settings.config.stromAppFollow = follow ? "yes" : "no";
                             ctx.settings.save();
                         }
-                        if (follow)
-                            await run(["app", "--live"]);
+                        // opened when the first session starts: a run may wait for its gate first
+                        if (follow) {
+                            args.push("--follow");
+                            out(t("ui.run.follow.later"));
+                        }
                     }
                     out(t("ui.run.start"));
                     await run(["run", ...args]);
@@ -244,13 +249,15 @@ export async function runMenu(ctx, run) {
                             await run(["chat", "--agent", others[i].id]);
                     },
                 };
+            // Another tree, right after the research's own items.
+            items.push({ key: "6", label: known.length > 1 ? t("ui.menu.trees") : t("ui.menu.newtree"), act: async () => pickTree(ctx, run, lang) });
             // The Strom app: open the research in it (live while an agent is at work); not known yet: what it is, and whether they want it.
             const app = stromAppState(ctx.settings);
             if (app !== "no") {
                 const atWork = liveWorkers(root).length > 0 || runsAtWork(root).length > 0;
                 const hasApp = app !== "unknown" || Boolean(installedStromApp(ctx.env, process.platform, stromAppUrl(ctx.settings)));
                 appItem = {
-                    key: "5",
+                    key: "7",
                     label: t(!hasApp ? "ui.menu.app.new" : atWork ? "ui.menu.app.watch" : "ui.menu.app"),
                     act: async () => openStromApp(ctx, run, lang, hasApp),
                 };
@@ -262,12 +269,9 @@ export async function runMenu(ctx, run) {
             // Several trees and none chosen: pick one first.
             items.push({ key: "1", label: t("ui.menu.trees"), act: async () => pickTree(ctx, run, lang) });
         }
-        // What changes nothing of the research: the newer strom, the settings of this computer (with the check), another tree.
-        // At most nine: the newer strom is taken in the settings, the line above says where.
-        const settings = { key: "6", label: t("ui.menu.settings"), act: async () => settingsMenu(ctx, run, lang, root, newer) };
+        // The settings of this computer (with the check); at most nine: the newer strom is taken in the settings, the line above says where.
+        const settings = { key: "8", label: t("ui.menu.settings"), act: async () => settingsMenu(ctx, run, lang, root, newer) };
         items.push(settings);
-        if (root)
-            items.push({ key: "8", label: known.length > 1 ? t("ui.menu.trees") : t("ui.menu.newtree"), act: async () => pickTree(ctx, run, lang) });
         // Only with several agents here: last, so that it moves no other number.
         if (other)
             items.push(other);
@@ -423,6 +427,10 @@ async function pickTree(ctx, run, lang) {
     }
     const at = known.findIndex((k) => k.root === here);
     const options = [...known.map((k) => ({ label: `${k.name}  (${ctx.display(k.root)})` })), { label: ui(lang, "ui.trees.new") }];
+    // handing a research over: this one packed, one someone sent unpacked
+    const packAt = at >= 0 ? options.push({ label: ui(lang, "ui.trees.pack", { name: known[at].name }) }) - 1 : -1;
+    const unpackAt = options.push({ label: ui(lang, "ui.trees.unpack") }) - 1;
+    const removeAt = known.length ? options.push({ label: ui(lang, "ui.trees.remove") }) - 1 : -1;
     const back = at >= 0 ? { back: ui(lang, "ui.back.stay", { name: known[at].name }) } : {};
     const i = await ctx.choose(ui(lang, "ui.trees.pick"), options, Math.max(0, at), back);
     if (i === undefined || i === at)
@@ -431,6 +439,36 @@ async function pickTree(ctx, run, lang) {
         await run(["trees", "use", known[i].root], true);
         return;
     }
+    if (i === packAt) {
+        const tree = Tree.open(known[at].root, ctx.env);
+        const shared = ctx.settings.shared().value;
+        const size = (all) => (packPlan(tree, shared, all).media.reduce((s, m) => s + m.size, 0) / 1e6).toFixed(0);
+        const which = await ctx.choose(ui(lang, "ui.pack.which"), [{ label: ui(lang, "ui.pack.opt.records", { mb: size(false) }) }, { label: ui(lang, "ui.pack.opt.all", { mb: size(true) }) }], 0, { back: ui(lang, "ui.browse.back") });
+        if (which === undefined)
+            return;
+        await run(["pack", "--tree", tree.root, ...(which === 1 ? ["--all-images"] : [])]);
+        await partsPause(ctx, lang);
+        return;
+    }
+    if (i === removeAt) {
+        const which = await ctx.choose(ui(lang, "ui.remove.which"), known.map((k) => ({ label: `${k.name}  (${ctx.display(k.root)})` })), known.length, { back: ui(lang, "ui.browse.back") }); // Enter goes back
+        if (which === undefined)
+            return;
+        await run(["trees", "remove", known[which].root]);
+        await partsPause(ctx, lang);
+        return;
+    }
+    if (i === unpackAt) {
+        const answer = (await ctx.ask(ui(lang, "ui.unpack.file"))).trim();
+        if (!answer || answer === "0")
+            return;
+        const resolve = (p) => path.resolve(ctx.cwd, expandHome(p, ctx.env));
+        const dropped = droppedPaths(answer).map(resolve);
+        const file = dropped.length === 1 && fs.existsSync(dropped[0]) ? dropped[0] : resolve(answer);
+        await run(["unpack", file]);
+        await partsPause(ctx, lang);
+        return;
+    }
     const name = (await ctx.ask(ui(lang, "ui.tree.name.new"), ui(lang, "ui.tree.default"))).trim();
     if (name === "0")
         return;

package/dist/cli/ui.js

@@ -41,8 +41,8 @@ export const UI = {
     "ui.menu.waitlist": "What waits for you",
     "ui.menu.settings": "Settings: the agent, working alone, messages, archives, the check",
     "ui.menu.doctor": "Check the installation",
-    "ui.menu.trees": "Another family tree",
-    "ui.menu.newtree": "Create a family tree",
+    "ui.menu.trees": "Another family tree · send or receive one",
+    "ui.menu.newtree": "Create a family tree · send or receive one",
     "ui.menu.quit": "Quit",
     "ui.menu.bye": "See you next time. Start again with: strom",
     "ui.run.how": "How many tasks? (it stops earlier when there is nothing to do; 0 goes back)",
@@ -104,6 +104,7 @@ export const UI = {
     "ui.menu.app.live": "The agent is at work — you can watch it live in the Strom app: choice {key}.",
     "ui.app.open.now": "Once it is installed: open the research in it?",
     "ui.run.follow": "Watch the work live in the Strom app meanwhile?",
+    "ui.run.follow.later": "The Strom app opens when the agent begins its first session.",
     "ui.app.opened": "Opening the Strom app ({where}).",
     "ui.app.browser": "in your browser",
     "ui.app.url": "Open it here: {url}",
@@ -162,6 +163,7 @@ export const UI = {
     "ui.run.stop.resets": " (resets {at})",
     "ui.run.stop.auth": "the agent is not logged in — run {command} once and log in",
     "ui.run.stop.failed": "the agent failed: {detail}",
+    "ui.run.finishing": "■ Ctrl-C: session {session} is asked to finish — the agent writes down what it found and closes it, then the run stops (no next session). Ctrl-C again stops it now.",
     "ui.run.stopping": "■ stopping — the session is closed and its task goes back to the queue; Ctrl-C again to quit at once",
     "ui.run.gone": "· {session} closed — its run had stopped{back}",
     "ui.run.back": "; {task} is back in the queue",
@@ -515,6 +517,14 @@ export const UI = {
     "ui.consent.gate.set": "Let the condition “{name}” decide when the agent working alone goes on?",
     "ui.consent.gate.unset": "Remove the condition “{name}” — the agent working alone no longer asks it?",
     "ui.consent.gate.skip": "Let the agent work on its own without the condition “{name}”?",
+    "ui.run.browser.always": "· the browser (Claude in Chrome) in every session, as you set it (agent.browser always) — without asking for {hosts}; Chrome with the Claude extension must be running",
+    "ui.consent.browser": "Give the agent browser tools (Claude in Chrome) in every research session? It works in your own Chrome — where you are signed in — for the sites of the research's archives without asking; in a conversation it asks about any other site.",
+    "ui.archives.agentbrowser": "The browser for the agent (Claude in Chrome): {state}",
+    "ui.archives.agentbrowser.archives": "only for archives through the browser",
+    "ui.archives.agentbrowser.always": "in every session",
+    "ui.archives.agentbrowser.about": "In every session, the agent can work in your own Chrome — where you are signed in — so you can ask it for anything through the browser. The sites of the research's archives without asking; in a conversation it asks about any other site, working alone it uses none other. Chrome with the Claude extension must be running.",
+    "ui.archives.agentbrowser.on": "Give the agent the browser in every session?",
+    "ui.archives.agentbrowser.off": "Back to the browser only for archives through the browser?",
     "ui.consent.remote": "Start the Claude Code sessions strom opens with Remote Control, so that you can follow and steer them from claude.ai or the Claude app on your phone?",
     "ui.consent.hook.on": "Let the hook “{name}” be told of everything saved into your researches? It is a program on this computer and does with it what it was written to do.",
     "ui.consent.hook.off": "Stop telling the hook “{name}” what is saved?",
@@ -546,6 +556,16 @@ export const UI = {
     "ui.link.what.chat.person": "a conversation with the agent ({agent}) about {person}.",
     "ui.link.chat.say": "Let us look at {person}: tell me briefly what the research knows of this person, and ask me what I want to find out.",
     "ui.link.what.review.person": "look at {person} again.",
+    "ui.link.what.direction.pause": "pause the direction “{name}”: its tasks ({n}) wait out of the queue and nothing new is proposed for it. Nothing is deleted.",
+    "ui.link.what.direction.done": "end the direction “{name}”: its tasks ({n}) leave the queue. Nothing is deleted, it can be taken up again.",
+    "ui.link.what.direction.resume": "take the direction “{name}” up again: its tasks ({n}) come back to the queue and the research proposes what is missing.",
+    "ui.link.direction.none": "Direction {id} is not in this research. Nothing was done.",
+    "ui.link.direction.cannot": "The direction “{name}” is {state} already. Nothing was done.",
+    "ui.link.direction.why": "Why? (a few words, kept with the direction; Enter: no reason)",
+    "ui.link.what.chat.research": "a conversation with the agent ({agent}) about the direction “{name}”, only its tasks.",
+    "ui.link.chat.research.say": "Let us work on the direction “{name}” ({id}), on its tasks.",
+    "ui.link.what.finish": "ask {agent} to finish session {session} ({task}): it writes down what it found and closes the session; working alone, it starts no next one.",
+    "ui.link.finish.none": "Session {session} is not at work (it has closed meanwhile). Nothing was done.",
     "ui.link.what.review.family": "look at {person} again, with the partners and children.",
     "ui.link.what.review.line": "look at {person} again, with the ancestors.",
     "ui.link.what.research.ancestors": "search for the ancestors of {person} (a new direction of the research).",
@@ -635,7 +655,7 @@ export const UI = {
     "ui.research.knows": "What do you know of it? Dates, places, stories of the family help the agent (Enter: nothing)",
     "ui.research.done": "✓ The research “{name}” is started.",
     "ui.research.chat": "Start on it with the agent now?",
-    "ui.research.say": "I started a new research, “{name}” — let us begin with it.",
+    "ui.research.say": "I started a new research, “{name}” ({id}) — let us begin with it, with its tasks.",
     "ui.settings.title": "Settings (on this computer)",
     "ui.settings.wizard": "Language, agent, model, what the agent may do alone, stories… (the setup)",
     "ui.settings.alone": "The agent working alone: {minutes} min a task · condition: {gate}",
@@ -697,6 +717,20 @@ export const UI = {
     "ui.intake.empty": "There is nothing in it to take in.",
     "ui.intake.ours": "{path} is strom's own folder (the research itself), not material of the family.",
     "ui.research.exists": "This research is there already: “{name}” — the agent goes on with it.",
+    "ui.more.directions": "The directions of the research: pause, end or take one up again",
+    "ui.dirs.pick": "Which direction?",
+    "ui.dirs.item": "{name} — {state} · tasks: {n}",
+    "ui.dirs.active": "going on",
+    "ui.dirs.paused": "paused",
+    "ui.dirs.done": "ended",
+    "ui.dirs.what": "“{name}”:",
+    "ui.dirs.do.pause": "Pause it — its tasks wait, the agent takes others",
+    "ui.dirs.do.done": "End it — its tasks leave the queue (nothing is deleted)",
+    "ui.dirs.do.resume": "Take it up again — its tasks back in the queue",
+    "ui.dirs.paused.now": "⏸ “{name}” is paused: its tasks ({n}) wait until you take it up again (here).",
+    "ui.dirs.done.now": "■ “{name}” is ended: its tasks ({n}) are out of the queue — nothing is deleted, it can be taken up again here.",
+    "ui.dirs.active.now": "▶ “{name}” goes on: its tasks ({n}) are back in the queue.",
+    "ui.research.resume": "This research is there already, {state}: “{name}”. Take it up again?",
     "ui.alone.gate.bad": "Please a number of points from 0 to 100 (e.g. 10).",
     "ui.waiting.long": "That is long for an answer here (at most {n} characters) — a link or a sentence; the rest tell the agent in a conversation.",
     "ui.settings.remote.chats": "conversations yes, working alone no",
@@ -740,6 +774,59 @@ export const UI = {
     "ui.review.next.human": "The agent takes them up in a conversation or when it works alone.",
     "ui.review.wake.human": "    to go on with it, tell the agent in a conversation",
     "ui.waiting.gone": "This one no longer waits for you — the agent has taken it up meanwhile.",
+    "ui.trees.pack": "pack \"{name}\" to send to someone (a ZIP file)",
+    "ui.trees.unpack": "a family tree someone sent you (a ZIP file)",
+    "ui.pack.which": "Which images go along?",
+    "ui.pack.opt.records": "the ones its records stand on — {mb} MB (the pages searched through the archive gives again)",
+    "ui.pack.opt.all": "all of them — {mb} MB",
+    "ui.pack.done": "Packed \"{name}\": {file} ({mb} MB)",
+    "ui.pack.saved": "  the family tree as last saved, with its history",
+    "ui.pack.images": "  images: {n} ({mb} MB) — the ones its records stand on and the ones nobody can fetch again",
+    "ui.pack.images.all": "  images: all {n} ({mb} MB)",
+    "ui.pack.left": "  left out: {n} images ({mb} MB) — pages searched through; strom fetches them from the archive again when they are needed",
+    "ui.pack.connectors": "  connectors: {list}",
+    "ui.pack.noconnector": "⚠ some images left out came through a connector that is not on this computer — nobody could fetch them again: strom pack --all-images",
+    "ui.pack.missing": "⚠ {n} image(s) the family tree names are not on this computer — not in the package",
+    "ui.pack.send": "Send the file. The one who gets it unpacks it and double-clicks Windows.cmd or macOS.command inside: strom is installed where it is missing and the research opens (with strom already: strom unpack \"<the file>\").",
+    "ui.pack.readme.file": "HOW-TO-CONTINUE.txt",
+    "ui.pack.readme": "The research \"{name}\" - how to go on with it\n=============================================\n\n1. Unpack the whole ZIP file: on Windows right click it - Extract All; on a Mac double click it.\n\n2. In the unpacked folder start, by a double click:\n     Windows:  Windows.cmd\n     macOS:    macOS.command  (the first time: right click - Open; when macOS refuses:\n               System Settings - Privacy & Security - Open Anyway)\n     Linux:    in a terminal: bash Linux.sh\n   It installs Strom Research where it is not yet (the official installer), puts the\n   research in place - the family tree among yours, the images into your shared folder,\n   all of it checked - takes it over on your computer and opens strom.\n\n3. Go on: in strom's menu, the conversation with the agent.\n\nWithout the launchers: install strom yourself\n   Windows (PowerShell):      {win}\n   macOS, Linux (Terminal):   {unix}\nthen: strom unpack \"<this ZIP file>\" (type strom unpack and a space, drag the file into\nthe terminal, press Enter) - or in strom's menu: another family tree - a family tree someone sent you.\n\nThe images the records stand on are in the package. The other pages of the books\n(searched through, nothing found on them) are not, for size - strom fetches them from\nthe archive again when they are needed.\n",
+    "ui.unpack.file": "Drag the ZIP file here (or type where it is; 0 goes back):",
+    "ui.unpack.what": "\"{name}\" (sent from strom {strom}, saved {date}): {images} image(s){connectors} → {root}",
+    "ui.unpack.ask": "Put it here and take it over on this computer?",
+    "ui.unpack.done": "\"{name}\" is here: {root}",
+    "ui.unpack.images": "  {n} image(s) into the shared folder{had}",
+    "ui.unpack.had": " ({n} were here already)",
+    "ui.unpack.connectors": "  connectors: {list}",
+    "ui.unpack.kept": "  connector {name} was here already — yours stays",
+    "ui.unpack.left": "  {n} pages searched through are not in it: strom fetches them from the archive when they are needed",
+    "ui.unpack.adopted": "  taken over on this computer",
+    "ui.unpack.next": "Go on: strom (the menu) or strom chat.",
+    "ui.unpack.same": "this research is here already: {root}",
+    "ui.unpack.person": "only the person at the computer unpacks a research (it adds connectors)",
+    "ui.pack.launch.extract": "First unpack the whole ZIP file - on Windows: right click, Extract All - then start this again from the unpacked folder.",
+    "ui.pack.launch.failed": "Strom Research could not be installed. Install it by the line in HOW-TO-CONTINUE.txt and run this again.",
+    "ui.trees.remove": "take a family tree off this computer",
+    "ui.session.finish.done": "Session {session} (task {task}) is asked to finish: its agent sees it at its next strom command, writes down what it found and closes the session.",
+    "ui.session.finish.none": "no session is at work in this research",
+    "ui.session.finish.which": "several sessions are at work ({sessions}) — say which one",
+    "ui.session.finish.closed": "session {session} is closed already",
+    "ui.remove.which": "Which family tree to take off this computer?",
+    "ui.remove.person": "only the person at the computer takes a family tree off it",
+    "ui.remove.busy": "somebody is at work on \"{name}\" right now — it can go once the work is over",
+    "ui.remove.what": "\"{name}\" ({root}) · people: {persons}",
+    "ui.remove.backup": "Pack it first as a backup, with all its images ({mb} MB)? It comes back any time with strom unpack.",
+    "ui.remove.backup.done": "  backup: {file}",
+    "ui.remove.images": "Into the trash too the images no other family tree uses ({n}, {mb} MB)?",
+    "ui.remove.type": "To confirm, type the name of the family tree ({name}) — anything else takes nothing off:",
+    "ui.remove.cancelled": "Nothing was taken off.",
+    "ui.remove.done": "\"{name}\" is in the trash.",
+    "ui.remove.live": "  the Strom app no longer follows it live",
+    "ui.remove.images.done": "  its images in the trash: {n} ({mb} MB)",
+    "ui.remove.images.folder": "{name} – images",
+    "ui.remove.backup.back": "  it comes back from the backup: strom unpack \"{file}\"",
+    "ui.remove.trash.alone": "  it comes back from the system's trash, until it is emptied",
+    "ui.remove.next": "Now you work on \"{name}\" — another one: Another family tree in the menu.",
+    "ui.remove.trash": "  or from the system's trash, until it is emptied",
 };
 /** A text for the person, in their language. */
 export function ui(lang, key, values = {}) {

package/dist/commands/connectors.js

@@ -1094,14 +1094,16 @@ async function fetchWith(ctx, c, request, recordset) {
         });
     if (recordset && request.cmd === "fetch") {
         // what is registered already is not asked for again (a part of an image is not the image)
-        const have = new Set(tree.list("media").filter((m) => m.recordset === recordset && !m.part && m.image !== undefined).map((m) => m.image));
+        // …unless its file is not here (a research handed over without its images): fetched again, put back
+        const here = (m) => fs.existsSync(path.join(shared(ctx), m.file));
+        const have = new Set(tree.list("media").filter((m) => m.recordset === recordset && !m.part && m.image !== undefined && here(m)).map((m) => m.image));
         const asked = request.images;
         request.images = asked.filter((n) => !have.has(n));
         if (!request.images.length)
             return { text: `images ${runs(asked)} of ${recordset} are registered already — nothing fetched`, data: { added: [], again: asked } };
     }
     if (recordset && request.cmd === "part") {
-        const had = tree.list("media").find((m) => m.recordset === recordset && m.image === request.image && m.part && sameRegion(m.part, request.region));
+        const had = tree.list("media").find((m) => m.recordset === recordset && m.image === request.image && m.part && sameRegion(m.part, request.region) && fs.existsSync(path.join(shared(ctx), m.file)));
         if (had)
             return { text: `part ${regionText(request.region)} of image ${request.image} of ${recordset} is registered already: ${had.id} — nothing fetched`, data: { added: [], again: [had.id] } };
     }
@@ -1158,16 +1160,18 @@ async function fetchWith(ctx, c, request, recordset) {
             ? lines(`part ${regionText(m.part)} of image ${request.image} of ${recordset} fetched and registered: ${m.id}${m.width ? ` · ${m.width}×${m.height} px` : ""}${gain ? ` · ${gain.toFixed(1)}× the detail of the whole image` : ""} · ${took}`, gain !== undefined && gain < 1.2 ? "  no sharper than the whole image: the portal gives no more detail than that" : undefined, `look at it: strom media view ${recordset}:${request.image} --crop ${regionText(m.part)} (a view of the image uses the part by itself)`)
             : res.again.length && whole && res.again.includes(whole.id) && r.images.every((i) => isWhole(i.region))
                 ? lines(`the portal's sharpest of image ${request.image} is the whole scan, registered already: ${whole.id}${whole.width ? ` · ${whole.width}×${whole.height} px` : ""} — no part needed`, `look at it: strom media view ${recordset}:${request.image} --crop ${regionText(request.region)}`)
-                : res.again.length
-                    ? lines(`that part is registered already: ${res.again.join(" ")}`, ...res.clashes.map((x) => `⚠ ${x}`))
-                    : "no part fetched";
+                : res.restored.length
+                    ? `part ${regionText(request.region)} of image ${request.image} of ${recordset} fetched again and put back (its file was not here; the same scan): ${res.restored.join(" ")} · ${took}`
+                    : res.again.length
+                        ? lines(`that part is registered already: ${res.again.join(" ")}`, ...res.clashes.map((x) => `⚠ ${x}`))
+                        : "no part fetched";
         data = { ...data, added: res.added.map((x) => ({ id: x.id, image: x.image, part: x.part })), again: res.again };
     }
     else if (recordset && r.images.length) {
         const res = registerImages(tree, shared(ctx), r.images.map((i) => ({ file: i.file, image: i.n, url: i.url, from: from(i.file), fetched })), recordset);
         const nums = res.added.map((m) => m.image).filter((n) => n !== undefined);
-        text = lines(`${res.added.length} image(s) of ${recordset}${nums.length ? ` (images ${Math.min(...nums)}–${Math.max(...nums)})` : ""} fetched and registered · ${took}`, res.again.length ? `${res.again.length} already registered` : undefined, ...res.clashes.slice(0, 10).map((x) => `⚠ ${x}`), res.woken.length ? `back in the queue (they waited for these images): ${res.woken.join(" ")}` : undefined);
-        data = { ...data, added: res.added.map((m) => ({ id: m.id, image: m.image })), again: res.again, woken: res.woken, clashes: res.clashes };
+        text = lines(res.added.length || !res.restored.length ? `${res.added.length} image(s) of ${recordset}${nums.length ? ` (images ${Math.min(...nums)}–${Math.max(...nums)})` : ""} fetched and registered · ${took}` : undefined, res.restored.length ? `${res.restored.length} image(s) of ${recordset} fetched again and put back (their file was not here; the same scan): ${res.restored.slice(0, 5).join(" ")}${res.restored.length > 5 ? " …" : ""} · ${took}` : undefined, res.again.length ? `${res.again.length} already registered` : undefined, ...res.clashes.slice(0, 10).map((x) => `⚠ ${x}`), res.woken.length ? `back in the queue (they waited for these images): ${res.woken.join(" ")}` : undefined);
+        data = { ...data, added: res.added.map((m) => ({ id: m.id, image: m.image })), again: res.again, restored: res.restored, woken: res.woken, clashes: res.clashes };
         fs.rmSync(workDir, { recursive: true, force: true });
     }
     else if (r.images.length) {
@@ -1307,7 +1311,7 @@ async function takeOver(ctx, c, result) {
         if (plan.recordset) {
             const res = registerImages(tree, shared(ctx), mine.map((t) => ({ file: t.file, image: t.item.n, url: t.item.url, from: `connector ${c.name} · your browser · ${path.basename(t.file)}`, part: t.item.region, fetched })), plan.recordset);
             added.push(...res.added.map((m) => ({ id: m.id, ...(m.image !== undefined ? { image: m.image } : {}) })));
-            again.push(...res.again);
+            again.push(...res.again, ...res.restored);
             notes.push(...res.clashes);
             woken.push(...res.woken);
             for (const t of mine)

package/dist/commands/guide.js

@@ -59,6 +59,10 @@ conversation opened anywhere, a bot on its own server)
   then tell the user what was found (strom person card …) and what comes next (strom plan), and ask
   before the next session. The next step is strom's queue: what the user wants instead becomes a
   task first (strom task add …, or strom research new …) — never search outside a session and its task.
+  The user names a research (G…) to work on: its tasks only — strom session start --research G….
+  A side of the family no direction reaches (a spouse's line) is a direction of its own: strom research
+  new --person <them>. The user wants a direction to wait or to end: strom research pause|done G… (its
+  tasks leave the queue, nothing is deleted; strom research resume G… brings them back).
   In a conversation the next task is best begun in a fresh context (Claude Code: /clear) — suggest
   it to the user; many tasks waiting: the agent working on its own (strom run, the user starts it
   from strom's menu), every task in a fresh session
@@ -153,7 +157,8 @@ THE STROM APP'S EDITS, ANOTHER FAMILY TREE (the user changed the tree in the Str
 STORIES OF THE ANCESTORS (the setting stories — on by default; strom shows it)
   Once records tell a person's life (a baptism and more facts from records), strom proposes a narrate
   task: write the story for the family book — plain words, the research language, every statement on a
-  recorded fact (strom story set P… --text @notes/story-P….md --fact E… …). More facts later: it
+  recorded fact (strom story set P… --text @notes/story-P….md --title "…" --fact E… …; paragraphs,
+  "## " subheadings, "- " bullets, **bold**, *italic* — nothing else shows in the app). More facts later: it
   proposes adding to it. Stories wait behind all the research; working alone
   (strom run), every few sessions one comes first. In a conversation the user leads: write one when they
   want it, or offer it when the research has a pause. A story is a draft until the user approves it (strom story approve P…; the Strom app asks it too). When strom says to tell

package/dist/commands/index.js

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

package/dist/commands/links.js

@@ -80,6 +80,10 @@ function who(p) {
 function aboutPerson(lang, p) {
     return ui(lang, "ui.link.chat.say", { person: who(p) });
 }
+/** The conversation's first message about one direction: its name and ID, from the research's own record. */
+function aboutDirection(lang, r) {
+    return ui(lang, "ui.link.chat.research.say", { name: r.name, id: r.id });
+}
 /** 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);
@@ -121,7 +125,8 @@ async function inTerminal(ctx, link) {
         // 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 "live":
+            return { text: "", data: { done: (await run(link.action === "open" ? [] : link.action === "live" ? ["app", "--live"] : ["app"])) === 0, action: link.action, tree: root } };
         case "update":
         case "setup":
             return end((await run([link.action])) === 0);
@@ -158,6 +163,14 @@ async function inTerminal(ctx, link) {
             const { undoSending } = await import("../cli/menu-links.js");
             return end(await undoSending(ctx, run, treeLang, root, link.intake));
         }
+        case "direction": {
+            const { directionDo } = await import("../cli/menu-links.js");
+            return end(await directionDo(ctx, run, treeLang, root, link.id, link.do));
+        }
+        case "finish": {
+            const { finishSession } = await import("../cli/menu-links.js");
+            return end(await finishSession(ctx, run, treeLang, root, link.session));
+        }
     }
     const named = "person" in link ? link.person : undefined;
     const person = named ? personOf(root, ctx, named) : undefined;
@@ -166,11 +179,20 @@ async function inTerminal(ctx, link) {
     const { asks } = await import("../cli/menu-links.js");
     switch (link.action) {
         case "chat": {
+            // one direction: its tasks only (the research's own name and ID in the first message)
+            const direction = link.research ? tree.get(link.research) : undefined;
+            if (link.research && direction?.type !== "research")
+                return said("ui.link.direction.none", { id: link.research });
             // 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 });
+            const what = direction
+                ? ui(treeLang, "ui.link.what.chat.research", { agent, name: direction.name })
+                : 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 } };
+            const first = direction ? aboutDirection(treeLang, direction) : person ? aboutPerson(treeLang, person) : undefined;
+            return { text: "", data: { done: (await run(["chat", ...(first ? [`--say=${first}`] : [])])) === 0, action: link.action, tree: root } };
         }
         case "story": {
             const { approveStory } = await import("../cli/menu-links.js");
@@ -206,6 +228,9 @@ 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 } };
+    // followed live: the bridge started (or the one running), its address into the app's window — strom app --live
+    if (link.action === "live")
+        return { text: "", data: { done: (await run(["app", "--live"], true)) === 0, action: "live", tree: root } };
     if (link.action !== "chat" && !(link.action === "conflict" && link.do === "agent"))
         return undefined;
     const tree = Tree.open(root, ctx.env);
@@ -217,6 +242,12 @@ async function withoutTerminal(ctx, link, root) {
         if (!first)
             return say(ctx, "ui.link.conflict.none", { id: link.id }, { tree: link.tree });
     }
+    else if (link.action === "chat" && link.research) {
+        const direction = tree.get(link.research);
+        if (direction?.type !== "research")
+            return say(ctx, "ui.link.direction.none", { id: link.research }, { tree: link.tree });
+        first = aboutDirection(tree.lang, direction);
+    }
     else if (link.action === "chat" && link.person) {
         const person = personOf(root, ctx, link.person);
         if (!person)
@@ -251,6 +282,7 @@ register({
         "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://live?tree=<id> — the research followed live in the app's window (strom app --live).\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" +
@@ -260,6 +292,10 @@ register({
         "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://direction?tree=<id>&id=G0002&do=pause|done|resume — a direction paused, ended (the reason asked) or\n" +
+        "taken up again (strom research pause|done|resume).\n" +
+        "strom-research://chat?tree=<id>&research=G0002 — a conversation about one direction, its tasks only.\n" +
+        "strom-research://finish?tree=<id>&session=N0012 — the session at work asked to finish (strom session finish).\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" +

package/dist/commands/media.js

@@ -26,12 +26,20 @@ export function registerImages(tree, shared, items, recordset) {
     const known = new Map(tree.list("media").filter((m) => !m.retracted).map((m) => [m.sha, m]));
     const added = [];
     const again = [];
+    const restored = [];
     const clashes = [];
     const copies = [];
     tree.withTreeLock(() => {
         for (const it of items) {
             const sha = fileSha256(it.file);
             const k = known.get(sha);
+            if (k && !tree.dryRun && !fs.existsSync(path.join(shared, k.file))) {
+                // its file is not here (a research handed over without its images): the same scan, put back where it was
+                fs.mkdirSync(path.dirname(path.join(shared, k.file)), { recursive: true });
+                fs.copyFileSync(it.file, path.join(shared, k.file));
+                restored.push(k.id);
+                continue;
+            }
             if (k) {
                 again.push(k.id);
                 // the same scan as another image: a portal serving another book's images, or a file given the wrong number
@@ -85,7 +93,7 @@ export function registerImages(tree, shared, items, recordset) {
             });
             woken.push(t.id);
         }
-    return { added, again, woken, clashes, copies };
+    return { added, again, restored, woken, clashes, copies };
 }
 function sharedDir(ctx) {
     return ctx.settings.shared().value;
@@ -264,7 +272,7 @@ register({
                     hint: "rename the files by the image number the viewer shows (9.jpg), or --image <n> for one file",
                 });
         }
-        const { added, again, woken, clashes, copies } = registerImages(tree, shared, items, recordset);
+        const { added, again, restored, woken, clashes, copies } = registerImages(tree, shared, items, recordset);
         if (opts.inbox && !tree.dryRun) {
             for (const f of files)
                 fs.rmSync(f, { force: true }); // now in the store
@@ -275,7 +283,7 @@ register({
         const nums = added.map((m) => m.image).filter((n) => n !== undefined);
         const text = lines(added.length
             ? `${added.length} image(s) registered: ${added[0].id}${added.length > 1 ? `–${added.at(-1).id}` : ""}${recordset ? ` of ${recordset}` : ""}${nums.length ? ` (images ${runs(nums)})` : ""}`
-            : "no new images", again.length ? `${again.length} already registered (same content): ${again.slice(0, 5).join(" ")}${again.length > 5 ? " …" : ""}` : undefined, ...clashes.slice(0, 10).map((c) => `⚠ ${c}`), ...copies.slice(0, 10), copies.length > 10 ? `… and ${copies.length - 10} more images with a sharper copy` : undefined, woken.length ? `back in the queue (they waited for these images): ${woken.join(" ")}` : undefined, tree.dryRun ? "(dry run — nothing written)" : undefined, added[0] ? `\nlook at one: strom media view ${recordset && added[0].image !== undefined ? `${recordset}:${added[0].image}` : added[0].id} --grid` : undefined);
+            : restored.length ? undefined : "no new images", restored.length ? `${restored.length} image(s) put back (their file was not here; the same scan): ${restored.slice(0, 5).join(" ")}${restored.length > 5 ? " …" : ""}` : undefined, again.length ? `${again.length} already registered (same content): ${again.slice(0, 5).join(" ")}${again.length > 5 ? " …" : ""}` : undefined, ...clashes.slice(0, 10).map((c) => `⚠ ${c}`), ...copies.slice(0, 10), copies.length > 10 ? `… and ${copies.length - 10} more images with a sharper copy` : undefined, woken.length ? `back in the queue (they waited for these images): ${woken.join(" ")}` : undefined, tree.dryRun ? "(dry run — nothing written)" : undefined, added[0] ? `\nlook at one: strom media view ${recordset && added[0].image !== undefined ? `${recordset}:${added[0].image}` : added[0].id} --grid` : undefined);
         return { text, data: { added: added.map((m) => ({ id: m.id, image: m.image })), again, woken, clashes, copies } };
     },
 }, {