strom-research 1.7.0 → 1.8.0

package/dist/commands/session.js

@@ -5,12 +5,14 @@
 // closes what the agent left open, exports the GEDCOM and commits. Between
 // sessions not a single token is spent.
 import fs from "node:fs";
+import { spawnSync } from "node:child_process";
 import path from "node:path";
 import { register } from "../cli/registry.js";
 import { ui } from "../cli/ui.js";
 import { lines, table, truncate } from "../cli/format.js";
 import { NeedsConsentError, UsageError, StromError } from "../core/errors.js";
 import { closeSession, currentSession, openSessions, othersAtWork, sessionNote, startSession } from "../core/session.js";
+import { reviveLive } from "../core/live.js";
 import { buildBrief } from "../brief/brief.js";
 import { DEFAULT_BUDGET, DEFAULT_RUN_MINUTES, Settings } from "../core/config.js";
 import { prependPath } from "../runners/runner.js";
@@ -28,15 +30,16 @@ import { PROFILES } from "../agents/profiles.js";
 import { AGENTS, detectAgent, isAgent, which, withoutAgentMarks } from "../core/which.js";
 import { askGate, ensureGatesDir, loadGate } from "../core/gate.js";
 import { keepAwake } from "../core/awake.js";
-import { deadlineOf, WRAP_UP_MS } from "../core/clock.js";
+import { askFinish, deadlineOf, finishAsked, WRAP_UP_MS } from "../core/clock.js";
+import { OWN_GROUP } from "../runners/runner.js";
 import { stromLauncher } from "../core/self.js";
 import { phrase } from "../core/phrases.js";
