strom-research 1.15.0-beta.6 → 1.15.0

package/CHANGELOG.cs.md

@@ -7,7 +7,7 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 
 ## 1.15.0
 
-*Patří k aplikaci Strom 3.12.0.*
+*16. 10. 2026 · patří k aplikaci Strom 3.12.0.*
 
 - **Archiv Stromu podle volby, i s AI agentem.** Průvodce nastavením se ptá, zda nové rodokmeny budou výzkumem
   s agentem, nebo jen Archivem Stromu; v nastavení jde volbu změnit pro jeden rodokmen nebo pro nové.
@@ -23,9 +23,14 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   přečtené snímky jsou řečeny přesně a jen ty se počítají jako prohledané.
 - **Rodokmeny z jiných programů.** Soubor GEDCOM uložený se značkou BOM nebo v UTF-16 (tak ho ukládají některé programy
   ve Windows) se čte jako rodokmen; rodokmen jiného výzkumu se převezme jako cizí.
-- **Živé sledování končí čistě** na každém systému, i ve Windows, a aplikace Strom se dozví, že skončilo.
-- **Jeden strom na instalaci.** Jiný strom na stejném počítači (z npm nebo sestavený ze zdrojů) nikdy nepřevezme odkazy
-  aplikace Strom ani kanál aktualizací.
+- **Čistě na jednom počítači.** Živé sledování končí čistě na každém systému, i ve Windows, a aplikace Strom se dozví,
+  že skončilo. Jiný strom na stejném počítači (z npm nebo sestavený ze zdrojů) nikdy nepřevezme odkazy aplikace Strom
+  ani kanál aktualizací.
+- **Opravy ze skutečných výzkumů.** Denní příděl práce o samotě pustí nový týden hned, v posledních dvou hodinách
+  týdne využije, co zbývá, místo čekání přes obnovení, a říká, kdy se týden obnoví. Věk zapsaný zlomkem (½ roku, 1 1/2
+  léta, půl roku) se přečte a seznam snímků (`strom read --images 5-19,21-39`) se čte tak, jak je zadaný. Knihu
+  stahuje sezení, které ji čte, nikdy předem pro pozdější; `strom fetch --recordset` najde knihu sám; počty a příkazy
+  jsou řečeny tak, jak se píšou.
 - **Co je nového.** Po `strom update` a u `strom --version` odkaz na tento přehled v jazyce výzkumu. Aplikace Strom
   ukazuje body nové verze výzkumu ve svém okně „Co je nového“.
 

package/CHANGELOG.de.md

@@ -7,7 +7,7 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.15.0
 
-*Gehört zur Strom-App 3.12.0.*
+*16.10.2026 · gehört zur Strom-App 3.12.0.*
 
 - **Ein Strom-Archiv nach Wahl, auch mit einem KI-Agenten.** Die Einrichtung fragt, ob neue Stammbäume Forschungen mit
   dem Agenten sind oder nur ein Strom-Archiv; in den Einstellungen lässt sich das für einen Stammbaum oder für die
@@ -25,9 +25,15 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   und nur sie gelten als durchsucht.
 - **Stammbäume aus anderen Programmen.** Eine GEDCOM-Datei mit Byte-Order-Mark oder in UTF-16 (so speichern sie manche
   Windows-Programme) wird als Stammbaum gelesen; der Stammbaum einer anderen Forschung wird als fremder übernommen.
-- **Die Live-Ansicht endet sauber** auf jedem System, auch unter Windows, und die Strom-App erfährt, dass sie endete.
-- **Ein strom pro Installation.** Ein anderer strom auf demselben Computer (aus npm oder aus den Quellen gebaut)
-  übernimmt nie die Links der Strom-App oder den Update-Kanal.
+- **Sauber auf einem Computer.** Die Live-Ansicht endet sauber auf jedem System, auch unter Windows, und die Strom-App
+  erfährt, dass sie endete. Ein anderer strom auf demselben Computer (aus npm oder aus den Quellen gebaut) übernimmt nie
+  die Links der Strom-App oder den Update-Kanal.
+- **Korrekturen aus echten Forschungen.** Die tägliche Ration des Alleinarbeitens lässt eine neue Woche sofort
+  beginnen, nutzt in den letzten zwei Stunden der Woche, was übrig ist, statt über die Erneuerung hinaus zu warten,
+  und sagt, wann sich die Woche erneuert. Ein Alter als Bruch (½ Jahr, 1 1/2 Jahre, ein halbes Jahr) wird gelesen, und
+  eine Liste von Bildern (`strom read --images 5-19,21-39`) wird so gelesen, wie sie angegeben ist. Ein Buch lädt die
+  Sitzung, die es liest, nie im Voraus für eine spätere; `strom fetch --recordset` findet das Buch selbst; Zahlen und
+  Befehle werden so genannt, wie sie geschrieben werden.
 - **Was ist neu.** Nach `strom update` und bei `strom --version` ein Link zu dieser Übersicht in der Sprache der
   Forschung. Die Strom-App zeigt die Punkte einer neuen Forschungsversion in ihrem Fenster „Was ist neu“.
 

package/CHANGELOG.md

@@ -7,7 +7,7 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 1.15.0
 
