strom-research 1.7.0 → 1.8.0

package/dist/cli/menu.js

@@ -203,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]);
@@ -246,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),
                 };
@@ -264,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);
@@ -428,6 +430,7 @@ async function pickTree(ctx, run, lang) {
     // 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)
@@ -447,6 +450,14 @@ async function pickTree(ctx, run, lang) {
         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")

package/dist/cli/ui.js

@@ -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",
@@ -771,6 +805,28 @@ export const UI = {
     "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/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/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/pack.js

@@ -14,6 +14,25 @@ import { setupWizard } from "../cli/wizard.js";
 import { isAgent } from "../core/which.js";
 import { ensureShared } from "./setup.js";
 const mb = (bytes) => (bytes / 1e6 < 10 ? (bytes / 1e6).toFixed(1) : Math.round(bytes / 1e6).toString());
+/** Where a package goes unless named: the desktop (else the home), the tree's name and the day, a free name. */
+export function defaultPackFile(ctx, tree) {
+    const base = `${safeFolderName(tree.config.name) || "tree"} ${new Date().toISOString().slice(0, 10)}`;
+    const desk = desktopDir(ctx.env);
+    const dir = fs.existsSync(desk) ? desk : userHome(ctx.env);
+    let out = path.join(dir, `${base}.zip`);
+    for (let n = 2; fs.existsSync(out); n++)
+        out = path.join(dir, `${base} (${n}).zip`);
+    return out;
+}
+/** The package with its how-to and launchers in the research language. */
+export function packTree(tree, shared, out, all) {
+    const readme = {
+        name: ui(tree.config.lang, "ui.pack.readme.file"),
+        text: ui(tree.config.lang, "ui.pack.readme", { name: tree.config.name, win: INSTALL_WINDOWS, unix: INSTALL_UNIX }),
+    };
+    const say = { extract: ui(tree.config.lang, "ui.pack.launch.extract"), failed: ui(tree.config.lang, "ui.pack.launch.failed") };
+    return writePack(tree, shared, out, { all, readme, say });
+}
 register({
     path: ["pack"],
     summary: "Pack the research into one ZIP file for someone to go on with it (the tree, the images its records stand on, the connectors)",
@@ -33,18 +52,7 @@ register({
         const shared = ctx.settings.shared().value;
         const lang = ctx.uiLang();
         const all = Boolean(opts["all-images"]);
-        const day = new Date().toISOString().slice(0, 10);
-        const base = `${safeFolderName(tree.config.name) || "tree"} ${day}`;
-        let out;
-        if (opts.out)
-            out = ctx.resolvePath(String(opts.out));
-        else {
-            const desk = desktopDir(ctx.env);
-            const dir = fs.existsSync(desk) ? desk : userHome(ctx.env);
-            out = path.join(dir, `${base}.zip`);
-            for (let n = 2; fs.existsSync(out); n++)
-                out = path.join(dir, `${base} (${n}).zip`);
-        }
+        let out = opts.out ? ctx.resolvePath(String(opts.out)) : defaultPackFile(ctx, tree);
         if (!out.toLowerCase().endsWith(".zip"))
             out += ".zip";
         if (fs.existsSync(out))
@@ -54,12 +62,7 @@ register({
             const bytes = plan.media.reduce((s, m) => s + m.size, 0);
             return { text: `dry run: would pack "${tree.config.name}" with ${plan.media.length} image(s) (${mb(bytes)} MB) into ${ctx.display(out)} — nothing written`, data: { out, plan } };
         }
-        const readme = {
-            name: ui(tree.config.lang, "ui.pack.readme.file"),
-            text: ui(tree.config.lang, "ui.pack.readme", { name: tree.config.name, win: INSTALL_WINDOWS, unix: INSTALL_UNIX }),
-        };
-        const say = { extract: ui(tree.config.lang, "ui.pack.launch.extract"), failed: ui(tree.config.lang, "ui.pack.launch.failed") };
-        const r = writePack(tree, shared, out, { all, readme, say });
+        const r = packTree(tree, shared, out, all);
         const took = r.plan.media.reduce((s, m) => s + m.size, 0);
         const text = lines(ui(lang, "ui.pack.done", { name: tree.config.name, file: ctx.display(r.file), mb: mb(r.bytes) }), ui(lang, "ui.pack.saved"), ui(lang, all ? "ui.pack.images.all" : "ui.pack.images", { n: r.plan.media.length, mb: mb(took) }), r.plan.left.count ? ui(lang, "ui.pack.left", { n: r.plan.left.count, mb: mb(r.plan.left.bytes) }) : undefined, r.plan.connectors.length ? ui(lang, "ui.pack.connectors", { list: r.plan.connectors.join(", ") }) : undefined, r.plan.left.count && r.plan.left.connectors ? ui(lang, "ui.pack.noconnector") : undefined, r.plan.missing.length ? ui(lang, "ui.pack.missing", { n: r.plan.missing.length }) : undefined, "", ui(lang, "ui.pack.send"));
         return { text, data: { file: r.file, bytes: r.bytes, manifest: r.manifest, missing: r.plan.missing } };

package/dist/commands/research.js

@@ -12,6 +12,8 @@ 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 { now } from "../core/tree.js";
+import { directionOf, scopes } from "../core/directions.js";
 import { update } from "../core/records.js";
 import { isAgent } from "../core/which.js";
 function int(v, name) {
@@ -109,7 +111,46 @@ register({
             return { text: 'no researches yet → strom research new "<name>" --new-person "<Given /Surname/>"', data: { researches: [] } };
         return { text: table(all.map((r) => researchLine(tree, r))), data: { researches: all } };
     },
-}, {
+}, ...["pause", "resume", "done"].map((act) => ({
+    path: ["research", act],
+    summary: act === "pause"
+        ? "Pause a research direction: its tasks wait out of the queue, nothing new is proposed for it"
+        : act === "resume"
+            ? "Resume a paused or finished research direction: its tasks back in the queue, what it would propose added"
+            : "End a research direction (done): its tasks leave the queue, nothing is deleted",
+    group: "research",
+    tree: true,
+    writes: true,
+    description: "The user's decision about where the research goes (an agent runs it when the user asks). Nothing is\n" +
+        "deleted: the direction's tasks stay as they are, out of the queue while it is paused or done; a session\n" +
+        "at work on one of them goes on. strom research resume brings them back.",
+    args: [{ name: "research", description: "ID (G0001) or part of the name", required: true }],
+    options: act === "resume" ? [] : [{ name: "reason", type: "string", value: "<text>", description: "why (kept as a note of the research)" }],
+    examples: act === "pause" ? ['strom research pause G0001 --reason "the family asked to wait"'] : act === "resume" ? ["strom research resume G0001"] : ["strom research done G0001"],
+    run(ctx, { args, opts }) {
+        const tree = ctx.tree();
+        const r = resolveResearch(tree, args[0]);
+        const state = act === "pause" ? "paused" : act === "resume" ? "active" : "done";
+        const reason = typeof opts.reason === "string" && opts.reason.trim() ? opts.reason.trim() : undefined;
+        const waiting = (id) => {
+            const all = scopes(tree);
+            return tree.list("task").filter((t) => ["open", "parked", "waiting"].includes(t.state) && directionOf(tree, t, all) === id).length;
+        };
+        if (r.state === state)
+            return { text: `${r.id} is ${state} already`, data: { research: r, changed: false, tasks: waiting(r.id) } };
+        const next = update(tree, r.id, "research", (x) => ({ ...x, state, stateSince: now(), notes: reason ? [...x.notes, { text: `${state}: ${reason}`, at: new Date().toISOString(), by: tree.actor }] : x.notes }), {
+            op: `research.${act}`,
+            summary: `${r.id} ${state}: ${r.name}`,
+            ...(reason ? { reason } : {}),
+        });
+        const created = act === "resume" ? applyFrontier(tree, next) : [];
+        const n = waiting(r.id);
+        return {
+            text: lines(...tree.written.map((o) => o.summary), tree.dryRun ? "(dry run — nothing written)" : undefined, act === "resume" ? `its tasks are back in the queue: ${n}` : `its tasks wait out of the queue: ${n} → strom research resume ${r.id}`),
+            data: { research: next, changed: true, tasks: n, created },
+        };
+    },
+})), {
     path: ["research", "show"],
     summary: "One research: goal, focus person, known ancestors, what is missing",
     group: "research",