-import { enterWorker, runAlive, runsAtWork } from "../core/workers.js";
+import { enterWorker, markPaused, 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 { treeBrowserConnectors } from "../core/connector.js";
+import { agentBrowser, treeBrowserConnectors } from "../core/connector.js";
 import { browserNote } from "./connectors.js";
 import { reviewProposals } from "../core/review.js";
 function written(tree) {
@@ -70,6 +73,9 @@ export function researchProposals(tree, research) {
 }
 /** Create the tasks strom proposes for a research; returns their IDs. */
 export function applyFrontier(tree, research) {
+    // a direction paused or ended proposes nothing (resumed: what it would, at once)
+    if (research.state !== "active")
+        return [];
     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. */
@@ -102,6 +108,7 @@ register({
         if (task && !["open", "doing", "parked"].includes(task.state))
             throw new UsageError(`${task.id} is ${task.state}`);
         const s = startSession(tree, { ...(task ? { task } : {}), ...(research ? { research: research.id } : {}) });
+        reviveLive(tree.root, ctx.env);
         const brief = buildBrief(tree, { ...(task ? { task } : {}), session: s, budget: ctx.settings.number("brief.budget", tree.config, DEFAULT_BUDGET), shared: ctx.settings.shared()?.value });
         return { text: lines(written(tree), "", brief.text), data: { session: s, brief: brief.text, sections: brief.sections } };
     },
@@ -120,6 +127,30 @@ register({
         sessionNote(tree, s, args[0]);
         return { text: written(tree) };
     },
+}, {
+    path: ["session", "finish"],
+    summary: "Ask a session at work to finish now: its agent writes down what it found and closes it",
+    group: "research",
+    tree: true,
+    description: "For the user: a session of strom run (or a conversation) is told, from the next strom command its agent runs, to\n" +
+        "start nothing new, record what it has and close the session (the task back to the queue when unfinished).\n" +
+        "Nothing is stopped by force; the run it belongs to stops after it (as at the first Ctrl-C in its terminal).",
+    args: [{ name: "session", description: "session ID (default: the one open session)" }],
+    examples: ["strom session finish", "strom session finish N0001"],
+    run(ctx, { args }) {
+        const tree = ctx.tree();
+        const lang = tree.lang;
+        const open = openSessions(tree);
+        const s = args[0] ? requireRecord(tree, args[0], "session") : open.length === 1 ? open[0] : undefined;
+        if (!s && !open.length)
+            throw new UsageError(ui(lang, "ui.session.finish.none"), { hint: "strom session list" });
+        if (!s)
+            throw new UsageError(ui(lang, "ui.session.finish.which", { sessions: open.map((x) => x.id).join(", ") }), { hint: `strom session finish ${open[0].id}` });
+        if (s.state !== "open")
+            throw new UsageError(ui(lang, "ui.session.finish.closed", { session: s.id }), { hint: "strom session list" });
+        askFinish(tree.root, s.id, ctx.env.STROM_WORKER ?? "user");
+        return { text: ui(lang, "ui.session.finish.done", { session: s.id, task: s.task ?? "–" }), data: { session: s.id, task: s.task ?? null, asked: true } };
+    },
 }, {
     path: ["session", "close"],
     summary: "Finish the session: summary, next step; exports the GEDCOM and fills the task queue",
@@ -402,6 +433,7 @@ register({
         { name: "loop", type: "boolean", description: "session after session for as long as there is work (and the gate lets it)" },
         { name: "gate", type: "string", value: "<name [n]>", description: 'ask this gate before each session, with what it is given, e.g. "claude-usage 20" (default: run.gate)' },
         { name: "no-gate", type: "boolean", description: "ask no gate this time (only you: an agent cannot)" },
+        { name: "follow", type: "boolean", description: "open the Strom app to follow the work live when the first session starts (after the gate)" },
         { name: "minutes", type: "string", value: "<n>", description: `time limit of one session (default: run.minutes, ${DEFAULT_RUN_MINUTES})` },
         { name: "budget", type: "string", value: "<tokens>", description: `brief size (default: brief.budget, ${DEFAULT_BUDGET})` },
         { name: "model", type: "string", value: "<model>", description: "model of the main agent (default: model.lead)" },
@@ -439,15 +471,27 @@ register({
         const report = [];
         // What the gate answered, for the record of the run.
         const gates = [];
+        // The Strom app opened to follow the run (--follow): once, when its first session starts.
+        let followed = false;
         // Why the run stopped: a code for the exit status and for data, words for the user (their language).
         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.
+        // The first Ctrl-C while a session works: it is asked to finish (the agent writes down what it found and closes
+        // it), then the run stops — no next session. Ctrl-C again, a closed terminal, a shutdown: stop the agent now,
+        // close its session, give the task back. (Windows: the console stops the agent itself — now.)
         const stop = new AbortController();
+        let atWorkOn;
+        let finishing = false;
         const onSignal = (sig) => {
             if (stop.signal.aborted)
-                process.exit(130); // a second Ctrl-C: now
+                process.exit(130); // a third Ctrl-C: at once
+            if (sig === "SIGINT" && atWorkOn && !finishing && OWN_GROUP && !opts.interactive) {
+                finishing = true;
+                askFinish(root, atWorkOn, "user");
+                out(`\n${ui(lang, "ui.run.finishing", { session: atWorkOn })}`);
+                return;
+            }
             out(`\n${ui(lang, "ui.run.stopping")} (${sig})`);
             stop.abort();
         };
@@ -478,6 +522,10 @@ register({
             const permissions = ctx.settings.agentPermissions();
             for (const c of browser)
                 out(ui(lang, "ui.run.browser", { name: c.manifest.title ?? c.name, hosts: c.manifest.hosts.join(", ") }));
+            // agent.browser always (the user's choice): the browser in every session, for the research's archives
+            const web = runnerId === "claude" ? agentBrowser(Tree.open(root, runEnv), ctx.settings.shared()?.value) : undefined;
+            if (web?.always)
+                out(ui(lang, "ui.run.browser.always", { hosts: web.hosts.length ? web.hosts.join(", ") : "–" }));
             if (browser.length && /haiku/i.test(models.lead ?? ""))
                 out(ui(lang, "ui.run.browser.model", { model: models.lead }));
             // Archives through the browser with an agent that has no browser tools, or without the extension: said before it starts.
@@ -493,7 +541,7 @@ register({
             if (gate)
                 out(ui(lang, gateHolds ? "ui.run.gate" : "ui.run.gate.once", { name: gate.manifest.title ?? gate.name }));
             for (let i = 0; i < max; i++) {
-                if (stop.signal.aborted) {
+                if (stop.signal.aborted || finishing) {
                     stopCode = "user";
                     break;
                 }
@@ -558,7 +606,14 @@ register({
                         out(ui(lang, "ui.run.gate.wait", { at: new Date(at).toLocaleString(lang, { weekday: "short", hour: "2-digit", minute: "2-digit" }), reason: said.reason ?? "" }));
                         // nothing to do meanwhile: the computer may sleep
                         stopAwake();
-                        await pause(at - Date.now(), stop.signal);
+                        // the Strom app shows the run paused until then, not at work
+                        markPaused(root, worker, { until: new Date(at).toISOString(), ...(said.reason ? { reason: said.reason } : {}) });
+                        try {
+                            await pause(at - Date.now(), stop.signal);
+                        }
+                        finally {
+                            markPaused(root, worker, undefined);
+                        }
                         stopAwake = keepAwake(ctx.env);
                         i--; // this was no session: ask again, with the queue as it is then
                         continue;
@@ -566,6 +621,17 @@ register({
                 }
                 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}`);
+                // the Strom app followed the research and its bridge ended without a word: on its address again
+                reviveLive(root, ctx.env);
+                // The Strom app follows it from the first session on — not while the run still waits for its gate.
+                if (opts.follow && !followed) {
+                    followed = true;
+                    const { command, args: self } = stromLauncher();
+                    const app = spawnSync(command, [...self, "app", "--live"], { cwd: root, env: ctx.env, encoding: "utf8", windowsHide: true, timeout: 60_000 });
+                    const said = `${app.stdout ?? ""}${app.stderr ?? ""}`.trim();
+                    if (said)
+                        out(said);
+                }
                 // When the agent is stopped: it knows (the brief, strom's reminders near the end), and gets a few minutes more to write down what it found.
                 const deadline = Date.now() + minutes * 60_000;
                 const brief = buildBrief(tree, { task, session, budget, shared: ctx.settings.shared()?.value, deadline });
@@ -584,6 +650,7 @@ register({
                     STROM_MINUTES: String(minutes),
                     ...(opts.interactive ? {} : { STROM_NONINTERACTIVE: "1" }),
                 };
+                atWorkOn = session.id;
                 const result = await runner.run({
                     cwd: root,
                     prompt,
@@ -605,16 +672,19 @@ register({
                     ...(opts.interactive ? { interactive: true } : {}),
                     // the level for every agent (each maps it to its own switches); the browser and Remote Control are Claude Code's
                     permissions,
-                    ...(runnerId === "claude" ? { chrome: browser.length > 0, remote: ctx.settings.agentRemote() } : {}),
+                    ...(runnerId === "claude" ? { chrome: Boolean(web?.on), remote: ctx.settings.agentRemote() } : {}),
                     ...(extra?.length ? { extraArgs: extra } : {}),
                     onProgress: (l) => out(`  · ${l}`),
                     signal: stop.signal,
                 });
+                atWorkOn = undefined;
                 // Close what the agent left open, record the metrics, export, commit.
                 const after = Tree.open(root, runEnv);
                 let s = after.get(session.id);
                 // strom worked for the agent when it closed the session itself or recorded something
                 const ranStrom = s.state !== "open" || sessionWrites(after, s.id) > 0;
+                // the user asked it to finish (strom session finish, the Strom app's "finish and stop"): no next session
+                const askedToFinish = finishAsked(root, s.id) || s.endedBy === "user";
                 if (s.state === "open")
                     s = closeSession(after, s, {
                         summary: result.outcome === "stopped" ? phrase(after.lang, "session.user") : phrase(after.lang, "session.agent", { outcome: result.outcome }),
@@ -653,7 +723,7 @@ register({
                     stopCode = "problems";
                     break;
                 }
-                if (stop.signal.aborted) {
+                if (stop.signal.aborted || finishing || askedToFinish) {
                     stopCode = "user";
                     break;
                 }

package/dist/commands/setup.js

@@ -453,6 +453,9 @@ function setUserSetting(ctx, key, value) {
     // Loosening the agent's permissions is the user's decision alone.
     if (key === "agent.permissions" && raises(s.agentPermissions(), value))
         ctx.requireHuman(`Let the agent ${value === "full" ? "do everything but what the tree's permissions deny" : "work on its own, asking only about risky steps"}, without asking?`, `strom config set agent.permissions ${value}`, "agent.permissions", ui(ctx.uiLang(), value === "full" ? "ui.consent.level.full" : "ui.consent.level.auto"));
+    // The browser in every session: the user's decision alone.
+    if (key === "agent.browser" && value === "always" && s.resolve("agent.browser", ctx.hasTree() ? ctx.tree().config : undefined)?.value !== "always")
+        ctx.requireHuman("Give the agent browser tools (Claude in Chrome) in every research session?", "strom config set agent.browser always", "agent.browser", ui(ctx.uiLang(), "ui.consent.browser"));
     // Sessions steered from elsewhere (Remote Control): the user's decision alone.
     if (key === "agent.remote" && value === "on" && !s.agentRemote())
         ctx.requireHuman("Start the Claude Code sessions with Remote Control (followed and steered from claude.ai or your phone)?", "strom config set agent.remote on", "agent.remote", ui(ctx.uiLang(), "ui.consent.remote"));

package/dist/commands/start.js

@@ -16,7 +16,7 @@ import { syncAgentFiles } from "../agents/files.js";
 import { AGENTS, findAgent, isAgent, withoutAgentMarks } from "../core/which.js";
 import { DESKTOP_APPS, agentsHere, whereToTalk } from "../core/apps.js";
 import { assertIntact } from "../core/integrity.js";
-import { treeBrowserConnectors } from "../core/connector.js";
+import { agentBrowser } from "../core/connector.js";
 import { browserNote } from "./connectors.js";
 import { offerLinks } from "../cli/wizard.js";
 import { appOpensLinks, appOpensResearch, importAppUrl, installedStromApp, liveAppUrl, noticeStromApp, STROM_APP_URL, stromAppUrl } from "../core/stromapp.js";
@@ -134,7 +134,7 @@ register({
             // its research when there is one, the day.
             name: ["Strom", tree.config.name, researches.length === 1 ? researches[0].name : undefined, new Date().toLocaleDateString(lang, { day: "numeric", month: "numeric" })].filter(Boolean).join(" · "),
             shared,
-            ...(agent === "claude" ? { chrome: treeBrowserConnectors(tree, shared).length > 0, remote: ctx.settings.agentRemote() } : {}),
+            ...(agent === "claude" ? { chrome: agentBrowser(tree, shared).on, remote: ctx.settings.agentRemote() } : {}),
         };
         const args = conversationArgs(agent, base);
         if (opts.print)
@@ -263,7 +263,10 @@ register({
     tree: true,
     description: "A small web server on this computer only (127.0.0.1, a secret address), that only reads: the Strom app, opened with\n" +
         "strom app --live, takes the tree from it and hears what changes — who is at work on what, what was recorded, what\n" +
-        "waits for the user. It ends by itself when nobody asks it anything for two hours, or with strom live stop.",
+        "waits for the user. It ends by itself when nobody asks it anything for two hours, or with strom live stop.\n" +
+        "One error does not end it (a read that fails is tried again); what it did and what went wrong is in .strom/live.log.\n" +
+        "Started again it takes the address it had (its port while free), so the app following it goes on by itself;\n" +
+        "one that ended without a word is started again when a session starts.",
     examples: ["strom live", "strom live start", "strom live stop"],
     run(ctx) {
         const tree = ctx.tree();

package/dist/commands/story.js

@@ -8,6 +8,42 @@ import { approveStory, setStory, findEventOwner } from "../core/actions.js";
 import { UsageError } from "../core/errors.js";
 import { csvOpt, normId, textOpt } from "../core/records.js";
 import { resolvePerson } from "../core/people.js";
+import { foldText } from "../core/text.js";
+/**
+ * The one heading a story has is its title (--title). A first line "# …" is taken as the title when none is given,
+ * and dropped when it only repeats it; any other "# …" line stays (the Strom app shows it as a subheading).
+ */
+function titleOf(text, title) {
+    const [first = "", ...rest] = text.replace(/\r\n?/g, "\n").trimStart().split("\n");
+    const heading = /^#[ \t]+(.+?)[ \t#]*$/.exec(first)?.[1]?.trim();
+    if (!heading)
+        return { text, ...(title ? { title } : {}) };
+    if (!title?.trim())
+        return { text: rest.join("\n"), title: heading };
+    return foldText(heading) === foldText(title) ? { text: rest.join("\n"), title } : { text, title };
+}
+/**
+ * What the Strom app shows as plain text (its set: paragraphs, "## " subheadings, "- " bullets, **bold**,
+ * *italic*): said, never refused. Numbered lists count only as two such lines in a row — a date may start a line.
+ */
+function outsideSet(text) {
+    const found = [];
+    const lns = text.split("\n");
+    if (/\[[^\]\n]+\]\([^)\n]+\)/.test(text))
+        found.push("links");
+    if (lns.filter((l) => /^\s*\|.*\|\s*$/.test(l)).length >= 2)
+        found.push("tables");
+    if (lns.some((l) => /^\s*>/.test(l)))
+        found.push("quotes (> )");
+    if (/`[^`\n]+`/.test(text))
+        found.push("code");
+    if (lns.some((l, i) => /^\s*\d+[.)]\s/.test(l) && /^\s*\d+[.)]\s/.test(lns[i + 1] ?? "")))
+        found.push("numbered lists");
+    // "* 1831" is the sign of a birth, no bullet
+    if (lns.some((l) => /^\s*[*+]\s+(?!\d)/.test(l)))
+        found.push('bullets other than "- "');
+    return found;
+}
 function owner(tree, ref) {
     return /^F\d+$/i.test(ref.trim()) ? normId(ref, "family") : resolvePerson(tree, ref).id;
 }
@@ -17,8 +53,10 @@ register({
     group: "people",
     tree: true,
     writes: true,
-    description: "Every statement rests on a recorded fact: list them with --fact. Paragraphs are separated by a blank line;\n" +
-        "**bold** is kept. Writing it again replaces it (the history keeps the old one).",
+    description: "Every statement rests on a recorded fact: list them with --fact. Paragraphs are separated by a blank line.\n" +
+        "Kept: \"## subheading\" lines, \"- \" bullet lines, **bold**, *italic*; anything else shows as plain text in the\n" +
+        "Strom app. The title goes in --title (a first line \"# …\" is taken as it). Writing it again replaces it (the\n" +
+        "history keeps the old one).",
     args: [{ name: "who", description: "person (ID or name) or family (F…)", required: true }],
     options: [
         { name: "text", type: "string", value: "<text|@file>", description: "the story, in the research language" },
@@ -30,18 +68,21 @@ register({
     examples: ['strom story set P0001 --text @notes/story-P0001.md --title "The miller of Týnec" --fact E0001 --fact E0002 --note "The house is inferred from the census."'],
     run(ctx, { args, opts }) {
         const tree = ctx.tree();
-        const text = textOpt(opts.text, (p) => fs.readFileSync(ctx.resolvePath(p), "utf8"));
-        if (!text?.trim())
+        const given = textOpt(opts.text, (p) => fs.readFileSync(ctx.resolvePath(p), "utf8"));
+        if (!given?.trim())
             throw new UsageError("--text is required", { hint: "--text @notes/story.md (a file) or the text itself" });
+        const { text, title } = titleOf(given, opts.title);
         const rec = setStory(tree, owner(tree, args[0]), {
             text,
-            title: opts.title,
+            title,
             facts: csvOpt(opts.fact).map((f) => normId(f)),
             note: opts.note,
             final: Boolean(opts.final),
         });
         const missing = rec.story.facts.length === 0 ? "note: no --fact given — say which facts the story rests on" : undefined;
-        return { text: lines(...tree.written.map((o) => o.summary), tree.dryRun ? "(dry run — nothing written)" : undefined, missing), data: { story: rec.story } };
+        const outside = outsideSet(rec.story.text);
+        const plain = outside.length ? `note: the Strom app shows ${outside.join(", ")} as plain text — keep to paragraphs, "## " subheadings, "- " bullets, **bold**, *italic*` : undefined;
+        return { text: lines(...tree.written.map((o) => o.summary), tree.dryRun ? "(dry run — nothing written)" : undefined, missing, plain), data: { story: rec.story } };
     },
 }, {
     path: ["story", "approve"],

package/dist/commands/tasks.js

@@ -11,6 +11,7 @@ import { lines, moreLine, paginate, runs, table, truncate } from "../cli/format.
 import { UsageError } from "../core/errors.js";
 import { TASK_LEVELS } from "../core/model.js";
 import { create, csvOpt, listOpt, normId, requireRecord, update } from "../core/records.js";
+import { directionOf, ofResearch, scopes } from "../core/directions.js";
 import { resolvePerson } from "../core/people.js";
 import { foldText } from "../core/text.js";
 import { now, typeOfId } from "../core/tree.js";
@@ -35,11 +36,17 @@ function subjects(tree, refs) {
         return resolvePerson(tree, r).id;
     });
 }
-function defaultResearch(tree, ref) {
+/** A new task's research: the one named, else the session's that adds it, else the one active research its people belong to. */
+function defaultResearch(tree, ref, subject = []) {
     if (typeof ref === "string")
         return resolveResearch(tree, ref).id;
+    const session = typeOfId(tree.actor) === "session" ? tree.get(tree.actor) : undefined;
+    if (session?.research)
+        return session.research;
     const active = tree.list("research").filter((r) => r.state === "active");
-    return active.length === 1 ? active[0].id : undefined;
+    if (active.length === 1)
+        return active[0].id;
+    return directionOf(tree, { subject }, scopes(tree).filter((s) => s.research.state === "active"));
 }
 /** What the research waits for from outside — mostly from the user: scans to download, a book to find, a reply. */
 export function waitingForUser(tree) {
@@ -75,9 +82,10 @@ export function taskQueue(tree, filter = {}) {
     return rankedQueue(tree, filter).map((r) => r.task);
 }
 export function rankedQueue(tree, filter = {}) {
+    const scope = filter.research ? scopes(tree).find((s) => s.research.id === filter.research) : undefined;
     const tasks = tree
         .list("task")
-        .filter((t) => !filter.research || !t.research || t.research === filter.research)
+        .filter((t) => !filter.research || (scope ? ofResearch(tree, t, scope) : t.research === filter.research))
         .filter((t) => !filter.level || t.level === filter.level);
     return rankTasks(tree, tasks, filter.strategy, { storyTurn: filter.storyTurn });
 }
@@ -183,7 +191,7 @@ register({
             throw new UsageError("--priority must be 1..5");
         const where = listOpt(opts.where).map((w) => (/^[Bb]\d+$/.test(w) ? requireRecord(tree, w, "recordset").id : w));
         const subject = subjects(tree, listOpt(opts.about));
-        const research = defaultResearch(tree, opts.research);
+        const research = defaultResearch(tree, opts.research, subject);
         // The same work again: an open task of the same person and level that reads the same (or nearly, in the same
         // books) — not added; what is new goes into that one.
         if (!opts.anyway) {
@@ -278,8 +286,9 @@ register({
         }
         else {
             all = tree.list("task").filter((t) => opts.state === "all" || t.state === opts.state);
-            if (research)
-                all = all.filter((t) => t.research === research);
+            const scope = research ? scopes(tree).find((s) => s.research.id === research) : undefined;
+            if (scope)
+                all = all.filter((t) => ofResearch(tree, t, scope));
             if (opts.level)
                 all = all.filter((t) => t.level === opts.level);
         }

package/dist/commands/trees.js

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