-*Goes with the Strom app 3.12.0.*
+*2026-10-16 · goes with the Strom app 3.12.0.*
 
 - **A Strom archive by choice, with an AI agent too.** The setup asks whether new family trees are researches with the
   agent or only a Strom archive; the settings change it for one family tree or for the new ones.
@@ -23,9 +23,14 @@ The changes of each version in short. The full notes and the install lines are o
   (`strom read --until-found`): the images read are said exactly, and only they count as searched.
 - **Family trees from other programs.** A GEDCOM file saved with a byte order mark or in UTF-16 (as some Windows
   programs save it) is read as a family tree; a family tree of another research is taken in as a foreign one.
-- **The live view ends cleanly** on every system, Windows too, and the Strom app learns that it ended.
-- **One strom per installation.** Another strom on the same computer (from npm, or built from the sources) never takes
-  over the links of the Strom app or the update channel.
+- **Cleaner on one computer.** The live view ends cleanly on every system, Windows too, and the Strom app learns that
+  it ended. Another strom on the same computer (from npm, or built from the sources) never takes over the links of the
+  Strom app or the update channel.
+- **Fixes from real researches.** The daily ration of working alone lets a new week begin at once, uses what is left
+  in the week's last two hours instead of waiting past the reset, and says when the week resets. Ages written as
+  fractions (½ roku, 1 1/2 years, ein halbes Jahr) are read, and a list of images (`strom read --images 5-19,21-39`)
+  is read as given. A book is fetched by the session that reads it, never ahead for a later one;
+  `strom fetch --recordset` finds the book itself; counts and commands are said as typed.
 - **What's new.** After `strom update` and with `strom --version`, a link to this list in the research language. The
   Strom app shows the points of a new research version in its own “What's new” window.
 

package/assets/method/core.md

@@ -104,7 +104,8 @@ conclusion so the next researcher can follow it.
   usual (about ±5 around the target, an index in batches) — fewer turns.
   `strom read` may follow a fetch at work: sooner, never more images.
   Images you will read later in the session: `--background` fetches them
-  while you work on, `strom read` reads them as they come.
+  while you work on, `strom read` reads them as they come. Nothing for a
+  later session: the session that reads a book fetches it.
 <!-- end -->
 - **What strom or the tree denies stays denied.** Never offer the user to
   change your permissions or settings, strom's or the tree's, to get round it:

package/assets/method/reading.md

