strom-research 1.2.0 → 1.4.0

package/dist/cli/menu-parts.js

@@ -0,0 +1,140 @@
+// What the guided menu and its submenus share: an item, the loop of a submenu,
+// asking for a person, and the paths a person drops into the terminal.
+import { fileURLToPath } from "node:url";
+import { ui } from "./ui.js";
+import { Tree } from "../core/tree.js";
+import { findPersons, label } from "../core/people.js";
+import { agentsHere } from "../core/apps.js";
+import { AGENTS } from "../core/which.js";
+/** The test (or a script) gave all its answers: nothing more is asked. */
+export function outOfAnswers(ctx) {
+    return ctx.io.answers !== undefined && ctx.io.answers.length === 0;
+}
+/** "Press Enter to go back to the menu." — unless there is nobody to press it. */
+export async function pause(ctx, lang) {
+    if (!outOfAnswers(ctx))
+        await ctx.ask(ui(lang, "ui.enter"));
+}
+/**
+ * A submenu: its items (built afresh each time, so what they say is current), numbered in the order shown, 0 back.
+ * An item's act returning true leaves the submenu. An act waits for Enter itself, only after a long answer —
+ * never after 0 or a question left: the person went back, nothing to read.
+ */
+export async function subMenu(ctx, lang, build) {
+    for (;;) {
+        if (outOfAnswers(ctx))
+            return;
+        const { title, items } = build();
+        const all = [...items, { key: "0", label: ui(lang, "ui.browse.back"), act: async () => true }];
+        ctx.io.stdout("\n");
+        let n = 0;
+        // Enter goes back: an item here changes or starts something, a person picks it by its number
+        const i = await ctx.choose(title ?? "", all.map((it) => ({ key: it.key === "0" ? "0" : String(++n), label: it.label })), all.length - 1);
+        if (i === undefined)
+            return;
+        if ((await guarded(ctx, lang, all[i].act)) === true)
+            return;
+    }
+}
+/** Ask for a person by name or ID; several match: pick one. Nobody (Enter, or no answers left): undefined. */
+export async function pickPerson(ctx, lang, root, question, suggested) {
+    const tree = Tree.open(root, ctx.env);
+    for (;;) {
+        if (outOfAnswers(ctx))
+            return undefined;
+        const who = (await ctx.ask(question, suggested)).trim();
+        if (!who || who === "0")
+            return undefined;
+        const byId = /^P\d+$/i.test(who) ? tree.get(who.toUpperCase()) : undefined;
+        const hits = byId && !byId.retracted ? [byId] : findPersons(tree, who);
+        if (!hits.length)
+            ctx.io.stdout(ui(lang, "ui.review.none", { who }) + "\n");
+        else if (hits.length === 1)
+            return hits[0];
+        else {
+            const i = await ctx.choose(ui(lang, "ui.review.pick"), hits.slice(0, 9).map((p) => ({ label: label(p) })), 0, { back: ui(lang, "ui.browse.back") });
+            return i === undefined ? undefined : hits[i];
+        }
+    }
+}
+/**
+ * The paths in what a person typed or dropped into the terminal: a file dragged in comes quoted ('…', "…") or
+ * with its spaces escaped (macOS, Linux: My\ Folder), several of them separated by spaces. On Windows a backslash
+ * is the path's own, never an escape.
+ */
+export function droppedPaths(answer, platform = process.platform) {
+    const out = [];
+    let cur = "";
+    let quote;
+    let any = false;
+    const s = answer.trim();
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (quote) {
+            if (c === quote)
+                quote = undefined;
+            else
+                cur += c;
+        }
+        else if (c === "'" || c === '"') {
+            quote = c;
+            any = true;
+        }
+        else if (c === "\\" && platform !== "win32" && i + 1 < s.length) {
+            cur += s[++i];
+            any = true;
+        }
+        else if (/\s/u.test(c)) {
+            if (cur || any)
+                out.push(cur);
+            cur = "";
+            any = false;
+        }
+        else
+            cur += c;
+    }
+    if (cur || any)
+        out.push(cur);
+    // some terminals drop a file as its address: file:///Users/…/My%20Folder
+    return out.filter(Boolean).map((p) => {
+        // Git Bash on Windows: /c/Users/… is C:\Users\…
+        const drive = platform === "win32" ? /^\/([a-zA-Z])(\/.*)?$/u.exec(p) : null;
+        if (drive)
+            return `${drive[1].toUpperCase()}:${(drive[2] ?? "/").replace(/\//gu, "\\")}`;
+        if (!/^file:\/\//iu.test(p))
+            return p;
+        try {
+            return fileURLToPath(p);
+        }
+        catch {
+            return p;
+        }
+    });
+}
+/** The translator of one language, as the menu's items use it. */
+export function translator(lang) {
+    return (key, values = {}) => ui(lang, key, values);
+}
+/** Is the agent of the research on this computer — its CLI or its desktop app? Without it, nothing is offered to start with it. */
+export function agentReady(ctx, tree) {
+    const agent = ctx.settings.agent(tree).value;
+    // an agent strom does not look for (a script of the user's) is theirs to have
+    return !AGENTS.some((a) => a.id === agent) || agentsHere(ctx.env).some((a) => a.id === agent);
+}
+/** Claude Code is the agent of the research and on this computer: only then does the menu speak of what is Claude's (Remote Control, its usage). */
+export function claudeHere(ctx, tree) {
+    return ctx.settings.agent(tree).value === "claude" && agentsHere(ctx.env).some((a) => a.id === "claude" && a.cli);
+}
+/**
+ * An item's act, and what goes wrong in it said in a sentence — the menu goes on (a folder that could not be read, a
+ * command that refused): never a crash of the menu with an agent's error.
+ */
+export async function guarded(ctx, lang, act) {
+    try {
+        return await act();
+    }
+    catch (err) {
+        ctx.io.stdout(ui(lang, "ui.menu.failed", { reason: err.message }) + "\n");
+        await pause(ctx, lang);
+    }
+}

