strom-research 1.13.2-beta.12 → 1.13.2-beta.13

package/assets/method/waiting.md

@@ -0,0 +1,66 @@
+# Method: a conversation about what waits for the user
+
+The user picked a task that waits for them (strom's menu, What waits; the Strom
+app) and the conversation begins with it: its ID, what it waits for, where it is
+dealt with, and the other tasks waiting at the same place. The user is here to
+get it done with your help — lead them through it, one step at a time, in the
+research language.
+
+- First `strom task show T…` for the task and for each of the others named
+  with it: what it waits for, the book and its images, the folder for images
+  saved by hand, whom a request goes to, its text in `notes/`.
+- Take the tasks of one place one after another, in the order given; say which
+  one you are on.
+- The user's answer is theirs to give in strom's menu or the Strom app — never
+  record it with `strom task wake T… --answer`. What you find together you
+  record with the usual commands (a source with its transcript, the facts
+  citing it; what the user tells you: `strom intake --text "…"`).
+
+## Images saved by hand
+
+An archive that allows no automation (or whose connector cannot fetch images):
+the user saves the images, you guide them. You open nothing and download
+nothing yourself — not through a browser either.
+
+1. The book: its title and its address on the archive's site (the task shows
+   them). An archive that needs an account: the user logs in with their own.
+2. Which images: the numbers the task names, as the archive's viewer counts
+   them (the viewer's own image number, not a folio or a page printed in the
+   book).
+3. How: the viewer's download or export, as JPEG; where the viewer offers
+   none, the browser's save of the image itself.
+4. The name of each file: its image number (`9.jpg`; a zoomed-in part of it
+   `9a.jpg`).
+5. Where: the exact folder of the shared inbox the task shows — say it whole.
+
+When the user says the images are saved:
+`strom media add --inbox "<the folder>" --recordset B…` registers them and the
+task comes back to the queue (it says which images are still missing — ask for
+those). Then `strom session start T…`: its brief says how to read and record.
+Read them, record what they say, tell the user what was found
+(`strom person card P…`) and what is needed next — all in this conversation.
+
+## A letter or the family
+
+1. Help write the request: short, in the language of whoever reads it; for an
+   office or an archive whose record, which type, the place, the years and what
+   is known already (method of requests). Save the text in `notes/` and name it
+   on the task (the family: `--kind family`):
+   `strom task edit T… --kind letter --to "<the addressee>" --request notes/<file>.md`
+2. Say to whom it goes and how — e-mail, a form on the office's site, the post,
+   a call to a relative — and what to attach.
+3. Once the user says it went out (never before):
+   `strom task sent T…` — the task still waits for the reply.
+4. A reply that came as a file: `strom intake <file> --answers T…` — the file
+   becomes material of the task's people, the task comes back to the queue
+   with it (no intake task of its own). A reply the user tells you:
+   `strom intake --text "…"`, then `strom task wake T…`. The work goes on in a
+   session.
+
+## A site
+
+Say which site, where on it and what to look for there; the user looks. What
+they find is recorded (an online record read with them is a source; a hint is a
+lead: `strom intake --text "…"`), then `strom task wake T…`. A check of a site
+that keeps automated tools off (`strom task wait --check`) is the user's alone
+to answer, in strom's menu or the Strom app: say what to look at, nothing more.

package/dist/agents/files.js