@@ -51,7 +51,8 @@ never open again a view cleared from your context — your notes hold it.
 - **Browsing a book or a range is a reader's job**: `strom read B0001
   --images 40-69 --question "…"` (small script: `--half both`) — readers in
   batches of ten, each with the full question, their reports in
-  notes/readings/. It ends with what they found, compact: the found and
+  notes/readings/. For every agent, also one with subagents of its own: a
+  third of their cost, every reading kept. It ends with what they found, compact: the found and
   unclear entries whole, what was illegible where nothing was found (a
   possible match often hides there — look at it), the gaps in the book.
   Later: `strom readings` (`--match <surname>`, `--list`; one image's block:

package/assets/plugins/gates/README.md

@@ -110,9 +110,19 @@ usage is at least the number you give it behind the week gone:
     strom config set run.gate "claude-usage 10"     gone − used ≥ 10
 
 Without a number: 0 — no faster than the week goes; 14: about a day in hand.
-Not enough in hand: it waits until the week has caught up (past the reset: the
-new week's share). A used-up session: until it resets. Another agent than
-Claude Code: it lets the work go on.
+
+Early in the week the number grows with it: at least half the week gone, the
+full number from twice it on (at 15: from 30 % gone). Right after the reset a
+session starts at once, and the first day uses at most half of its share.
+In the week's last 2 hours what is left would go with the reset: a session
+starts when the room left (to 100 %, or to the cap) holds one — counted high,
+10 points.
+
+Not enough in hand: it waits until the first of — the week has caught up, the
+week's last 2 hours (with room for a session), the reset itself (a new week
+starts at once); never past the reset. Every answer says when the week resets
+("weekly reset in 1.7 h"). A used-up session: until it resets. Another agent
+than Claude Code: it lets the work go on.
 
 **A cap** — your own hard stop for the week:
 

package/assets/plugins/gates/claude-usage/gate.json

@@ -1,7 +1,7 @@
 {
   "interface": 1,
   "title": "Claude usage",
-  "description": "Keeps working alone to the daily ration of your Claude subscription: a session starts only while the week's usage is at least n points behind the share of the week gone (a day ≈ 14.3): strom config set run.gate \"claude-usage 10\" (without a number: 0). A cap: \"claude-usage 10 --cap 95\" — at 95 % of the week no session starts, in any run, and no \"start anyway\" goes past it.",
+  "description": "Keeps working alone to the daily ration of your Claude subscription: a session starts only while the week's usage is at least n points behind the share of the week gone (a day ≈ 14.3; early in the week half the share gone, so a new week starts at once; in its last 2 hours what is left goes when it holds a session): strom config set run.gate \"claude-usage 10\" (without a number: 0). A cap: \"claude-usage 10 --cap 95\" — at 95 % of the week no session starts, in any run, and no \"start anyway\" goes past it.",
   "command": [
     "node",
     "gate.ts"

package/assets/plugins/gates/claude-usage/gate.ts

@@ -8,8 +8,19 @@
 // (a day is about 14.3 %) against the week's usage. With the number you give
 // it (strom config set run.gate "claude-usage 10") a session starts only while
 // usage is at least that many points behind the week gone: gone − used ≥ 10.
-// Without a number: 0 — no faster than the week goes. Else it waits until the
-// week has caught up (or past the reset); a full session: until it resets.
+// Without a number: 0 — no faster than the week goes.
+//
+// Early in the week the number grows with it: at least min(n, gone / 2) — right
+// after the reset (0 % gone, 0 % used) a session may start, and until 2·n % of
+// the week is gone usage may reach half of it; from there on the full number.
+// So the first day never spends the week (at most half its share), and a new
+// week is not idle for n % of it (a day and more at 15) for nothing.
+// Late in the week what is left goes with the reset: in its last END_WINDOW a
+// session starts when what is left (to 100 %, or to the cap) holds one session
+// (SESSION_POINTS).
+// Else it waits until the first of: the week has caught up, its last
+// END_WINDOW (with room for a session), its reset (a new week starts at once) —
+// never past the reset. A full session: until it resets.
 //
 // A cap (strom config set run.gate "claude-usage 15 --cap 95"): at 95 % of the
 // week used no session starts — the user's own hard stop, asked before every
@@ -28,15 +39,32 @@ const FRESH_MS = 15 * 60_000;
 /** Under a cap, a session at work is asked to finish at this much of the week. */
 const FINISH_AT = 0.99;
 const WEEK = 7 * DAY;
+/**
+ * The last stretch of the week in which what is left is spent rather than kept: about one session of `strom run`
+ * (60 minutes by default) with its wrap-up and the gate's next asking. What is not used by the reset is gone with
+ * it; what a person keeps in hand for their own work is missed for this long at most.
+ */
+const END_WINDOW = 2 * 3_600_000;
+/** What one session may take of the week, counted high (points of the week's %): the room it needs before the reset. */
+const SESSION_POINTS = 10;
+/** After the reset the gate asks again this much later, so the new week is what Claude Code says. */
+const AFTER_RESET = 60_000;
 const lang = (process.env.STROM_LANG ?? "en").slice(0, 2);
 
 const T: Record<string, Record<string, string>> = {
   en: {
     other: "the agent is not Claude Code — nothing to check",
     api: "Claude Code runs on an API key, not a subscription — no plan limits",
-    go: "week {used} % used, {gone} % gone, {behind} in hand (at least {min} needed)",
-    session: "the session is used up — until it resets",
-    week: "week {used} % used, {gone} % gone, {behind} in hand (at least {min} needed) — until the week catches up",
+    head: "week {used} % used, {gone} % gone, {behind} in hand (at least {min} needed{early})",
+    early: " — half the week gone, early in the week",
+    resetIn: "; weekly reset in {reset}",
+    catch: " — until the week catches up; weekly reset in {reset}",
+    last: " — until the last {window} before the weekly reset in {reset}",
+    reset: " — until the weekly reset in {reset}",
+    end: "week {used} % used, weekly reset in {reset} — the {room} % left is enough for a session",
+    session: "the session is used up — until it resets; weekly reset in {reset}",
+    hours: "{n} h",
+    days: "{n} days",
     bad: "the number must be 0 to 99, not \"{arg}\"",
     badcap: "the cap must be 1 to 100 (\"--cap 95\"), not \"{arg}\"",
     cap: "week {used} % used — the cap of {cap} % reached; it resets {resets}",
@@ -47,9 +75,16 @@ const T: Record<string, Record<string, string>> = {
   cs: {
     other: "agent není Claude Code — není co hlídat",
     api: "Claude Code běží na API klíči, ne na předplatném — žádné limity plánu",
-    go: "týden: využito {used} %, uplynulo {gone} %, náskok {behind} (potřeba aspoň {min})",
-    session: "sezení je vyčerpané — do jeho obnovení",
-    week: "týden: využito {used} %, uplynulo {gone} %, náskok {behind} (potřeba aspoň {min}) — dokud čas nedožene",
+    head: "týden: využito {used} %, uplynulo {gone} %, náskok {behind} (potřeba aspoň {min}{early})",
+    early: " – na začátku týdne polovina uplynulého",
+    resetIn: "; týden se obnoví za {reset}",
+    catch: " — dokud čas nedožene; týden se obnoví za {reset}",
+    last: " — do posledních {window} před obnovením týdne za {reset}",
+    reset: " — do obnovení týdne za {reset}",
+    end: "týden: využito {used} %, obnoví se za {reset} — zbylých {room} % stačí na sezení",
+    session: "sezení je vyčerpané — do jeho obnovení; týden se obnoví za {reset}",
+    hours: "{n} h",
+    days: "{n} dne",
     bad: "číslo musí být 0 až 99, ne \"{arg}\"",
     badcap: "strop musí být 1 až 100 (\"--cap 95\"), ne \"{arg}\"",
     cap: "týden: využito {used} % – strop {cap} % dosažen; obnoví se {resets}",
@@ -60,9 +95,16 @@ const T: Record<string, Record<string, string>> = {
   de: {
     other: "der Agent ist nicht Claude Code — nichts zu prüfen",
     api: "Claude Code läuft mit einem API-Schlüssel, nicht im Abo — keine Planlimits",
-    go: "Woche: {used} % genutzt, {gone} % vergangen, Vorsprung {behind} (mindestens {min} nötig)",
-    session: "die Sitzung ist aufgebraucht — bis sie zurückgesetzt wird",
-    week: "Woche: {used} % genutzt, {gone} % vergangen, Vorsprung {behind} (mindestens {min} nötig) — bis die Zeit aufholt",
+    head: "Woche: {used} % genutzt, {gone} % vergangen, Vorsprung {behind} (mindestens {min} nötig{early})",
+    early: " – am Wochenanfang die Hälfte des Vergangenen",
+    resetIn: "; Wochen-Reset in {reset}",
+    catch: " — bis die Zeit aufholt; Wochen-Reset in {reset}",
+    last: " — bis zu den letzten {window} vor dem Wochen-Reset in {reset}",
+    reset: " — bis zum Wochen-Reset in {reset}",
+    end: "Woche: {used} % genutzt, Wochen-Reset in {reset} — die übrigen {room} % reichen für eine Sitzung",
+    session: "die Sitzung ist aufgebraucht — bis sie zurückgesetzt wird; Wochen-Reset in {reset}",
+    hours: "{n} h",
+    days: "{n} Tagen",
     bad: "die Zahl muss 0 bis 99 sein, nicht \"{arg}\"",
     badcap: "die Obergrenze muss 1 bis 100 sein (\"--cap 95\"), nicht \"{arg}\"",
     cap: "Woche: {used} % genutzt – Obergrenze {cap} % erreicht; zurückgesetzt {resets}",
@@ -135,19 +177,39 @@ if (cap !== undefined && week.used >= cap)
   answer(2, say("cap", { used: Math.floor(week.used), cap, resets: week.resets.toLocaleString(lang, { weekday: "short", day: "numeric", month: "numeric", hour: "2-digit", minute: "2-digit" }) }), undefined, true);
 
 const now = Date.now();
-const start = week.resets.getTime() - WEEK;
+const resets = week.resets.getTime();
+const start = resets - WEEK;
 const gone = Math.max(0, Math.min(100, ((now - start) / WEEK) * 100));
 const behind = gone - week.used;
-// shown rounded down: never "15 in hand (at least 15 needed)" for 14.6 — and gone − used stays what it says
-const v = { used: Math.floor(week.used), gone: Math.floor(gone), behind: Math.floor(behind), min };
-if (session && session.used >= 100) answer(1, say("session"), session.resets ? new Date(session.resets.getTime() + 60_000) : undefined);
-if (behind < min) {
-  // when the week gone reaches usage + the number; past the reset, the new week's number
-  let at = start + ((week.used + min) / 100) * WEEK;
-  if (at >= week.resets.getTime()) at = week.resets.getTime() + (min / 100) * WEEK;
-  answer(1, say("week", v), new Date(Math.max(at, now + 5 * 60_000)));
+// the number needed in hand: half the week gone early in the week, the full number from 2·n % gone on
+const need = Math.min(min, gone / 2);
+const early = need < min ? say("early") : "";
+const reset = inTime(resets - now);
+// shown rounded down: never "15 in hand (at least 15 needed)" for 14.6 — and gone − used stays what it says; the
+// need early in the week is a fraction: rounded down when it goes, up when it waits, so the two never seem to disagree
+const v = { used: Math.floor(week.used), gone: Math.floor(gone), behind: Math.floor(behind), early, reset };
+if (session && session.used >= 100) answer(1, say("session", { reset }), session.resets ? new Date(session.resets.getTime() + AFTER_RESET) : undefined);
+if (behind >= need) answer(0, say("head", { ...v, min: Math.floor(need) }) + say("resetIn", { reset }));
+// what is left before the reset: (to the cap, else to 100 %) enough for a session — in the week's last stretch it goes
+const room = (cap ?? 100) - week.used;
+const fits = room >= SESSION_POINTS;
+if (fits && resets - now <= END_WINDOW) answer(0, say("end", { used: v.used, reset, room: Math.floor(room) }));
+// else it waits for the first of: the week caught up (gone − used ≥ the need: used < n → gone = 2·used, else
+// used + n), the week's last stretch (with room for a session), the reset — a new week at 0 % goes at once, so
+// never past it
+const caught = start + ((week.used < min ? 2 * week.used : week.used + min) / 100) * WEEK;
+const last = fits ? resets - END_WINDOW : Infinity;
+const after = resets + AFTER_RESET;
+const at = Math.min(caught, last, after);
+const tail = at === caught ? say("catch", { reset }) : at === last ? say("last", { reset, window: say("hours", { n: END_WINDOW / 3_600_000 }) }) : say("reset", { reset });
+answer(1, say("head", { ...v, min: Math.ceil(need) }) + tail, new Date(Math.max(at, now + 5 * 60_000)));
+
+/** A stretch of time as a person reads it: hours to two days, then days — one decimal, in the research language. */
+function inTime(ms: number): string {
+  const h = Math.max(0, ms) / 3_600_000;
+  const n = (x: number) => x.toLocaleString(lang, { minimumFractionDigits: 1, maximumFractionDigits: 1 });
+  return h < 48 ? say("hours", { n: n(h) }) : say("days", { n: n(h / 24) });
 }
-answer(0, say("go", v));
 
 /**
  * The limits Claude Code said in this run (strom passes them: [{kind, used 0–1, resetsAt, at}]), when the week's is

package/dist/agents/profiles.js

@@ -30,6 +30,9 @@ function delegationRules(n) {
     return `- Browsing a book, an index or a range of images ("is our surname on this page?")
   goes to \`strom read\` (by halves: \`--half both\`); a delegate reads only crops
   of the entries found. Anything self-contained that returns little is delegated.
+  \`strom read\` and not subagents of your own for a range: about a third of
+  their cost on the same images, every reading kept (\`strom readings\`), the
+  places its readers found unclear held against a negative.
 - A delegate other than strom-scan-reader (text, print, a search) gets no brief:
   begin its prompt with this, word for word — "${DELEGATE_SHEET}"
 - About ${first} scans (images B…:n) per delegate, four views each (halves and
@@ -56,6 +59,13 @@ function delegationRules(n) {
 export function selfReading(n = DEFAULT_READING_NUMBERS) {
     return `## Reading scans (Codex, Antigravity, OpenCode, Grok)
 