package/dist/cli/menu-research.js

@@ -0,0 +1,194 @@
+// The menu's "Add to the research": material from the family (strom intake), a
+// new direction (strom research new), one person looked at again (strom review).
+// Each an ordinary command; what the person reads is in their language, and the
+// agent takes it up in the next conversation or run.
+import fs from "node:fs";
+import path from "node:path";
+import { agentReady, droppedPaths, pause, pickPerson, subMenu, translator } from "./menu-parts.js";
+import { Tree } from "../core/tree.js";
+import { displayName } from "../core/people.js";
+import { expandHome } from "../core/paths.js";
+import { collectFiles } from "../core/media.js";
+import { BOOK_OF_SCANS, IMAGE_EXT } from "../commands/intake.js";
+export async function addToResearch(ctx, run, lang, root) {
+    const t = translator(lang);
+    await subMenu(ctx, lang, () => {
+        const items = [
+            { key: "1", label: t("ui.more.intake"), act: async () => void (await addMaterial(ctx, run, lang, root)) },
+            { key: "2", label: t("ui.more.research"), act: async () => void (await newResearch(ctx, run, lang, root)) },
+        ];
+        if (Tree.open(root, ctx.env).count("person") > 0)
+            items.push({ key: "3", label: t("ui.menu.review"), act: async () => void (await reviewPerson(ctx, run, lang, root)) });
+        return { title: t("ui.more.title"), items };
+    });
+}
+/** Files, folders or what the person knows, as inputs of the research; the agent reads them in its next work. */
+async function addMaterial(ctx, run, lang, root) {
+    const t = translator(lang);
+    const out = (line) => ctx.io.stdout(line + "\n");
+    const how = await ctx.choose(t("ui.intake.what"), [{ label: t("ui.intake.files") }, { label: t("ui.intake.text") }], 0, { back: t("ui.browse.back") });
+    if (how === undefined)
+        return;
+    let argv;
+    if (how === 1) {
+        const text = (await ctx.ask(t("ui.intake.write"))).trim();
+        if (!text || text === "0")
+            return;
+        argv = ["intake", `--text=${text}`]; // the person's words, whatever they start with
+    }
+    else {
+        let paths = await askPaths(ctx, lang, root);
+        if (!paths)
+            return;
+        // Nothing to take in (an empty folder, hidden files only): said so.
+        if (!collectFiles(paths).length)
+            return void out(t("ui.intake.empty"));
+        // A folder of many images is the scans of a book: those go to a record set, which the agent makes in a conversation —
+        // the rest is taken in.
+        const scans = paths
+            .filter((p) => fs.statSync(p).isDirectory())
+            .map((p) => ({ p, n: collectFiles([p]).filter((f) => IMAGE_EXT.has(path.extname(f).toLowerCase())).length }))
+            .filter((x) => x.n > BOOK_OF_SCANS);
+        let documents = false;
+        for (const s of scans) {
+            if (await ctx.confirm(t("ui.intake.scans", { folder: path.basename(s.p), n: s.n }), false))
+                documents = true;
+            else {
+                out(t("ui.intake.book", { folder: path.basename(s.p) }));
+                paths = paths.filter((p) => p !== s.p);
+            }
+        }
+        if (!paths.length)
+            return;
+        argv = ["intake", ...paths, ...(documents ? ["--documents"] : [])];
+    }
+    const before = Tree.open(root, ctx.env).count("input");
+    if ((await run(argv, true)) !== 0)
+        return;
+    const added = Tree.open(root, ctx.env).count("input") - before;
+    if (!added)
+        return void out(t("ui.intake.known"));
+    out(t("ui.intake.done", { n: added }));
+    await offerChat(ctx, run, lang, root, t("ui.intake.chat"), t("ui.intake.say"));
+}
+/** On with the agent now — when there is one; else it is said that the agent takes it up once it is here. */
+export async function offerChat(ctx, run, lang, root, question, say) {
+    if (!agentReady(ctx, Tree.open(root, ctx.env).config))
+        return void ctx.io.stdout(translator(lang)("ui.more.noagent") + "\n");
+    if (await ctx.confirm(question, true))
+        await run(["chat", "--say", say]);
+}
+/** Paths typed or dropped in, each one there and none of strom's own; asked again until they are, nothing (Enter, 0): undefined. */
+async function askPaths(ctx, lang, root) {
+    const t = translator(lang);
+    const own = [root, ctx.settings.home()?.value].filter((d) => Boolean(d));
+    const inside = (p, dir) => {
+        const rel = path.relative(dir, p);
+        return !rel.startsWith("..") && !path.isAbsolute(rel);
+    };
+    for (;;) {
+        if (ctx.io.answers !== undefined && ctx.io.answers.length === 0)
+            return undefined;
+        const answer = (await ctx.ask(t("ui.intake.path"))).trim();
+        if (!answer || answer === "0")
+            return undefined;
+        const resolve = (p) => path.resolve(ctx.cwd, expandHome(p, ctx.env));
+        let paths = droppedPaths(answer).map(resolve);
+        // one path with spaces, typed without quotes
+        if (paths.some((p) => !fs.existsSync(p)) && fs.existsSync(resolve(answer)))
+            paths = [resolve(answer)];
+        const missing = paths.filter((p) => !fs.existsSync(p));
+        // strom's own folders (the research, its home) are not material of the family: they would be copied into themselves
+        const ours = paths.filter((p) => own.some((d) => inside(p, d) || inside(d, p)));
+        if (ours.length)
+            ctx.io.stdout(t("ui.intake.ours", { path: ctx.display(ours[0]) }) + "\n");
+        else if (!missing.length && paths.length)
+            return paths;
+        else
+            ctx.io.stdout(t("ui.intake.missing", { path: missing.map((p) => ctx.display(p)).join(", ") || answer }) + "\n");
+    }
+}
+/** A new direction: the ancestors or the descendants of someone, or one question — and what the person knows of it. */
+async function newResearch(ctx, run, lang, root) {
+    const t = translator(lang);
+    const kinds = ["ancestors", "descendants", "question"];
+    const k = await ctx.choose(t("ui.research.kind"), [{ label: t("ui.research.ancestors") }, { label: t("ui.research.descendants") }, { label: t("ui.research.question") }], 0, {
+        back: t("ui.browse.back"),
+    });
+    if (k === undefined)
+        return;
+    const direction = kinds[k];
+    let question;
+    if (direction === "question") {
+        question = (await ctx.ask(t("ui.research.ask"))).trim();
+        if (!question || question === "0")
+            return;
+    }
+    // Whom: someone in the tree, or a new person (a name and sex; what else is known goes in as the person's words).
+    const people = Tree.open(root, ctx.env).count("person") > 0;
+    const inTree = people ? await ctx.choose(t("ui.research.whom"), [{ label: t("ui.research.known") }, { label: t("ui.research.newperson") }], 0, { back: t("ui.browse.back") }) : 1;
+    if (inTree === undefined)
+        return;
+    let who;
+    let name;
+    if (inTree === 0) {
+        const p = await pickPerson(ctx, lang, root, t("ui.review.who"));
+        if (!p)
+            return;
+        who = ["--person", p.id];
+        name = displayName(p);
+    }
+    else {
+        name = (await ctx.ask(t("ui.research.name"))).trim().replace(/\s+/gu, " ");
+        if (!name || name === "0")
+            return;
+        const sex = await ctx.choose(t("ui.research.sex"), [{ label: t("ui.research.male") }, { label: t("ui.research.female") }, { label: t("ui.research.unknown") }], 2, { back: t("ui.browse.back") });
+        if (sex === undefined)
+            return;
+        who = [`--new-person=${name}`, "--sex", ["M", "F", "U"][sex]];
+    }
+    // The same research again (this person, this direction, still going): said which one it is, nothing made.
+    const focus = who[0] === "--person" ? who[1] : undefined;
+    const same = focus && direction !== "question"
+        ? Tree.open(root, ctx.env)
+            .list("research")
+            .find((r) => r.focus === focus && r.direction === direction && r.state === "active")
+        : undefined;
+    if (same)
+        return void ctx.io.stdout(t("ui.research.exists", { name: same.name }) + "\n");
+    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")
+        return;
+    const knows = (await ctx.ask(t("ui.research.knows"))).trim();
+    const before = new Set(Tree.open(root, ctx.env)
+        .list("research")
+        .map((r) => r.id));
+    if ((await run(["research", "new", ...who, "--direction", direction, ...(question ? [`--question=${question}`] : []), "--", title || suggested], true)) !== 0)
+        return;
+    const made = Tree.open(root, ctx.env)
+        .list("research")
+        .find((r) => !before.has(r.id));
+    if (!made)
+        return;
+    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 }));
+}
+/** One person, looked at again: what the tree says of them elsewhere, what to read whole, what to check. */
+async function reviewPerson(ctx, run, lang, root) {
+    const t = translator(lang);
+    const person = await pickPerson(ctx, lang, root, t("ui.review.who"));
+    if (!person)
+        return;
+    const family = await ctx.confirm(t("ui.review.family"), false);
+    if ((await run(["review", person.id, ...(family ? ["--scope", "family"] : [])])) !== 0)
+        return pause(ctx, lang);
+    const tree = Tree.open(root, ctx.env);
+    const research = tree.list("research").find((r) => r.direction === "person" && r.focus === person.id && r.review);
+    const open = research ? tree.list("task").filter((x) => x.research === research.id && x.state === "open").length : 0;
+    if (research && open && (await ctx.confirm(t("ui.review.run", { n: open }), false)))
+        await run(["run", "--research", research.id, "--max", String(open)]);
+    await pause(ctx, lang);
+}