@@ -69,6 +69,10 @@ the researcher; \`strom\` is your only way to read and change the research.
     either — check with \`strom net web --check <url>\`. Another way to the
     same records first; a task for the user (\`strom task wait T… --check
     <url> --on "…"\`) only if the source stays necessary.
+    What a task waits for (\`--on\`) is a sentence the user reads in strom's
+    menu: impersonal, what is needed and from whom, never addressed to them;
+    say its kind (\`--kind letter|family|web|other\`) and, when known,
+    \`--to\`, \`--request notes/<file>.md\`, \`--url\`.
 11. What strom or this tree denies you (a command, a site, a file) stays
     denied: never offer the user to change your permissions or settings,
     strom's or the tree's, to get round it — go another way, or say what was
@@ -98,7 +102,7 @@ says how it ends.)
     there, strom says how the user clears your context (Claude Code: /clear)
     — nothing is lost, strom keeps it all; suggest it in a sentence, go on
     here if they prefer. Working alone (strom run) each task starts fresh by
-    itself and nobody reads a closing message: no such advice there;
+    itself and its closing message gives no such advice;
   - what only they can do: when strom needs their consent it opens a window
     on their screen — tell them to answer it, you cannot; images a portal gives
     only by hand — strom says which ones and where to save them.
@@ -125,7 +129,9 @@ says how it ends.)
   would take — tell them, write it on their yes (\`--apply\`); a sync is
   undone with \`strom sync undo I…\`. Straight from the app: \`strom sync --app\`.
 - **What waits for them** (\`strom\` shows it): tell them plainly what to do
-  and where, one thing at a time.
+  and where, one thing at a time. A conversation that begins with a task that
+  waits for them (they picked it in the menu or the Strom app): \`strom guide
+  waiting\` says how to lead it.
 - **Results and the Strom app**: \`output/tree-strom.ged\` is the family tree
   for the Strom app (${appSite(app)}) — strom's companion: a free family
   tree app, no account, their data stay on their computer; it shows the tree,

package/dist/brief/brief.js

@@ -753,6 +753,21 @@ function archiveLine(tree, b, repo, shared, installed, qs = []) {
     }
     return parts.length ? `    archive ${a.host}: ${parts.join(" · ")}` : "";
 }
+/**
+ * The files that came for what the task waited for (Task.files: strom intake --answers, the Strom app's file to the
+ * task) — that they came, never the person's words: read each as the task's next step.
+ */
+function filesCame(task) {
+    const all = task.files ?? [];
+    if (!all.length)
+        return [];
+    const who = (by) => (by === "app" ? "from the Strom app" : by === "user" ? "from the user" : `by ${by}`);
+    return [
+        ...all.slice(-5).map((f) => `file came (${f.at.slice(0, 10)}, ${who(f.by)}; asked: ${f.asked}): ${f.input} — strom ${f.input.startsWith("M") ? "media show" : "input show"} ${f.input}`),
+        all.length > 5 ? `(files: the last 5 of ${all.length} — all: strom task show ${task.id})` : "",
+        "read what came first: it is what the task waited for (what it says is recorded as from any material; strom input done <I…> once used)",
+    ].filter(Boolean);
+}
 /**
  * What the person answered for the task (Task.answers: only theirs, through strom task wake --answer/--check in their
  * terminal, a window or strom's menu) — apart from the notes, which anybody writes — and the way on from a check.
@@ -833,7 +848,11 @@ export function buildBrief(tree, opts) {
             research?.question ? `Research question: ${research.question}` : "",
             ...(research?.notes ?? []).slice(-3).map((n) => `From the user: ${n.text}`),
             `Research language: ${langName(lang)} — ${alone ? "" : "talk to the user and "}write notes, tasks and summaries in ${langName(lang)}; transcripts stay in the original language.`,
-            alone ? "Working alone (strom run): nobody reads this session live — nothing in it is said to the user, its last words neither." : "",
+            // the user may read a run afterwards (its output, its log): every word in the research language, impersonal (N0288,
+            // N0292, N0295: a last message in English, "it waits for you")
+            alone
+                ? `Working alone (strom run): nobody answers here, but the user may read this session afterwards (the run's output, its log) — every message of yours, the last one too, in ${langName(lang)}, about the work and never addressed to the user ("waits for a check", never "waits for you"); a step only the user can take goes into strom task wait.`
+                : "",
             STROM_ONLY,
             webRule(new Settings(tree.env, {}).webPerHost(tree.config)),
             opts.deadline !== undefined ? briefClock(opts.deadline) : "",
@@ -863,6 +882,7 @@ export function buildBrief(tree, opts) {
                 ...task.notes.slice(-3).map((n) => `note:  ${n.text}`),
                 task.notes.length > 3 ? `(notes: the last 3 of ${task.notes.length} — all: strom task show ${task.id})` : "",
                 ...personAnswers(tree, task),
+                ...filesCame(task),
             ].filter(Boolean).join("\n"),
         });
         // 2. a review: what each item of the task is, as the tree has it
@@ -1265,12 +1285,12 @@ export function buildBrief(tree, opts) {
             // there are impersonal, so is what it shows of the agent's
             alone
                 ? // working alone: every task starts in a fresh session by itself; nobody reads a closing message
-                    "- the summary: plain words of the research for the record (menu, Strom app), never addressed to the user, no advice (/clear, starting anything); after strom session close you are done: no closing message"
+                    `- the summary: plain words of the research for the record (menu, Strom app), never addressed to the user, no advice (/clear, starting anything); after strom session close you are done: a last message of one line at most, in ${langName(lang)}, never addressed to the user`
                 : "- the user reads the summary (menu, Strom app): plain words, never addressed to them",
             // nobody answers a question in a run: what only the user can decide waits for them where they look (the menu's
             // What waits for you, the Strom app), their answer comes back on the task (strom task wake --answer)
             alone && task
-                ? `- a decision or a step only the user can take: strom task wait ${task.id} --on "<the question, impersonal, in the research language>" — they see it in the menu and the Strom app; a question in the summary gets no answer`
+                ? `- a decision or a step only the user can take: strom task wait ${task.id} --on "<the question, impersonal, in the research language>" — they see it in the menu and the Strom app; a question in the summary gets no answer; its kind: --kind letter|family|web|other`
                 : "",
             "- a command you need: strom help <command> (short, with examples) — the full guide: strom guide",
         ].filter(Boolean).join("\n"),