+Browsing a book, an index or a range of images goes to \`strom read\`
+(\`strom read B0001 --images 40-69 --question "…"\`), also for an agent with
+sub-agents of its own: cheaper than reading the range in your context or by
+a sub-agent, every reading kept (\`strom readings\`), the places its readers
+found unclear held against a negative. Where strom says no reader can start
+here, and for the entries found:
+
 Read the images yourself, with your strongest model — never hand old
 handwriting to a faster or cheaper model, subagent or pass. Read them
 in batches of about ${inWords(n.batch)}: open a batch (one call gives its views —
@@ -103,7 +113,8 @@ comes back to you. Choose the model by the kind of work:
 
 | work | model |
 |---|---|
-| handwriting: registers, indexes, land books, any scan read closely | \`strom-scan-reader\`, ${m.vision ? `on \`${m.vision}\`` : "on your own model"} — never cheaper |
+| browsing handwriting: a book, an index, a range of images | \`strom read\` (its readers on the model for handwriting) — not a subagent of yours |
+| handwriting read closely: the entries found, a page of a land book | \`strom-scan-reader\`, ${m.vision ? `on \`${m.vision}\`` : "on your own model"} — never cheaper |
 | print and type: documents of the 20th century, catalogues, web pages, big text files (the lines \`strom grep\` found) | \`${m.text ?? "sonnet"}\` |
 | mechanical: downloads, renaming, counting | \`${m.cheap ?? "haiku"}\` |
 | a text in inputs/ or notes/ | nobody — \`strom grep\`, one call |

package/dist/brief/brief.js

@@ -21,7 +21,7 @@ import { byHandOnly, listConnectors, missingConsents, readyConnectors, routeOf }
 import { clock, hostAllowed, hostState, REFUSED_FOREVER } from "../core/net.js";
 import { archiveLevel } from "../core/terms.js";
 import { onHost, permissionQuestions, setHosts } from "../core/archivewait.js";
-import { runs, shellArg } from "../cli/format.js";
+import { runs, runsArg, shellArg } from "../cli/format.js";
 import { commandSheet } from "./sheet.js";
 import { foldText } from "../core/text.js";
 import { subjectPeople } from "../core/records.js";
@@ -631,10 +631,10 @@ function imagesLines(tree, b, route, shape, finder, noSharper = false, waiting)
 /** The fetches at work for the research (each book: how far), and those in the background that ended lately with images left. */
 function fetchingLines(root) {
     const active = activeFetches(root);
-    const out = active.map((m) => `- ${m.recordset}: ${m.registered}/${m.images.length} images registered (${m.background ? `in the background${m.task ? `, for ${m.task}` : ""}` : "in the foreground"}) — strom read ${m.recordset} --images ${runs(m.images)} reads them as they come; not fetched again`);
+    const out = active.map((m) => `- ${m.recordset}: ${m.registered}/${m.images.length} images registered (${m.background ? `in the background${m.task ? `, for ${m.task}` : ""}` : "in the foreground"}) — strom read ${m.recordset} --images ${runsArg(m.images)} reads them as they come; not fetched again`);
     for (const e of endedFetches(root))
         if (e.missed.length && !active.some((m) => m.recordset === e.recordset))
-            out.push(`- ${e.recordset}: a fetch in the background ended with images ${runs(e.missed)} not fetched${e.stopped ? ` (stopped: ${e.stopped})` : ""} — strom fetch ${e.connector} ${shellArg(e.book)} --images ${runs(e.missed)} --recordset ${e.recordset} if they are needed`);
+            out.push(`- ${e.recordset}: a fetch in the background ended with images ${runs(e.missed)} not fetched${e.stopped ? ` (stopped: ${e.stopped})` : ""} — strom fetch ${e.connector} ${shellArg(e.book)} --images ${runsArg(e.missed)} --recordset ${e.recordset} if they are needed`);
     return out;
 }
 /** What the user put in the shared inbox, waiting to be registered — by folder (one download each). */

package/dist/brief/sheet.js

@@ -27,10 +27,11 @@ const LEVELS = {
 const RARE = {
     "search add": ["by"],
     "task add": ["research", "anyway"],
-    "media view": ["scale", "max", "grey", "png", "image"],
+    "media view": ["scale", "max", "grey", "png", "image", "whole"],
     read: ["context", "batch", "model", "minutes", "max"],
-    // a book the research has already: the refusal says --again where it applies; --status and --stop: the method and the brief name them
-    fetch: ["take", "result", "again", "status", "stop"],
+    // a book the research has already: the refusal says --again where it applies; --status and --stop: the method and the brief name them;
+    // --task: strom takes the task the agent works on where it is plain, and says --task where it took one
+    fetch: ["take", "result", "again", "status", "stop", "task"],
     "source add": ["translation", "media"],
     "source edit": ["translation", "media"],
     "recordset add": ["images", "again"],

package/dist/cli/execute.js

@@ -5,7 +5,7 @@ import { parseArgs } from "node:util";
 import { UsageError } from "../core/errors.js";
 import { ALL_PREFIXES } from "../core/model.js";
 import { shellArg } from "./format.js";
-import { GLOBAL_OPTIONS, aliasExtends, commands, match, optionsOf, subcommandsOf, usageLine, WRITE_OPTIONS } from "./registry.js";
+import { GLOBAL_OPTIONS, aliasExtends, aliasGroup, commands, match, optionsOf, subcommandsOf, usageLine, WRITE_OPTIONS } from "./registry.js";
 const VALUE_GLOBALS = new Set(GLOBAL_OPTIONS.filter((o) => o.type === "string").map((o) => `--${o.name}`));
 /** The first word of a command line as typed — a command strom knows or not; the values of global options (--lang cs) are none. */
 export function firstWord(argv) {
@@ -55,12 +55,28 @@ function distance(a, b) {
         }
     return d[a.length][b.length];
 }
+/**
+ * How many typos a word of this many letters may hold and still be meant: one in a short word, two in a longer one,
+ * a few more in a command of several words — never so many that another word is offered (--whole is no --home).
+ */
+function typos(letters) {
+    return letters <= 6 ? 1 : letters <= 14 ? 2 : Math.floor(letters / 5);
+}
 /** The closest candidates to `input` (a prefix, or a few typos), best first — only the best ones. */
 export function suggest(input, candidates) {
-    const q = input.toLowerCase();
+    // an option's dashes are no letters of it: "--bron" is "bron"
+    const bare = (s) => s.toLowerCase().replace(/^-+/u, "");
+    const q = bare(input);
+    if (!q)
+        return [];
     const scored = candidates
-        .map((c) => ({ c, d: c.startsWith(q) || q.startsWith(c) ? 0.5 : distance(q, c.toLowerCase()) }))
-        .filter((x) => x.d <= Math.max(2, Math.floor(q.length / 3)))
+        .map((c) => {
+        const b = bare(c);
+        // a prefix of at least three letters ("--surnamez" for --surname, "person ad" for person add)
+        const prefix = Math.min(b.length, q.length) >= 3 && (b.startsWith(q) || q.startsWith(b));
+        return { c, d: prefix ? 0.5 : distance(q, b) };
+    })
+        .filter((x) => x.d <= typos([...q].length))
         .sort((a, b) => a.d - b.d || a.c.length - b.c.length);
     const best = scored[0]?.d;
     return [...new Set(scored.filter((x) => x.d <= (best ?? 0) + 0.5).map((x) => x.c))].slice(0, 3);
@@ -78,11 +94,14 @@ export function resolveCommand(argv) {
         return { def: found.def, rest };
     }
     // A group ("person") with a wrong or missing subcommand.
-    const group = found ? [...found.def.path, ...leftover] : words;
+    const typedGroup = found ? [...found.def.path, ...leftover] : words;
+    // another name of a group (strom book → strom recordset): that group
+    const group = aliasGroup(typedGroup) ?? typedGroup;
     if (group.length && subcommandsOf(group).length) {
         if (!extra.length)
             throw new GroupOnly(group);
-        throw unknownCommand([...group, extra[0]]);
+        // said as typed (strom book B1, never "strom recordset B1"), looked up in the group it stands for
+        throw unknownCommand([...group, extra[0]], [...typedGroup, extra[0]]);
     }
     throw unknownCommand([...words, ...extra].slice(0, Math.max(words.length + 1, 2)));
 }
@@ -94,15 +113,22 @@ export class GroupOnly extends Error {
         this.group = group;
     }
 }
-function unknownCommand(words) {
-    const typed = words.join(" ");
+/**
+ * An unknown command, said as typed (`said`: another name of a group — strom book … — when `words` name the group it
+ * stands for) with the commands near it; a group's ID after it (strom book B1) offers the group's show.
+ */
+function unknownCommand(words, said = words) {
+    const typed = said.join(" ");
     const all = commands().filter((c) => c.path.length > 0).map((c) => c.path.join(" "));
     // A known group narrows the choice ("person ad" → "person add", not "lesson add").
     const inGroup = all.filter((c) => c.startsWith(`${words[0]} `));
     const same = (inGroup.length ? inGroup : all).filter((c) => c.split(" ").length === words.length);
-    const hits = suggest(typed, same.length ? same : all);
-    const more = hits.length ? hits : suggest(words[0] ?? "", [...new Set(all.map((c) => c.split(" ")[0]))]);
-    const near = more.map((c) => `strom ${c}`).join(" · ");
+    const hits = suggest(words.join(" "), same.length ? same : all);
+    const show = !hits.length && words.length === 2 && /^\p{Lu}\p{N}+$/u.test(words[1]) && inGroup.includes(`${words[0]} show`) ? `${said[0]} show ${said[1]}` : undefined;
+    const more = show ? [show] : hits.length ? hits : suggest(words[0] ?? "", [...new Set(all.map((c) => c.split(" ")[0]))]);
+    // in the words typed: the group's other name kept (strom book show, not strom recordset show)
+    const asTyped = (c) => (said[0] !== words[0] && c.split(" ")[0] === words[0] ? [said[0], ...c.split(" ").slice(1)].join(" ") : c);
+    const near = more.map((c) => `strom ${asTyped(c)}`).join(" · ");
     return new UsageError(`unknown command "strom ${typed}"`, {
         hint: more.length ? `similar command: ${near}` : "strom help   (all commands)",
         ...(more.length ? { code: "command.near", params: { cmd: typed, near } } : { code: "command.unknown", params: { cmd: typed } }),
@@ -275,9 +301,9 @@ export function parseOptions(def, rest, program = "strom") {
         const own = [...(def.options ?? []), ...(def.writes ? optionsOf(def).filter((o) => o.name === "dry-run" || o.name === "reason") : [])].filter((o) => !o.hidden).map((o) => `--${o.name}`);
         if (e.code === "ERR_PARSE_ARGS_UNKNOWN_OPTION") {
             // "strom brief --task T0003": the task is an argument there, not an option
-            const arg = def.args?.find((a) => `--${a.name}` === opt);
+            const arg = def.args?.find((a) => `--${a.name}` === opt || a.mistaken?.includes(opt.replace(/^-+/u, "")));
             if (arg)
-                throw new UsageError(`${opt.slice(2)} is an argument of ${cmd}, not an option`, { hint: `strom ${def.path.join(" ")} <${arg.name}>`, code: "option.is-arg", params: { opt, cmd, arg: arg.name }, usage });
+                throw new UsageError(`--${arg.name}` === opt ? `${opt.slice(2)} is an argument of ${cmd}, not an option` : `${opt} is no option of ${cmd}: <${arg.name}> is its argument`, { hint: `strom ${def.path.join(" ")} <${arg.name}>`, code: "option.is-arg", params: { opt, cmd, arg: arg.name }, usage });
             // a status asked of a name or a family (N0191): it is a fact's only — said as cite says it (the person's
             // language: the plain unknown option, its code kept)
             if (opt === "--status" && (def.path[0] === "name" || def.path[0] === "family"))

package/dist/cli/format.js

@@ -38,6 +38,10 @@ export function truncate(text, max) {
     const one = text.replace(/\s+/g, " ").trim();
     return [...one].length <= max ? one : [...one].slice(0, max - 1).join("") + "…";
 }
+/** A count with its noun as English says it: "1 image", "2 images" (`many` where the plural is not one more s). */
+export function counted(n, one, many = `${one}s`) {
+    return `${n} ${n === 1 ? one : many}`;
+}
 export function lines(...parts) {
     return parts.filter((p) => typeof p === "string").join("\n");
 }
@@ -54,6 +58,13 @@ export function runs(nums) {
     }
     return out.join(", ");
 }
+/**
+ * Runs of numbers as a command takes them, one word of the shell: [1, 2, 3, 7] → "1-3,7" (no spaces, no en dash — a
+ * hint copied as runs() says it for a person, "1–3, 7", would be three arguments).
+ */
+export function runsArg(nums) {
+    return runs(nums).replace(/–/g, "-").replace(/,\s*/g, ",");
+}
 /** A number as a language writes it (1,4 in Czech, 1.4 in English); a language Intl does not know: English. */
 export function numberIn(lang, n, o = { maximumFractionDigits: 1 }) {
     try {

package/dist/cli/help.js

@@ -1,6 +1,6 @@
 // Help text generated from the registry. Short by design: examples first,
 // then arguments and options.
-import { GROUPS, GLOBAL_OPTIONS, WRITE_OPTIONS, commands, descriptionOf, match, subcommandsOf, usageLine } from "./registry.js";
+import { GROUPS, GROUP_ALIASES, GLOBAL_OPTIONS, WRITE_OPTIONS, aliasGroup, commands, descriptionOf, match, subcommandsOf, usageLine } from "./registry.js";
 import { table } from "./format.js";
 import { suggest } from "./execute.js";
 import { UI, ui } from "./ui.js";
@@ -77,12 +77,14 @@ export function groupHelp(prefix, archive = false) {
     });
     if (!subs.length)
         return `strom ${prefix.join(" ")}: not in an archive (research is switched on by the user: strom mode research)`;
+    const also = prefix.length === 1 ? Object.entries(GROUP_ALIASES).filter(([, g]) => g === prefix[0]).map(([a]) => `strom ${a} <command>`) : [];
     return [
         `strom ${prefix.join(" ")} <command>`,
         "",
         table(subs),
         "",
         `Details: strom help ${prefix.join(" ")} <command>`,
+        ...(also.length ? [`Also: ${also.join(" · ")}`] : []),
     ].join("\n");
 }
 /** Words joined with " · ", wrapped to lines of about `width`, the next ones indented. */
@@ -130,6 +132,9 @@ export function helpFor(input, archive, appUrl) {
         return commandHelp(found.def, archive, appUrl);
     if (subcommandsOf(words).length > 0)
         return groupHelp(words, archive);
+    const real = aliasGroup(words);
+    if (real)
+        return groupHelp(real, archive);
     const all = commands().filter((c) => c.path.length > 0).map((c) => c.path.join(" "));
     const near = suggest(words.join(" "), all.filter((c) => c.split(" ").length === words.length));
     return `unknown command "${words.join(" ")}"${near.length ? ` — similar command: ${near.map((c) => `strom help ${c}`).join(" · ")}` : ""}\nall commands: strom help`;
@@ -205,6 +210,9 @@ export function helpAs(input, as) {
         return humanCommand(found.def, as);
     if (subcommandsOf(words).length > 0)
         return humanGroup(words, as);
+    const real = aliasGroup(words);
+    if (real)
+        return humanGroup(real, as);
     const all = commands().filter((c) => c.path.length > 0).map((c) => c.path.join(" "));
     const near = suggest(words.join(" "), all.filter((c) => c.split(" ").length === words.length));
     return [ui(as.lang, "ui.help.unknown", { cmd: words.join(" ") }), ...near.map((c) => `  strom help ${c} --human`)].join("\n");

package/dist/cli/main.js

@@ -30,6 +30,7 @@ import { refreshGlobal } from "../agents/global.js";
 import { expandFromLine, refreshLinks } from "../core/links.js";
 import { clockLine, FINISH_LINE, finishLimitLine, finishOf, timeLine } from "../core/clock.js";
 import { currentSession } from "../core/session.js";
+import { backgroundOf } from "../core/fetching.js";
 import { callMistake, checkArgs, GroupOnly, parseOptions, resolveCommand, firstWord, severalRecords, splitPassthrough, usageOf } from "./execute.js";
 import { placeholders, UI, ui } from "./ui.js";
 import { catalog, localized, sayCommandAs } from "../core/phrases.js";
@@ -409,7 +410,9 @@ export async function main(argv, io, env, cwd) {
         let lang;
         try {
             // an unknown command or option has no context yet: the person's language all the same
-            lang = (ran ?? Context.fromOptions({ env, cwd, io, json, values: {} })).uiLang();
+            // …but a fetch in the background writes into its log, which the agent reads: English, as the rest of it
+            if (!backgroundOf(env))
+                lang = (ran ?? Context.fromOptions({ env, cwd, io, json, values: {} })).uiLang();
         }
         catch {
             // no language to say it in: English

package/dist/cli/registry.js

@@ -33,8 +33,16 @@ export const WRITE_OPTIONS = [
     { name: "reason", type: "string", value: "<text>", description: "why (required when changing or retracting facts)" },
 ];
 const registry = [];
+/**
+ * Other names of a whole group (what agents type for it: "book show" for strom recordset show): each command of the
+ * group is taken by it too — an alias of its own, said in its help ("Also: strom book show") and in strom commands
+ * --json, never a command or group of its own in the overview.
+ */
+export const GROUP_ALIASES = { book: "recordset" };
 export function register(...defs) {
-    for (const def of defs) {
+    for (const given of defs) {
+        const others = Object.entries(GROUP_ALIASES).filter(([, g]) => given.path.length > 1 && given.path[0] === g).map(([a]) => [a, ...given.path.slice(1)]);
+        const def = others.length ? { ...given, aliases: [...(given.aliases ?? []), ...others] } : given;
         const names = [def.path, ...(def.aliases ?? [])].map((p) => p.join(" "));
         if (registry.some((c) => [c.path, ...(c.aliases ?? [])].some((p) => names.includes(p.join(" ")))))
             throw new Error(`duplicate command ${def.path.join(" ")}`);
@@ -72,6 +80,11 @@ export function subcommandsOf(prefix) {
 export function aliasExtends(prefix) {
     return registry.some((c) => (c.aliases ?? []).some((a) => a.length > prefix.length && prefix.every((w, i) => a[i] === w)));
 }
+/** The group another name stands for, when the words are one ("book" → "recordset"), else nothing. */
+export function aliasGroup(prefix) {
+    const real = prefix.length === 1 ? GROUP_ALIASES[prefix[0]] : undefined;
+    return real && subcommandsOf([real]).length ? [real] : undefined;
+}
 export function usageLine(def) {
     const args = (def.args ?? []).map((a) => {
         const name = a.variadic ? `${a.name}...` : a.name;