strom-research 1.15.0-beta.5 → 1.15.0-beta.7

package/CHANGELOG.cs.md

@@ -0,0 +1,50 @@
+# Co je nového ve Strom výzkumu
+
+[English](CHANGELOG.md) · Čeština · [Deutsch](CHANGELOG.de.md)
+
+Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou na
+[GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (anglicky).
+
+## 1.15.0
+
+*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é.
+- **Výzkum čeká na svého agenta.** Rodokmen, jehož AI agent na tomto počítači není, ukládá, co posílá aplikace Strom,
+  jako Archiv Stromu. Jakmile je agent nainstalovaný, výzkum pokračuje sám.
+- **Jedna kniha archivu se stahuje jednou.** Kniha, která už ve výzkumu je, se pojmenuje místo nového zápisu
+  a stahování, takže archiv nikdy nedostane dvakrát žádost o tytéž snímky.
+- **Rychlejší čtení.** Snímky čte současně pět čtenářů (nastavení `read.parallel`, 1 až 10) a dlouhé stahování
+  ukazuje, kolik už je hotovo („40/109 snímků“). Čtenáři začnou už během stahování knihy: snímky se registrují
+  po deseti a co nepřišlo, je řečeno přesně; Ctrl-C ponechá, co už přišlo. Archiv dostane stejné žádosti ve stejném
+  tempu. Kniha se může stahovat i na pozadí, zatímco agent pracuje dál (`strom fetch --background`), nikdy z archivu,
+  který dovoluje jen tempo člověka. Hledání jednoho zápisu může skončit u nálezu (`strom read --until-found`):
+  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í.
+- **Č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“.
+
+## 1.14.0
+
+*11. 10. 2026 · patří k aplikaci Strom 3.11.0.*
+
+- **Podmínky každého archivu.** strom dodržuje, jak daleko každý archiv dovoluje automatický přístup: povoleno,
+  omezeně, jen ručně, nebo vůbec. Kde podmínky nejsou jasné, rozhodne jednou člověk. Odmítnutí archiv na den odloží.
+- **Co čeká, po místech.** Věci pro člověka jsou seřazené podle druhu a seskupené podle toho, kde se vyřizují: jeden
+  archiv, jeden úřad, rodina, jeden web. Dopis nebo dotaz jde označit jako odeslaný.
+- **Čtení starého písma.** Snímky ve velikosti, jakou každý pohled potřebuje, čtenář snímků na modelu, který si člověk
+  zvolil, a čtení vyladěné na vlastních doložených záznamech výzkumu.
+- **S aplikací Strom 3.11.0.** Rozpor mezi úpravou v aplikaci a záznamem se rozhoduje v aplikaci; hypotézy ukazují, co
+  by která varianta spojila.
+- **Menší podklady pro agenta, které vědí víc**, a míra uvažování je volbou člověka (`model.effort`).
+- **`strom grep`** prohledává podklady, poznámky a výstupy výzkumu, i bez ohledu na diakritiku.

package/CHANGELOG.de.md

@@ -0,0 +1,55 @@
+# Was ist neu in Strom Ahnenforschung
+
+[English](CHANGELOG.md) · [Čeština](CHANGELOG.cs.md) · Deutsch
+
+Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Installationszeilen stehen bei
+[GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (auf Englisch).
+
+## 1.15.0
+
+*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
+  neuen ändern.
+- **Eine Forschung wartet auf ihren Agenten.** Ein Stammbaum, dessen KI-Agent nicht auf diesem Computer ist, speichert,
+  was die Strom-App sendet, wie ein Strom-Archiv. Sobald der Agent installiert ist, geht die Forschung von selbst weiter.
+- **Ein Buch eines Archivs, einmal geladen.** Ein Buch, das schon in der Forschung ist, wird genannt, statt neu
+  eingetragen und wieder geladen zu werden – ein Archiv wird nie zweimal um dieselben Bilder gebeten.
+- **Schneller lesen.** Fünf Leser lesen die Scans gleichzeitig (die Einstellung `read.parallel`, 1 bis 10), und ein
+  langer Download zeigt, wie weit er ist („40/109 Bilder“). Die Leser beginnen schon, während ein Buch lädt: seine
+  Bilder werden zu zehnt registriert, und was nicht kam, wird genau gesagt; Strg+C behält, was schon kam. Ein Archiv
+  bekommt dieselben Anfragen im selben Tempo wie bisher. Ein Buch kann auch im Hintergrund laden, während der Agent
+  weiterarbeitet (`strom fetch --background`), nie aus einem Archiv, das nur das Tempo eines Menschen erlaubt. Die
+  Suche nach einem Eintrag kann beim Fund enden (`strom read --until-found`): die gelesenen Bilder werden genau gesagt,
+  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.
+- **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“.
+
+## 1.14.0
+
+*11.10.2026 · gehört zur Strom-App 3.11.0.*
+
+- **Die Bedingungen jedes Archivs.** strom hält sich daran, wie weit jedes Archiv automatischen Zugriff erlaubt:
+  erlaubt, eingeschränkt, nur von Hand oder gar nicht. Wo die Bedingungen unklar sind, entscheidet einmal der Mensch.
+  Eine Ablehnung pausiert ein Archiv für einen Tag.
+- **Was wartet, nach Orten.** Die Dinge für den Menschen sind nach Art sortiert und danach gruppiert, wo sie erledigt
+  werden: ein Archiv, ein Amt, die Familie, eine Website. Ein Brief oder eine Frage lässt sich als verschickt markieren.
+- **Alte Handschrift lesen.** Scans in der Größe, die jede Ansicht braucht, ein Leser der Scans auf dem Modell, das der
+  Mensch gewählt hat, und das Lesen abgestimmt auf die eigenen belegten Einträge der Forschung.
+- **Mit der Strom-App 3.11.0.** Ein Widerspruch zwischen einer Änderung in der App und einem Eintrag wird in der App
+  entschieden; Hypothesen zeigen, was jede Variante verbinden würde.
+- **Kleinere Unterlagen für den Agenten, die mehr wissen**, und der Denkaufwand ist die Wahl des Menschen
+  (`model.effort`).
+- **`strom grep`** durchsucht die Unterlagen, Notizen und Ausgaben der Forschung, auch über Akzente hinweg.

package/CHANGELOG.md

@@ -0,0 +1,50 @@
+# What's new in Strom Research
+
+English · [Čeština](CHANGELOG.cs.md) · [Deutsch](CHANGELOG.de.md)
+
+The changes of each version in short. The full notes and the install lines are on
+[GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases).
+
+## 1.15.0
+
+*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.
+- **A research waiting for its agent.** A family tree whose AI agent is not on this computer keeps what the Strom app
+  sends, as a Strom archive does. Once the agent is installed, the research goes on by itself.
+- **One book of an archive, fetched once.** A book already in the research is named instead of being registered and
+  fetched again, so an archive is never asked twice for the same images.
+- **Faster reading.** Five readers read the scans at the same time (the setting `read.parallel`, 1 to 10), and a long
+  download says how far it is ("40/109 images"). The readers begin while a book is still downloading: its images are
+  registered ten at a time, and what did not come is said exactly; Ctrl-C keeps what came. An archive gets the same
+  requests at the same pace. A book can also be fetched in the background while the agent works on (`strom fetch
+  --background`), never from an archive that allows only a person's pace. A search for one entry can stop at the find
+  (`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.
+- **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.
+
+## 1.14.0
+
+*2026-10-11 · goes with the Strom app 3.11.0.*
+
+- **Each archive's terms.** strom keeps to how far each archive allows automated access: allowed, restricted, by hand
+  only, or not at all. Where the terms are unclear, the person decides once. A refusal pauses an archive for a day.
+- **What waits, in places.** Things for the person are sorted by kind and grouped by where they are done: one archive,
+  one office, the family, one site. A letter or a question can be marked as sent.
+- **Reading old handwriting.** Scans at the size each view needs, a reader of scans on the person's model, and the
+  reading tuned on the research's own proven records.
+- **With the Strom app 3.11.0.** A conflict between an edit in the app and a record is decided in the app; hypotheses
+  show what each variant would connect.
+- **A smaller brief that knows more**, and the reasoning effort is the person's choice (`model.effort`).
+- **`strom grep`** searches the research's inputs, notes and output, through accents too.

package/assets/lang/cs.json

@@ -250,6 +250,7 @@
   "ui.tune.book.weak": "zápory na slabých skenech {n} z {of}",
   "ui.tune.book.requests": "požadavky {n}",
   "ui.tune.book.unread": "staženo a nepřečteno {n} z {of}",
+  "ui.tune.book.background": "na pozadí: nepřečteno {n} z {of}",
   "ui.tune.hosts": "Archivy:",
   "ui.tune.host": "  {host}: sezení {sessions} · požadavky {requests} ({perSession} na sezení, {perImage} na snímek) · čekání {wait} min · limit vyčerpán {later}×",
   "ui.tune.web": "Webové nástroje agenta:",

package/assets/lang/de.json

@@ -250,6 +250,7 @@
   "ui.tune.book.weak": "Negativbefunde auf schwachen Scans {n} von {of}",
   "ui.tune.book.requests": "Anfragen {n}",
   "ui.tune.book.unread": "geladen und nie gelesen {n} von {of}",
+  "ui.tune.book.background": "im Hintergrund: nie gelesen {n} von {of}",
   "ui.tune.hosts": "Archive:",
   "ui.tune.host": "  {host}: Sitzungen {sessions} · Anfragen {requests} ({perSession} pro Sitzung, {perImage} pro Bild) · gewartet {wait} min · Limit erschöpft {later}×",
   "ui.tune.web": "Eigene Webwerkzeuge des Agenten:",

package/assets/method/core.md

@@ -102,6 +102,10 @@ conclusion so the next researcher can follow it.
   number by one or two images, never a batch of ten; an entry: its image ±1
   (it may run over a page). An archive that allows automation: batches as
   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. 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:
@@ -65,6 +66,13 @@ never open again a view cleared from your context — your notes hold it.
   and headings only, one surname's entries, one entry whole — and transcribes
   nothing else. Record each report as it comes back, before the next readers.
   Only the entries that will be cited need your own eyes, at full resolution.
+<!-- for link verify enrich -->
+- **`--until-found` only for ONE particular entry** (one person's baptism,
+  marriage or burial whose details you know): no more readers begin once one
+  reports it. Never for every entry of a place or surname, nor where a
+  namesake may follow. Record only the images it names as read, `--result
+  partial`; if the find is not the one, read the rest.
+<!-- end -->
 - **Report image by image, as you go**: the image and page, what was found (or
   nothing), what was illegible and where, the hand, how sure each name is.
 - **Cite the image, and where the entry is on it**: `strom source add …

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";
@@ -39,6 +39,7 @@ import { ENRICH_PAGES, STORY_SOURCES_ORIGIN } from "../core/stories.js";
 import { sandboxOf, WITHOUT_READERS } from "../core/sandbox.js";
 import { WEB_SOFT } from "../core/metrics.js";
 import { indexBriefLines } from "../core/indexfirst.js";
+import { activeFetches, endedFetches } from "../core/fetching.js";
 /** The hosts of a connector, as its manifest names them (a wildcard without its star). */
 function connectorHosts(shared, name) {
     try {
@@ -627,6 +628,15 @@ function imagesLines(tree, b, route, shape, finder, noSharper = false, waiting)
                         : ""),
     ].filter(Boolean);
 }
+/** 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 ${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 ${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). */
 function inboxLines(shared) {
     if (!shared)
@@ -1197,6 +1207,15 @@ export function buildBrief(tree, opts) {
                 '  strom media add --inbox "<folder>" --recordset B…   · a document (certificate, letter): strom intake <file>',
             ].join("\n"),
         });
+    // 7c. images being fetched for the research now (strom fetch --background of an earlier session, or another strom),
+    // and what fetches in the background left unfetched lately: read as they come, never fetched twice
+    const fetching = fetchingLines(tree.root);
+    if (fetching.length)
+        sections.push({
+            name: "fetching",
+            pointer: "strom fetch --status",
+            text: ["## Images being fetched now (strom fetch --status)", ...fetching].join("\n"),
+        });
     // 8. method for this kind of task
     // (budgeted first, with the record sets and the commands: when the brief is long, the lists are cut before how to work)
     // only the parts the level uses — of getting images, those of how this task's record sets get them (none named:

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
-    fetch: ["take", "result", "again"],
+    // 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/commit.js

@@ -13,7 +13,9 @@ export function commitMessage(summaries, command) {
 /** Commit the changes of this command. Returns what blocked the commit, if anything did. */
 export function autoCommit(ctx, def) {
     const tree = ctx.current();
-    if (!tree || tree.dryRun || tree.written.length === 0)
+    // what an earlier commit of the same command holds already (strom fetch commits each batch of images) is not again
+    const ops = tree?.uncommitted() ?? [];
+    if (!tree || tree.dryRun || ops.length === 0)
         return undefined;
     // Incremental gate: records were validated when written; here only what
     // changed since the last commit is checked, so the cost stays flat.
@@ -30,11 +32,11 @@ export function autoCommit(ctx, def) {
             problems: errors.map((f) => ({ ...(f.id ? { id: f.id } : {}), ...(f.file ? { file: f.file } : {}), message: f.message })),
         };
     }
-    const message = commitMessage(tree.written.map((o) => o.summary), `strom ${def.path.join(" ")}`);
+    const message = commitMessage(ops.map((o) => o.summary), `strom ${def.path.join(" ")}`);
     // Only the files this command wrote, plus the free-form folders the agent
     // may edit — `git add` then never has to scan the whole data/ tree.
     const written = new Set(["data/_counters.json"]);
-    for (const op of tree.written)
+    for (const op of ops)
         for (const f of op.files)
             written.add(f.path);
     for (const f of tree.opsFilesTouched())
@@ -43,6 +45,7 @@ export function autoCommit(ctx, def) {
     // commit of something else (found on Windows: strom mode committed a file of the user's) — nor by the switch itself
     const free = isArchive(tree) || def.path[0] === "mode" ? ["inputs", "output"] : ["notes", "tools", "inputs", "output"];
     tree.withTreeLock(() => tree.commit(message, [...written, ...free]));
+    tree.markCommitted();
     tree.settle();
     return undefined;
 }