package/dist/brief/sheet.js

@@ -18,7 +18,7 @@ const LEVELS = {
     enrich: [...ALL, ...SCANS, ...ENTRY, "hypothesis add", "task wait"],
     locate: [...ALL, "place add", "place jurisdiction", "repo add", "recordset add", "fetch", "task edit", "task wait"],
     intake: [...ALL, "input sort", "input skip", "media view", ...ENTRY.filter((c) => c !== "event edit"), "person merge", "recordset add", "conflict add"],
-    request: [...ALL, "task wait"],
+    request: [...ALL, "task wait", "task sent"],
     narrate: ["task add", "note add", "story set"],
     // a task that links hypotheses to the tree (METHOD_LINKS): it reads the hypotheses and their people, and links
     links: ["hypothesis show", "hypothesis link", "hypothesis argue", "hypothesis variant", "person show", "family show", "task add", "note add", "search add"],
@@ -34,6 +34,8 @@ const RARE = {
     "source edit": ["translation", "media"],
     "recordset add": ["images"],
     grep: ["regex", "files"],
+    // what a waiting task waits for is said when it is set waiting (task wait); edit fills it for an older one
+    "task edit": ["on", "kind", "to", "request", "url"],
 };
 /** Where a source is cited — written once as +cite, the same in every command that takes all of it. */
 const CITE = ["cite", "locator", "quote", "information"];

package/dist/cli/human.js

@@ -5,6 +5,7 @@
 import { MONTHS } from "../core/gdate.js";
 import { ui } from "./ui.js";
 import { displayName } from "../core/people.js";
+import { foldText } from "../core/text.js";
 /**
  * English reads "31 Aug 1830"; the others their own numeric form ("31. 8. 1830", "31.8.1830"). A month and
  * year alone are named ("srpen 1830") — after a word ("před 3/1853") in numbers, which no grammatical case bends.
@@ -121,8 +122,32 @@ export function humanPlace(place, house, lang) {
         return place ?? "";
     return ui(lang, "ui.card.house", { place: place ?? "", house }).replace(/^[,\s]+/, "");
 }
-/** What the agent wrote into a task, for the user: the records it names by ID by their names ("S0001" → its title). */
-export function humanTask(tree, text, lang) {
+/** The words of a person's name, folded: what a text that names them may decline ("Václava" for Václav). */
+function nameWords(p) {
+    return foldText(displayName(p)).split(/[^\p{L}\p{M}\p{N}]+/u).filter((w) => w.length >= 2);
+}
+/** Does a word name one of these (its stem: the first letters but the last, five at most)? */
+function namesOne(word, names) {
+    return names.some((n) => {
+        const k = Math.min(5, Math.max(2, n.length - 1));
+        return word.length >= k && word.slice(0, k) === n.slice(0, k);
+    });
+}
+/**
+ * What the agent wrote into a task, for the user: the records it names by ID by their names ("S0001" → its title).
+ * `asWritten`: a person's ID right after their name in the text stays the bare ID in brackets ("Václava Nováka P0001" →
+ * "Václava Nováka [P0001]"), never the name said twice — the short lines of What waits.
+ */
+export function humanTask(tree, text, lang, o = {}) {
+    const named = (id, before) => {
+        const p = tree.get(id);
+        if (p?.type !== "person")
+            return false;
+        // the two words before the ID (letters only, none of them an ID)
+        const words = foldText(before.slice(-60)).split(/[^\p{L}\p{M}\p{N}]+/u).filter(Boolean).slice(-2).filter((w) => !/^[pfsbn]\d{4,}$/u.test(w));
+        const names = nameWords(p);
+        return words.some((w) => namesOne(w, names));
+    };
     const name = (id) => {
         const r = tree.get(id);
         if (!r)
@@ -136,5 +161,5 @@ export function humanTask(tree, text, lang) {
         return r.title;
     };
     // A list of IDs as a list of names, each once (two sessions of one day read as one).
-    return text.replace(/\b[PFSBN]\d{4,}\b(?:, [PFSBN]\d{4,}\b)*/g, (ids) => [...new Set(ids.split(", ").map(name))].join(", "));
+    return text.replace(/\b[PFSBN]\d{4,}\b(?:, [PFSBN]\d{4,}\b)*/g, (ids, at) => o.asWritten && !ids.includes(",") && named(ids, text.slice(0, at)) ? `[${ids}]` : [...new Set(ids.split(", ").map(name))].join(", "));
 }

package/dist/cli/menu-archives.js

@@ -12,64 +12,16 @@ import { Tree } from "../core/tree.js";
 import { isArchive } from "../core/mode.js";
 import { bareHost, listConnectors, routeOf, routesOf } from "../core/connector.js";
 import { claimOf, loadArchives, rank } from "../core/terms.js";
-import { archiveQuestions, connectorFor, levelWords, tasksStanding, tasksWaitingOn, termsText, waysOffered, wokenLines } from "../core/archiveasks.js";
+import { connectorFor, levelWords, tasksStanding, tasksWaitingOn, termsText, waysOffered, wokenLines } from "../core/archiveasks.js";
 import { wakeForArchive } from "../core/archivewait.js";
-import { archivesOverview, levelsOf, paceFor } from "../commands/archives.js";
-/** A pace in the person's words: "one image at most every 10 s, at most 120 an hour". */
+import { archivesOverview, capWords, levelsOf, paceFor } from "../commands/archives.js";
+/** A pace in the person's words: "one image at most every 10 s, at most 120 requests … an hour" — or no hourly cap. */
 export function paceWords(lang, p) {
-    const n = p.perHour === null || !Number.isFinite(p.perHour) ? "∞" : p.perHour;
-    return ui(lang, "ui.archive.pace", { seconds: secondsIn(lang, p.minIntervalMs), n });
+    return ui(lang, "ui.archive.pace", { seconds: secondsIn(lang, p.minIntervalMs), cap: capWords(lang, p.perHour, true) });
 }
 function connectorsHere(ctx) {
     return listConnectors(ctx.settings.shared()?.value, ctx.env);
 }
-/** The question's lines in What waits: the archive, its terms (strom's quote, or the connector's reading), the tasks. */
-function permissionLines(ctx, t, lang, tree, q) {
-    const tasks = tree ? tasksStanding(tree, q) : [];
-    return [
-        `    ${termsText(lang, ctx.env, q)}`,
-        ...(tasks.length ? [`    ${t("ui.archive.item.tasks", { ids: tasks.join(", ") })}`] : []),
-        // since when it waits (the first time asked) and how many times a command needed it
-        `    ${t("ui.archive.item.since", { date: humanDay(q.at, lang), tries: q.tries ?? 1 })}`,
-    ];
-}
-/** A question the menu can put: its archive named (a permission, a milder reading), the connectors taken over. */
-const answerable = (q) => (q.kind === "takeover" ? !!q.connectors?.length : !!q.host && (q.kind === "permission" || !!q.connector));
-/** One question in What waits: its text, the label of its item, what choosing it does. */
-export function archiveItems(ctx, run, lang, root, start, max) {
-    const t = translator(lang);
-    const tree = Tree.open(root, ctx.env);
-    const qs = archiveQuestions(tree).filter(answerable);
-    const text = [];
-    const items = [];
-    const connectors = qs.length ? connectorsHere(ctx) : [];
-    for (const q of qs) {
-        if (items.length >= max)
-            break;
-        const k = start + items.length + 1;
-        if (q.kind === "permission" && q.host) {
-            const title = q.title ?? q.host;
-            text.push("", ` ${k}. ${t("ui.archive.item", { title, host: q.host })}`, ...permissionLines(ctx, t, lang, tree, q));
-            items.push({ key: String(k), label: t("ui.archive.item.read", { k, title }), act: async () => void (await decideArchive(ctx, run, lang, root, q.host, q)) });
-        }
-        else if (q.kind === "takeover" && q.connectors?.length) {
-            const names = q.connectors.map((n) => connectors.find((c) => c.name === n)?.manifest.title ?? n);
-            text.push("", ` ${k}. ${t("ui.archive.takeover.item", { n: names.length, names: names.join(", ") })}`);
-            items.push({ key: String(k), label: t("ui.archive.takeover.read", { k }), act: () => decideTakeover(ctx, run, lang, q) });
-        }
-        else if (q.kind === "milder" && q.host && q.connector) {
-            const c = connectors.find((x) => x.name === q.connector);
-            const title = c?.manifest.title ?? q.title ?? q.connector;
-            text.push("", ` ${k}. ${t("ui.archive.milder.item", { title, host: q.host, to: levelWords(lang, q.to ?? "allowed"), from: levelWords(lang, q.from ?? "restricted") })}`);
-            items.push({ key: String(k), label: t("ui.archive.milder.read", { k, title }), act: () => decideMilder(ctx, run, lang, q, title) });
-        }
-    }
-    return { text, items, count: qs.length };
-}
-/** How many questions about archives wait with this research (none in an archive). */
-export function archiveQuestionCount(tree) {
-    return archiveQuestions(tree).filter(answerable).length;
-}
 /** Every research on this computer, the one worked on first: a decision about an archive is the person's for all. */
 export function rootsHere(ctx, root) {
     return [...new Set([...(root ? [root] : []), ...ctx.knownTrees().map((k) => k.root)])];
@@ -78,11 +30,18 @@ export function rootsHere(ctx, root) {
 function levelHere(ctx, c, host) {
     return levelsOf(ctx, c, true).find((a) => a.host === host);
 }
+/** Can a downloader give images at all — directly (fetch, part) or through the browser (locate)? Else they go only by hand. */
+function givesImages(c) {
+    const can = c.manifest.can;
+    const routes = routesOf(c);
+    return (routes.includes("direct") && (can.includes("fetch") || can.includes("part"))) || (routes.includes("browser") && (can.includes("locate") || can.includes("fetch")));
+}
 /**
  * One archive: what its terms say and the ways to get its images — a question that waited (What waits, a link), or
  * the person's look at it in the settings (the current way suggested, its permission to be forgotten). True: decided.
+ * `all`: the archive's hosts (its downloader's, the same state on each) — said once, decided for all of them.
  */
-export async function decideArchive(ctx, run, lang, root, host, q) {
+export async function decideArchive(ctx, run, lang, root, host, q, all) {
     const t = translator(lang);
     const out = (line = "") => ctx.io.stdout(line + "\n");
     const c = connectorFor(connectorsHere(ctx), host, q?.connector);
@@ -93,12 +52,18 @@ export async function decideArchive(ctx, run, lang, root, host, q) {
     const a = levelHere(ctx, c, host);
     const title = a?.title ?? q?.title ?? c.manifest.title ?? host;
     const tree = root ? Tree.open(root, ctx.env) : undefined;
+    const hosts = all && all.length > 1 ? all : [host];
+    // the command's target: the downloader for all its hosts at once, else the host
+    const target = hosts.length > 1 ? c.name : host;
     out("");
-    out(` ${t("ui.archive.item", { title, host })}`);
+    out(` ${t("ui.archive.item", { title, host: hosts.join(", ") })}`);
     out(`    ${termsText(lang, ctx.env, { host, ...(a?.quote ? { quote: a.quote } : q?.quote ? { quote: q.quote } : {}), ...(a?.terms ?? q?.terms ? { terms: (a?.terms ?? q?.terms) } : {}), ...(a?.quoteBy ? { quoteBy: a.quoteBy } : q?.quoteBy ? { quoteBy: q.quoteBy } : {}) })}`);
-    const tasks = tree && !isArchive(tree) ? (q?.kind === "permission" ? tasksStanding(tree, q) : tasksWaitingOn(tree, host).map((x) => x.id)) : [];
+    const tasks = tree && !isArchive(tree) ? (q?.kind === "permission" ? tasksStanding(tree, q) : [...new Set(hosts.flatMap((h) => tasksWaitingOn(tree, h).map((x) => x.id)))]) : [];
     if (tasks.length)
         out(`    ${t("ui.archive.item.tasks", { ids: tasks.join(", ") })}`);
+    // a question that waits: since when (the first time asked) and how many times a command needed it
+    if (q?.kind === "permission")
+        out(`    ${t("ui.archive.item.since", { date: humanDay(q.at, lang), tries: q.tries ?? 1 })}`);
     // a server that refused strom's client: its answer, not the archive's terms — only the person lifts it (--unblock)
     if (a?.level === "forbidden" && a.refused && !a.refused.unreadable) {
         const h = a.refused.host;
@@ -106,9 +71,10 @@ export async function decideArchive(ctx, run, lang, root, host, q) {
         await pause(ctx, lang);
         return false;
     }
-    // a level no permission opens (by hand only, nothing at all): said, and who lifts it
+    // a level no permission opens (by hand only, nothing at all): said, and who lifts it — only where lifting it would
+    // open a way (its downloader gives images, the archive refuses strom nothing); else the images go by hand
     if (a && (a.level === "manual" || a.level === "forbidden")) {
-        out(`    ${t("ui.archive.closed", { title, level: levelWords(lang, a.level, false, a.from), host })}`);
+        out(`    ${t(givesImages(c) && !a.refused ? "ui.archive.closed" : "ui.archive.closed.hand", { title, level: levelWords(lang, a.level, false, a.from), host: target })}`);
         await pause(ctx, lang);
         return false;
     }
@@ -125,7 +91,7 @@ export async function decideArchive(ctx, run, lang, root, host, q) {
     const now = a?.permission;
     const choices = ways.map((w) => ({
         way: w,
-        label: t(w === "slow" ? "ui.archive.way.slow" : w === "browser" ? "ui.archive.way.browser" : "ui.archive.way.manual", { seconds: secondsIn(lang, slow.minIntervalMs), n: Number.isFinite(slow.perHour) ? slow.perHour : "∞" }),
+        label: t(w === "slow" ? "ui.archive.way.slow" : w === "browser" ? "ui.archive.way.browser" : "ui.archive.way.manual", { seconds: secondsIn(lang, slow.minIntervalMs), cap: capWords(lang, slow.perHour) }),
     }));
     if (now)
         choices.push({ label: t("ui.archive.way.revoke") });
@@ -136,14 +102,14 @@ export async function decideArchive(ctx, run, lang, root, host, q) {
         return false;
     const chosen = choices[i].way;
     if (!chosen) {
-        if ((await run(["allow", "archive", host, "--revoke"], true)) !== 0)
+        if ((await run(["allow", "archive", target, "--revoke"], true)) !== 0)
             return false;
         out(t("ui.archive.revoked", { title }));
         return true;
     }
     // what the decision does to the tasks that waited (the command wakes them, in every research here): said after it
-    const plan = wakeForArchive(ctx.env, rootsHere(ctx, root), host, { ...(ctx.settings.shared()?.value ? { shared: ctx.settings.shared().value } : {}), way: chosen, dry: true });
-    if ((await run(["allow", "archive", host, "--way", chosen], true)) !== 0)
+    const plan = hosts.flatMap((h) => wakeForArchive(ctx.env, rootsHere(ctx, root), h, { ...(ctx.settings.shared()?.value ? { shared: ctx.settings.shared().value } : {}), way: chosen, dry: true }));
+    if ((await run(["allow", "archive", target, "--way", chosen], true)) !== 0)
         return false;
     // the connector's route follows the way chosen: through the browser, or straight through strom
     const via = routeOf(ctx.env, c).via;
@@ -157,7 +123,7 @@ export async function decideArchive(ctx, run, lang, root, host, q) {
     return true;
 }
 /** The connectors taken over from an older strom: confirmed all at once, or gone through one by one. */
-async function decideTakeover(ctx, run, lang, q) {
+export async function decideTakeover(ctx, run, lang, q) {
     const t = translator(lang);
     const out = (line = "") => ctx.io.stdout(line + "\n");
     const all = connectorsHere(ctx).filter((c) => q.connectors?.includes(c.name));
@@ -202,7 +168,7 @@ async function decideTakeover(ctx, run, lang, q) {
     }
 }
 /** A connector that says now an archive allows more than strom keeps: accepted, or kept as it is. */
-async function decideMilder(ctx, run, lang, q, title) {
+export async function decideMilder(ctx, run, lang, q, title) {
     const t = translator(lang);
     const out = (line = "") => ctx.io.stdout(line + "\n");
     const c = connectorsHere(ctx).find((x) => x.name === q.connector);
@@ -227,13 +193,15 @@ function onlyBrowser(t, c, robots) {
 export function browserOnlyHere(ctx, c) {
     return archivesOverview(ctx).some((r) => r.connector === c.name && r.browserOnly && r.level !== "manual" && r.level !== "forbidden");
 }
-/** What holds for a downloader's archive, on its line in the settings: its level, the person's way and since when, the pace. */
-export function archiveState(ctx, lang, c) {
+/**
+ * What holds for a downloader's archive, on its line in the settings: its level, the person's way and since when, the
+ * pace — once for all its hosts where they are the same (`host`: that host alone).
+ */
+export function archiveState(ctx, lang, c, host) {
     const t = translator(lang);
-    const rows = archivesOverview(ctx).filter((r) => r.connector === c.name);
+    const rows = archivesOverview(ctx).filter((r) => r.connector === c.name && (!host || r.host === host));
     const store = loadArchives(ctx.env).archives;
-    return rows
-        .map((r) => {
+    const said = rows.map((r) => {
         const rec = store[r.host];
         const level = r.level;
         const closed = level === "manual" || level === "forbidden";
@@ -242,23 +210,52 @@ export function archiveState(ctx, lang, c) {
         const only = !closed && !r.way && r.browserOnly ? onlyBrowser(t, c, !!r.robots) : undefined;
         const way = only ?? (!closed && r.way ? t("ui.archives.state.way", { way: t(`ui.archive.is.${r.way}`), date: rec?.at ? humanDay(rec.at, lang) : "–" }) : levelWords(lang, level, !!r.robots, r.from));
         const pace = !closed && r.way !== "manual" && (level === "allowed" || r.way) ? `; ${paceWords(lang, r.pace)}` : "";
-        return `${rows.length > 1 ? `${r.host}: ` : ""}${way}${pace}`;
-    })
-        .join(" · ");
+        return { host: r.host, text: `${way}${pace}` };
+    });
+    // said once where every host of the archive is the same, per host only where they differ
+    return said.every((x) => x.text === said[0].text) ? (said[0]?.text ?? "") : said.map((x) => `${x.host}: ${x.text}`).join(" · ");
+}
+/** Each host of a downloader with what holds for it. */
+function hostStates(ctx, lang, c) {
+    return [...new Set(archivesOverview(ctx).filter((r) => r.connector === c.name).map((r) => r.host))].map((host) => ({ host, text: archiveState(ctx, lang, c, host) }));
 }
 /** Settings → Archives → permissions: each archive of a downloader here, then the same choices as in What waits. */
 export async function archivePermissions(ctx, run, lang, root) {
     const t = translator(lang);
+    const pending = (hosts) => loadArchives(ctx.env).pending.find((p) => p.kind === "permission" && hosts.includes(p.host ?? ""));
     await subMenu(ctx, lang, () => {
         const rows = archivesOverview(ctx);
-        const hosts = [...new Map(rows.map((r) => [r.host, r])).values()];
         const connectors = connectorsHere(ctx);
-        const items = hosts.slice(0, 9).map((r, k) => {
-            const c = connectors.find((x) => x.name === r.connector);
+        // one line per archive (its downloader) with its hosts inside it — a host two downloaders reach under the first
+        const seen = new Set();
+        const archives = [];
+        for (const name of [...new Set(rows.map((r) => r.connector))]) {
+            const c = connectors.find((x) => x.name === name);
+            const hosts = [...new Set(rows.filter((r) => r.connector === name && !seen.has(r.host)).map((r) => r.host))];
+            if (!c || !hosts.length)
+                continue;
+            for (const h of hosts)
+                seen.add(h);
+            archives.push({ c, hosts });
+        }
+        const items = archives.slice(0, 9).map(({ c, hosts }, k) => {
+            const states = hostStates(ctx, lang, c).filter((x) => hosts.includes(x.host));
+            const same = states.every((x) => x.text === states[0]?.text);
+            const title = c.manifest.title ?? c.name;
             return {
                 key: String(k + 1),
-                label: `${c?.manifest.title ?? r.connector} (${r.host}) – ${c ? archiveState(ctx, lang, c) : levelWords(lang, r.level, !!r.robots, r.from)}`,
-                act: async () => void (await decideArchive(ctx, run, lang, root, r.host, loadArchives(ctx.env).pending.find((p) => p.kind === "permission" && p.host === r.host))),
+                label: `${title} (${hosts.join(", ")}) – ${same ? (states[0]?.text ?? "") : states.map((x) => `${x.host}: ${x.text}`).join(" · ")}`,
+                act: async () => {
+                    // the same on every host: decided for the archive at once; else for the host the person picks
+                    if (same || hosts.length === 1) {
+                        const q = pending(hosts);
+                        return void (await decideArchive(ctx, run, lang, root, q?.host ?? hosts[0], q, hosts));
+                    }
+                    const i = await ctx.choose(title, states.map((x) => ({ label: `${x.host} – ${x.text}` })), states.length, { back: t("ui.browse.back") });
+                    if (i === undefined)
+                        return;
+                    await decideArchive(ctx, run, lang, root, states[i].host, pending([states[i].host]));
+                },
             };
         });
         return { title: t(items.length ? "ui.archives.permissions.title" : "ui.archives.empty"), items };

package/dist/cli/menu-links.js

@@ -6,7 +6,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { outOfAnswers, translator } from "./menu-parts.js";
-import { directionTasks, offerChat, setDirection } from "./menu-research.js";
+import { askPaths, directionTasks, offerChat, setDirection } from "./menu-research.js";
 import { humanCost, humanDay, humanTask, humanWhen } from "./human.js";
 import { lines, truncate } from "./format.js";
 import { isArchive } from "../core/mode.js";
@@ -36,6 +36,10 @@ import { forgetTree } from "../commands/trees.js";
 import { archiveQuestions } from "../core/archiveasks.js";
 import { bareHost, listConnectors } from "../core/connector.js";
 import { decideArchive } from "./menu-archives.js";
+import { inboxOf, requestFile, sameGroup } from "../core/waiting.js";
+import { SENDABLE, waitGroupOf, waitKindOf } from "../core/waitkind.js";
+import { openForUser } from "../core/open.js";
+import { fileRefused } from "../core/taskfiles.js";
 /** What the Strom app asks, said before anything is done; true when the person goes on. */
 export async function asks(ctx, lang, root, what, note, suggested = true) {
     const name = Tree.open(root, ctx.env).config.name;
@@ -74,6 +78,91 @@ export async function taskDo(ctx, run, lang, root, id, what) {
     out(ctx, t(`ui.link.task.${what}.done`));
     return true;
 }
+/**
+ * What a link of the Strom app does with a task that waits: a conversation about it and what waits with it at the same
+ * place (said and asked first: the agent costs), its request's text or its folder of images opened (nothing written),
+ * its request marked sent on the person's word (Enter: no). True: done.
+ *
+ * `menu`: the same chosen in the menu's What waits — the person picked it there, nothing said as the app's: a
+ * conversation starts at once, sent is asked in a line of its own (Enter: no).
+ */
+export async function waitingDo(ctx, run, lang, root, id, what, agent, menu = false) {
+    const t = translator(lang);
+    const tree = Tree.open(root, ctx.env);
+    const task = tree.get(id);
+    if (!task || task.type !== "task" || task.retracted)
+        return stop(ctx, t("ui.link.task.none", { task: id }));
+    if (task.state !== "waiting")
+        return stop(ctx, t("ui.link.notask"));
+    const shown = humanTask(tree, task.what, lang);
+    if (what === "chat") {
+        if (menu)
+            return (await run(["chat", "--task", task.id])) === 0;
+        const more = sameGroup(tree, task, ctx.settings.shared()?.value).length;
+        const said = `${t("ui.link.what.task.chat", { agent, what: shown })}${more ? t("ui.link.what.task.chat.more", { n: more }) : ""}`;
+        if (!(await asks(ctx, lang, root, said, t("ui.link.cost"))))
+            return false;
+        return (await run(["chat", "--task", task.id])) === 0;
+    }
+    if (what === "note") {
+        const file = requestFile(tree, task);
+        if (!file)
+            return stop(ctx, t("ui.link.note.none", { task: task.id }));
+        openForUser(file, ctx.env);
+        out(ctx, t("ui.link.note.opened", { file: ctx.display(file) }));
+        return true;
+    }
+    if (what === "folder") {
+        const inbox = inboxOf(ctx.settings.shared()?.value, task);
+        if (!inbox)
+            return stop(ctx, t("ui.link.folder.none", { task: task.id }));
+        openForUser(inbox.dir, ctx.env);
+        out(ctx, t("ui.waiting.opened", { dir: ctx.display(inbox.dir) }));
+        return true;
+    }
+    // a file that came for it: dragged in, a short note — an input of its people, the task back in the queue (Enter or 0
+    // at the file, 0 at the note: nothing written)
+    if (what === "file") {
+        if (fileRefused(task, task.id))
+            return stop(ctx, t("ui.link.file.cannot", { task: task.id }));
+        if (!menu) {
+            out(ctx, t("ui.link.asks", { what: t("ui.link.what.task.file", { what: shown }), name: tree.config.name }));
+            if (task.waitingOn)
+                out(ctx, ` ${t("ui.waiting.do", { what: task.waitingOn })}`);
+        }
+        const paths = await askPaths(ctx, lang, root);
+        if (!paths?.length)
+            return false;
+        const note = (await ctx.ask(t("ui.link.file.note"))).trim();
+        if (note === "0")
+            return false;
+        if ((await run(["intake", ...paths, `--answers=${task.id}`, ...(note ? [`--note=${note}`] : [])], true)) !== 0)
+            return false;
+        out(ctx, t("ui.link.task.file.done"));
+        return true;
+    }
+    // sent: a fact the person gives, never a consent — the task still waits for the reply
+    if (!SENDABLE.includes(waitKindOf(task)))
+        return stop(ctx, t("ui.link.sent.cannot", { task: task.id }));
+    if (task.sent)
+        return stop(ctx, t("ui.link.sent.already", { task: task.id, day: humanDay(task.sent.at, lang) }));
+    const group = waitGroupOf(tree, task, lang);
+    const to = task.wait?.to?.trim() || (group.kind === "office" || group.kind === "family" ? group.name : undefined);
+    if (menu) {
+        if (!(await ctx.confirm(t("ui.wait.sent.sure", { to: to ? ` (${to})` : "" }), false)))
+            return false;
+    }
+    else {
+        if (task.waitingOn)
+            out(ctx, ` ${t("ui.waiting.do", { what: task.waitingOn })}`);
+        if (!(await asks(ctx, lang, root, t("ui.link.what.task.sent", { what: shown, to: to ? ` (${to})` : "" }), undefined, false)))
+            return false;
+    }
+    if ((await run(["task", "sent", task.id], true)) !== 0)
+        return false;
+    out(ctx, t("ui.link.task.sent.done"));
+    return true;
+}
 /**
  * The question about an archive's images a link of the Strom app opens: only an archive that waits for the person's
  * decision, or one a downloader here reaches (its permission looked at again) — anything else only said.

package/dist/cli/menu-research.js

@@ -122,7 +122,7 @@ export async function offerChat(ctx, run, lang, root, question, say) {
         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) {
+export 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) => {