package/dist/cli/menu-settings.js

@@ -0,0 +1,273 @@
+// The menu's settings: what belongs to this computer and to the person alone —
+// the setup wizard, the agent working alone (its time, the condition it works
+// on under), hooks, Remote Control, logins to archives and the consent to
+// downloaders, the check of the installation. Only the user changes these; here
+// the person at the terminal does, through the ordinary commands.
+import path from "node:path";
+import { claudeHere, pause, subMenu, translator } from "./menu-parts.js";
+import { Tree } from "../core/tree.js";
+import { DEFAULT_RUN_MINUTES } from "../core/config.js";
+import { askGate, ensureGatesDir, listGates, loadGate } from "../core/gate.js";
+import { ensureHooksDir, hooksDir, listHooks } from "../core/hooks.js";
+import { listConnectors, routeOf, routesOf } from "../core/connector.js";
+import { claudeInChrome, CLAUDE_IN_CHROME_URL } from "../core/browser.js";
+import { PROFILES } from "../agents/profiles.js";
+import { loadLogins } from "../core/logins.js";
+import { claudeRemoteAtStartup } from "../agents/global.js";
+export async function settingsMenu(ctx, run, lang, root, newer) {
+    const t = translator(lang);
+    await subMenu(ctx, lang, () => {
+        ctx.settings.reload();
+        const shared = ctx.settings.shared()?.value;
+        const tree = root ? Tree.open(root, ctx.env).config : undefined;
+        const minutes = ctx.settings.number("run.minutes", tree, DEFAULT_RUN_MINUTES);
+        const gate = ctx.settings.runGate();
+        const on = ctx.settings.config.hooks ?? [];
+        const anyHook = shared ? listHooks(shared).length > 0 : false;
+        // The items always here first, in the same order; what shows only sometimes (Remote Control, a newer strom) after
+        // them — the numbers a person knows never move.
+        const items = [
+            // After the wizard the menu starts afresh: the research may be in another folder now.
+            { key: "1", label: t("ui.settings.wizard"), act: async () => (await run(["setup"]), true) },
+            { key: "2", label: t("ui.settings.alone", { minutes, gate: gate ? gateName(shared, gate) : t("ui.settings.gate.none") }), act: async () => alone(ctx, run, lang, root) },
+            {
+                key: "3",
+                label: t("ui.settings.hooks", { state: on.length ? on.join(", ") : t(anyHook ? "ui.settings.off" : "ui.hooks.nothing") }),
+                act: async () => (shared ? hooks(ctx, run, lang, shared) : undefined),
+            },
+            { key: "4", label: t("ui.settings.archives"), act: async () => archives(ctx, run, lang, shared, root) },
+            {
+                key: "5",
+                label: t("ui.menu.doctor"),
+                act: async () => {
+                    const code = await run(["doctor"]);
+                    if (code !== 0 && (await ctx.confirm(t("ui.menu.fix"), true)))
+                        await run(["doctor", "--fix"]);
+                    await pause(ctx, lang);
+                },
+            },
+        ];
+        if (claudeHere(ctx, tree)) {
+            // Claude Code may do it for its conversations itself (its own setting): what holds is said as it is.
+            const own = claudeRemoteAtStartup(ctx.env);
+            const remote = ctx.settings.agentRemote();
+            items.push({
+                key: "6",
+                label: t("ui.settings.remote", { state: t(remote ? "ui.settings.remote.both" : own ? "ui.settings.remote.chats" : "ui.settings.off") }),
+                act: async () => {
+                    ctx.io.stdout(t(own ? "ui.settings.remote.own" : "ui.settings.remote.about") + "\n");
+                    if (await ctx.confirm(t(remote ? "ui.settings.remote.off" : own ? "ui.settings.remote.onalone" : "ui.settings.remote.on"), !remote))
+                        await run(["config", "set", "agent.remote", remote ? "off" : "on"], true);
+                },
+            });
+        }
+        if (newer)
+            items.push({ key: "7", label: t("ui.menu.update", { version: newer }), act: async () => void (await run(["update"])) });
+        return { title: t("ui.settings.title"), items };
+    });
+}
+/** A gate as the user reads it: its title and what it is given ("Claude usage 10"). */
+function gateName(shared, spec) {
+    if (!shared)
+        return spec;
+    try {
+        const g = loadGate(shared, spec);
+        return [g.manifest.title ?? g.name, ...g.args].join(" ");
+    }
+    catch {
+        return spec;
+    }
+}
+/** The agent working alone: how long one session may take, and the condition it works on under (run.gate). */
+async function alone(ctx, run, lang, root) {
+    const t = translator(lang);
+    const out = (line) => ctx.io.stdout(line + "\n");
+    await subMenu(ctx, lang, () => {
+        ctx.settings.reload();
+        const shared = ctx.settings.shared()?.value;
+        const tree = root ? Tree.open(root, ctx.env).config : undefined;
+        const minutes = ctx.settings.number("run.minutes", tree, DEFAULT_RUN_MINUTES);
+        const set = ctx.settings.runGate();
+        const items = [
+            {
+                key: "1",
+                label: t("ui.alone.minutes", { minutes }),
+                act: async () => {
+                    for (;;) {
+                        const a = (await ctx.ask(t("ui.alone.minutes.ask"), String(minutes))).trim();
+                        if (a === "0" || a === String(minutes))
+                            return;
+                        const n = Number(a);
+                        // a tree with a time of its own: the change is for it, else it would not show
+                        const own = root ? ctx.settings.resolve("run.minutes", tree)?.source === "tree" : false;
+                        if (Number.isInteger(n) && n >= 5 && n <= 600)
+                            return void (await run(["config", "set", "run.minutes", String(n), ...(own ? ["--for-tree"] : [])], true));
+                        out(t("ui.alone.minutes.bad"));
+                        if (ctx.io.answers !== undefined && ctx.io.answers.length === 0)
+                            return;
+                    }
+                },
+            },
+        ];
+        if (shared)
+            items.push({
+                key: "2",
+                label: t("ui.alone.gate", { gate: set ? gateName(shared, set) : t("ui.settings.gate.none") }),
+                act: async () => {
+                    ensureGatesDir(shared);
+                    // strom's claude-usage asks Claude Code: offered only where it is
+                    const claude = claudeHere(ctx, tree);
+                    const gates = listGates(shared).filter((g) => g.name !== "claude-usage" || claude || loadGateName(set ?? "") === g.name);
+                    out(t("ui.alone.gate.about"));
+                    const current = set ? gates.findIndex((g) => g.name === loadGateName(set)) : gates.length;
+                    const i = await ctx.choose(t("ui.alone.gate.pick"), [...gates.map((g) => ({ label: g.manifest.title ?? g.name })), { label: t("ui.settings.gate.none") }], current >= 0 ? current : gates.length + 1, {
+                        back: t("ui.browse.back"),
+                    });
+                    if (i === undefined)
+                        return;
+                    if (i === gates.length) {
+                        if (set)
+                            await run(["config", "unset", "run.gate"], true);
+                        return;
+                    }
+                    const g = gates[i];
+                    const had = set && loadGateName(set) === g.name ? set.trim().split(/\s+/u).slice(1).join(" ") : undefined;
+                    let given = "";
+                    for (;;) {
+                        given = (await ctx.ask(t(g.name === "claude-usage" ? "ui.alone.gate.claude" : "ui.alone.gate.args"), had ?? (g.name === "claude-usage" ? "10" : ""))).trim();
+                        // claude-usage takes a number of points (0–100); anything else would stop every run
+                        if (g.name !== "claude-usage" || (/^\d+(?:[.,]\d+)?$/u.test(given) && Number(given.replace(",", ".")) <= 100))
+                            break;
+                        out(t("ui.alone.gate.bad"));
+                        if (ctx.io.answers !== undefined && ctx.io.answers.length === 0)
+                            return;
+                    }
+                    given = g.name === "claude-usage" ? given.replace(",", ".") : given;
+                    if (given === "0" && g.name !== "claude-usage")
+                        return;
+                    const spec = [g.name, given].filter(Boolean).join(" ");
+                    if (spec !== set)
+                        await run(["config", "set", "run.gate", spec], true);
+                },
+            });
+        if (set && shared)
+            items.push({
+                key: "3",
+                label: t("ui.alone.test"),
+                act: async () => {
+                    out(t("ui.alone.asking"));
+                    const tr = root ? Tree.open(root, ctx.env) : undefined;
+                    const agent = ctx.settings.agent(tr?.config).value;
+                    let said;
+                    try {
+                        said = askGate(loadGate(shared, set), ctx.env, { tree: tr?.root ?? "", lang: tr?.lang ?? lang, agent, model: ctx.settings.models(agent, tr?.config).lead, sessions: 0, costUsd: 0 });
+                    }
+                    catch (err) {
+                        said = { verdict: "error", reason: err.message };
+                    }
+                    const at = said.verdict === "wait" && said.waitMs
+                        ? new Date(Date.now() + said.waitMs).toLocaleString(lang, { weekday: "short", day: "numeric", month: "numeric", hour: "2-digit", minute: "2-digit" })
+                        : "";
+                    out(t(`ui.alone.said.${said.verdict}`, { at, reason: said.reason ? ` — ${said.reason}` : "" }));
+                    await pause(ctx, lang);
+                },
+            });
+        return { title: t("ui.alone.title"), items };
+    });
+}
+/** The gate's name in "claude-usage 10". */
+function loadGateName(spec) {
+    return spec.trim().split(/\s+/u)[0] ?? "";
+}
+/** Hooks: which there are, each turned on or off by the person here; none yet: how to make one. */
+async function hooks(ctx, run, lang, shared) {
+    const t = translator(lang);
+    ensureHooksDir(shared);
+    if (!listHooks(shared).length) {
+        ctx.io.stdout(t("ui.hooks.none", { readme: ctx.display(path.join(hooksDir(shared), "README.md")) }) + "\n");
+        return pause(ctx, lang);
+    }
+    await subMenu(ctx, lang, () => {
+        ctx.settings.reload();
+        const on = new Set(ctx.settings.config.hooks ?? []);
+        const items = listHooks(shared).map((h, k) => ({
+            key: String(k + 1),
+            label: t(on.has(h.name) ? "ui.hooks.on" : "ui.hooks.off", { name: h.manifest.title ?? h.name }),
+            act: async () => {
+                // on: what it will be told, and a yes (off needs none)
+                if (!on.has(h.name) && !(await ctx.confirm(t("ui.consent.hook.on", { name: h.manifest.title ?? h.name }), false)))
+                    return;
+                await run(["hook", on.has(h.name) ? "off" : "on", h.name], true);
+            },
+        }));
+        return { title: t("ui.hooks.title"), items };
+    });
+}
+/** Archives: the person's logins to portals (typed here, kept on this computer), and whether downloaders ask first. */
+async function archives(ctx, run, lang, shared, root) {
+    const t = translator(lang);
+    const out = (line) => ctx.io.stdout(line + "\n");
+    await subMenu(ctx, lang, () => {
+        ctx.settings.reload();
+        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 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) => {
+            const login = !c.manifest.login ? "" : `; ${saved[c.name] ? t("ui.archives.login.saved", { date: saved[c.name].at.slice(0, 10) }) : t("ui.archives.login.none")}`;
+            return `  • ${c.manifest.title ?? c.name} — ${t(`ui.archives.via.${via(c)}`)}${login}`;
+        });
+        // Through the browser: only Claude Code can, with the Claude in Chrome extension — said as it is here.
+        const browser = connectors.filter((c) => via(c) === "browser");
+        const names = browser.map((c) => c.manifest.title ?? c.name).join(", ");
+        const ext = browser.length && agent === "claude" ? claudeInChrome(ctx.env).extension : [];
+        const browserLine = !browser.length
+            ? undefined
+            : agent !== "claude"
+                ? t("ui.browser.agent", { names, agent: PROFILES[agent]?.name ?? agent })
+                : ext.length
+                    ? t("ui.archives.browser.ok", { browsers: ext.join(", ") })
+                    : t("ui.browser.noext", { names, url: CLAUDE_IN_CHROME_URL });
+        const withLogin = connectors.filter((c) => c.manifest.login);
+        const title = connectors.length
+            ? [t("ui.archives.title"), ...lines, "", ...(browserLine ? [browserLine] : []), t(withLogin.length ? "ui.archives.login.how" : "ui.archives.login.nobody")].join("\n")
+            : t("ui.archives.empty");
+        // A downloader that can take either way: switched here (the agents' permissions follow).
+        const switchable = connectors.filter((c) => via(c) !== "manual" && routesOf(c).includes("browser") && routesOf(c).includes("direct"));
+        const items = [
+            {
+                key: "1",
+                label: t("ui.archives.consent", { state: t(consent ? "ui.settings.on" : "ui.settings.off") }),
+                act: async () => {
+                    out(t("ui.archives.consent.about"));
+                    if (await ctx.confirm(t(consent ? "ui.archives.consent.off" : "ui.archives.consent.on"), false))
+                        await run(["config", "set", "connectors.consent", consent ? "off" : "on"], true);
+                },
+            },
+            ...switchable.map((c) => {
+                const next = via(c) === "browser" ? "direct" : "browser";
+                const name = c.manifest.title ?? c.name;
+                return {
+                    key: "s",
+                    label: t(next === "browser" ? "ui.archives.to.browser" : "ui.archives.to.direct", { title: name }),
+                    act: async () => {
+                        out(t(next === "browser" ? "ui.archives.browser.about" : "ui.archives.direct.about"));
+                        if (!(await ctx.confirm(t("ui.archives.switch"), true)))
+                            return;
+                        if ((await run(["connector", "use", c.name, "--via", next], true)) === 0)
+                            out(t(`ui.archives.now.${next}`, { title: name }));
+                    },
+                };
+            }),
+            ...withLogin.map((c) => ({
+                key: "l",
+                label: t(saved[c.name] ? "ui.archives.login.change" : "ui.archives.login.save", { title: c.manifest.title ?? c.name }),
+                act: async () => void (await run(["login", c.name])),
+            })),
+        ];
+        // at most nine
+        return { title, items: items.slice(0, 9) };
+    });
+}