strom-research 1.13.2-beta.5 → 1.13.2-beta.6

package/assets/lang/cs.json

@@ -137,6 +137,37 @@
   "ui.chat.app.model.chosen": "V aplikaci {app} zvolit pro výzkum model {model} (zvolený v nastavení).",
   "ui.settings.model": "Model výzkumu ({agent}): {model}",
   "ui.settings.model.own": "vlastní model agenta",
+  "ui.views.title": "Ladění čtení snímků · {agent}: snímků {n}, knih {books}, velikosti {sizes} px",
+  "ui.views.find": "Nalezení zápisu na celém snímku:",
+  "ui.views.find.row": "  {size} px  na místě {located} z {n} · na snímku bez něj {wrong} z {neg} · {cost}",
+  "ui.views.read": "Přečtení zápisu z poloviny nebo strany:",
+  "ui.views.read.row": "  {size} px  přečteno {keys} z {total} · nejistých míst {unsure} · {cost}",
+  "ui.views.rule": "Menší velikost se uloží jen při jasném výsledku: každý zápis nalezený na místě jako u největší velikosti a žádný navíc na snímku bez něj; přečteno celkem aspoň tolik, žádný zápis o víc než jeden údaj méně, nejistých míst ne víc.",
+  "ui.views.stored": "Uloženo pro {agent} ({date}): hledání {find} px · čtení {read} px — řídí se tím strom media view a strom read; zpět na výchozí: strom media calibrate --reset",
+  "ui.views.kept": "Bez jasného výsledku: nic se neuložilo, velikosti zůstávají, jak byly.",
+  "ui.views.unclear.find": "Hledání: bez jasného výsledku — zůstává výchozí ({size} px).",
+  "ui.views.unclear.read": "Čtení: bez jasného výsledku — zůstává výchozí ({size} px).",
+  "ui.views.failed": "Čtení, která nedoběhla: {failed} — nic se neuložilo, velikosti zůstávají, jak byly.",
+  "ui.views.few": "Na vyladění čtení snímků je málo snímků se známou pravdou: {have} z potřebných {need}. Takový snímek je sken záznamu, který cituje doložený údaj, s jeho slovy (přepisem) a už na tomto počítači; chybí ještě {more} — vzniknou běžnou prací agenta, zkusit znovu po několika sezeních. Do té doby platí výchozí velikosti.",
+  "ui.views.ask": "Vyladit čtení snímků pro {agent}: {readers} placených čtení {n} snímků tohoto výzkumu ve velikostech {sizes} px, asi {cost} (typický odhad; ceny agenta se mohou lišit). Spustit?",
+  "ui.views.no": "Nic se nespustilo; velikosti zůstávají, jak byly.",
+  "ui.views.reset": "Vyladění pro {agent} zapomenuto: platí výchozí velikosti (hledání {find} px · čtení {read} px).",
+  "ui.views.reset.none": "Pro {agent} nic vyladěno není: platí výchozí velikosti (hledání {find} px · čtení {read} px).",
+  "ui.views.estimate": "Snímků {n}, knih {books}, {readers} čtení ve velikostech {sizes} px, asi {cost} — spouští člověk: strom media calibrate",
+  "ui.views.offer": "čtení snímků bylo vyladěno pro {before}, pro {now} zatím ne: strom media calibrate (spouští člověk; placená práce modelu)",
+  "ui.views.progress": "▶ {what} · {size} px · snímky: {n}",
+  "ui.views.what.find": "hledání",
+  "ui.views.what.read": "čtení",
+  "ui.views.cost.unknown": "cena neznámá",
+  "ui.views.spent": "Čtení stála {cost}.",
+  "ui.o.views": "snímky",
+  "ui.settings.views": "Vyladit čtení snímků ({state})",
+  "ui.settings.views.default": "výchozí velikosti",
+  "ui.settings.views.done": "vyladěno {date}",
+  "ui.settings.views.other": "zatím vyladěno pro jiný model",
+  "ui.doc.views": "čtení snímků",
+  "ui.doc.views.default": "výchozí velikosti: hledání {find} px · čtení {read} px",
+  "ui.doc.views.done": "vyladěno {date}: hledání {find} px · čtení {read} px",
   "ui.setup.level": "Co smí agent dělat bez ptaní?",
   "ui.setup.level.ask": "Ptát se mě na všechno mimo výzkum",
   "ui.setup.level.auto": "Pracovat samostatně – ptát se jen u riskantních kroků (doporučeno)",
@@ -662,6 +693,7 @@
   "ui.help.cmd.pack": "Zabalit výzkum do jednoho souboru ZIP, aby v něm mohl pokračovat někdo jiný",
   "ui.help.cmd.unpack": "Rozbalit rodokmen, který někdo poslal",
   "ui.help.cmd.tidy": "Uvolnit místo, které si strom drží vedle výzkumu (nejdřív ukáže, pak se zeptá)",
+  "ui.help.cmd.media.calibrate": "Vyladit velikost snímků pro agenta a model výzkumu na jeho vlastních doložených záznamech (placená práce modelu; cena se řekne předem)",
   "ui.help.cmd.check": "Zkontrolovat výzkum: vše v pořádku, nic změněné mimo strom",
   "ui.help.cmd.config.get": "Přečíst nastavení",
   "ui.help.cmd.config.set": "Změnit nastavení",
@@ -978,7 +1010,7 @@
   "ui.run.which.bad": "Čísla ze seznamu, 1 až {n}: např. 2 nebo 1,4 nebo 2-5.",
   "ui.run.limit": "Na jeden úkol má agent nejvýš {minutes} minut; pak ho strom zastaví a úkol vrátí do fronty (nastavení run.minutes).",
   "ui.run.empty": "Fronta je prázdná – co hledat, stačí agentovi říct v rozhovoru.",
-  "ui.run.browser": "· {name}: snímky přes prohlížeč – agent dostane nástroje prohlížeče pro {hosts}; musí běžet Chrome s rozšířením Claude",
+  "ui.run.browser": "· {name}: snímky přes prohlížeč – nástroje prohlížeče pro {hosts} v sezeních, jejichž úkol je může potřebovat; musí běžet Chrome s rozšířením Claude",
   "ui.run.browser.model": "  pozor: nástroje prohlížeče potřebují model, který své kroky zkontroluje – Sonnet nebo Opus, ne {model}: strom config set model.lead sonnet",
   "ui.run.full": "· oprávnění: plná – agent smí vše kromě toho, co oprávnění rodokmenu zakazují (zpět: strom config set agent.permissions auto)",
   "ui.menu.working.more": "Samostatně teď pracují agenti: {n}.",
@@ -994,6 +1026,11 @@
   "ui.run.gate.no": "ne",
   "ui.run.gate.noanswer": "neodpověděla, jak má (strom gate test)",
   "ui.run.stop.gate.declined": "nespuštěno — podmínka „{name}“: {reason}",
+  "ui.run.gate.cap": "· {name}: nastavený strop – kontroluje se před každým sezením; žádné „přesto začít“ ho nepřekročí",
+  "ui.run.stop.gate.cap": "strop podmínky „{name}“ – {reason} (pevná hranice z run.gate; „přesto začít“ ji nepřekročí)",
+  "ui.run.cap.finish": "⏳ {session}: limit agenta na {used} % ({kind}) – sezení dostalo žádost zapsat, co našlo, a skončit; za stropem další sezení nezačne",
+  "ui.run.limit.five_hour": "pětihodinové okno",
+  "ui.run.limit.seven_day": "týden",
   "ui.run.loop": "Nechat ho pracovat, dokud je co dělat a dovolí to podmínka „{name}“",
   "ui.consent.gate.set": "Nechat podmínku „{name}“ rozhodovat, kdy agent pracující sám pokračuje?",
   "ui.consent.gate.unset": "Odebrat podmínku „{name}“ — agent pracující sám se jí už nebude ptát?",
@@ -1318,6 +1355,24 @@
   "log.research.done": "Směr ukončen: {name}",
   "log.mode.archive": "Výzkum je teď archiv",
   "log.mode.research": "Výzkum je znovu zapnutý",
+  "log.reading.loose": "Pročteno snímků: {n}",
+  "log.clips": "Zápisy vyznačené na snímcích: {n} z {total}",
+  "log.transcripts": "Zápisy přepsané z výřezů: {n} z {total}",
+  "log.tree.create": "Výzkum založen: {name}",
+  "log.repair": "Data vrácena do posledního zapečetěného stavu",
+  "log.chat.saved": "Uloženo po rozhovoru s agentem",
+  "log.migrate": "Data rodokmenu převedena pro novější strom",
+  "log.setting": "Změněno nastavení výzkumu: {key}",
+  "log.image": "{name}, obr. {image}",
+  "log.media.edit": "Upravený snímek: {name}",
+  "log.media.retract": "Odvolaný snímek: {name}",
+  "log.input.edit": "Materiál doplněn: {name}",
+  "log.input.skip": "Materiál odložen jako nepoužitelný: {name}",
+  "log.input.sort": "Materiál roztříděn: {name}",
+  "log.record.edit": "Upraveno: {name}",
+  "ui.gate.timeout": "neodpověděla do {s} s",
+  "ui.gate.signal": "ukončena signálem {signal}",
+  "ui.gate.status": "skončila s kódem {status}",
   "ui.waiting.title": "Agent potřebuje ({n}):",
   "ui.waiting.do": "Co udělat: {what}",
   "ui.waiting.ask": "agent to řekne v rozhovoru",
@@ -1478,6 +1533,13 @@
   "ui.gate.asked": "před každým sezením strom run se ptá: {gate} (strom config unset run.gate: žádná)",
   "ui.gate.unset": "žádná se neptá: strom config set run.gate <název> (jen uživatel)",
   "ui.gate.folder": "složka: {folder} – složka podmínky nakopírovaná sem je nainstalovaná (rozhraní: README.md tamtéž)",
+  "ui.gate.cap.week": "strop nastaven: ptá se před každým sezením každého běhu; sezení v práci je požádáno o dokončení při {pct} % týdne",
+  "ui.gate.cap.window": "strop nastaven: ptá se před každým sezením každého běhu; sezení v práci je požádáno o dokončení při {pct} % pětihodinového okna",
+  "ui.gate.test.go": "pokračovat",
+  "ui.gate.test.wait": "počkat do {at}",
+  "ui.gate.test.stop": "zastavit",
+  "ui.gate.test.error": "chyba – běh by se zastavil",
+  "ui.gate.test.hard": "(strop: pevné zastavení, žádné „přesto začít“)",
   "ui.hook.none": "žádné hooky",
   "ui.hook.on": "zapnuté: {hooks} (strom hook off <název>)",
   "ui.hook.unset": "žádný není zapnutý: strom hook on <název> (jen uživatel)",

package/assets/lang/de.json

@@ -137,6 +137,37 @@
   "ui.chat.app.model.chosen": "In {app} für die Forschung das Modell {model} wählen (das in den Einstellungen gewählte).",
   "ui.settings.model": "Modell der Forschung ({agent}): {model}",
   "ui.settings.model.own": "das eigene des Agenten",
+  "ui.views.title": "Abstimmung des Lesens der Scans · {agent}: {n} Bilder aus {books} Büchern, Größen {sizes} px",
+  "ui.views.find": "Finden eines Eintrags auf dem ganzen Bild:",
+  "ui.views.find.row": "  {size} px  an der Stelle {located} von {n} · auf einem Bild ohne ihn {wrong} von {neg} · {cost}",
+  "ui.views.read": "Lesen eines Eintrags aus einer Hälfte oder einer Seite:",
+  "ui.views.read.row": "  {size} px  gelesen {keys} von {total} · unsichere Stellen {unsure} · {cost}",
+  "ui.views.rule": "Eine kleinere Größe wird nur bei klarem Ergebnis gespeichert: jeder Eintrag an der Stelle gefunden wie bei der größten Größe und keiner mehr auf einem Bild ohne ihn; insgesamt mindestens so viel gelesen, kein Eintrag um mehr als eine Angabe weniger, nicht mehr unsichere Stellen.",
+  "ui.views.stored": "Gespeichert für {agent} ({date}): Suchen {find} px · Lesen {read} px — danach richten sich strom media view und strom read; zurück zu den Vorgaben: strom media calibrate --reset",
+  "ui.views.kept": "Kein klares Ergebnis: nichts gespeichert, die Größen bleiben, wie sie waren.",
+  "ui.views.unclear.find": "Suchen: kein klares Ergebnis — die Vorgabe bleibt ({size} px).",
+  "ui.views.unclear.read": "Lesen: kein klares Ergebnis — die Vorgabe bleibt ({size} px).",
+  "ui.views.failed": "Nicht beendete Lesungen: {failed} — nichts gespeichert, die Größen bleiben, wie sie waren.",
+  "ui.views.few": "Zu wenige Bilder mit bekannter Wahrheit, um das Lesen der Scans abzustimmen: {have} von {need} nötigen. Ein solches Bild ist der Scan eines Eintrags, den eine belegte Angabe zitiert, mit seinem Wortlaut (einer Abschrift), schon auf diesem Computer; {more} weitere entstehen durch die gewöhnliche Arbeit des Agenten — nach einigen Sitzungen erneut versuchen. Bis dahin gelten die vorgegebenen Größen.",
+  "ui.views.ask": "Das Lesen der Scans für {agent} abstimmen: {readers} bezahlte Lesungen von {n} Bildern dieser Forschung in {sizes} px, etwa {cost} (ein typischer Wert; die Preise des Agenten können abweichen). Starten?",
+  "ui.views.no": "Nichts gestartet; die Größen bleiben, wie sie waren.",
+  "ui.views.reset": "Die Abstimmung für {agent} ist vergessen: es gelten die vorgegebenen Größen (Suchen {find} px · Lesen {read} px).",
+  "ui.views.reset.none": "Für {agent} ist nichts abgestimmt: es gelten die vorgegebenen Größen (Suchen {find} px · Lesen {read} px).",
+  "ui.views.estimate": "{n} Bilder aus {books} Büchern, {readers} Lesungen in {sizes} px, etwa {cost} — startet ein Mensch: strom media calibrate",
+  "ui.views.offer": "das Lesen der Scans wurde für {before} abgestimmt, für {now} noch nicht: strom media calibrate (startet ein Mensch; bezahlte Arbeit des Modells)",
+  "ui.views.progress": "▶ {what} · {size} px · Bilder: {n}",
+  "ui.views.what.find": "Suchen",
+  "ui.views.what.read": "Lesen",
+  "ui.views.cost.unknown": "Kosten unbekannt",
+  "ui.views.spent": "Die Lesungen kosteten {cost}.",
+  "ui.o.views": "Scans",
+  "ui.settings.views": "Das Lesen der Scans abstimmen ({state})",
+  "ui.settings.views.default": "die vorgegebenen Größen",
+  "ui.settings.views.done": "abgestimmt {date}",
+  "ui.settings.views.other": "bisher für ein anderes Modell abgestimmt",
+  "ui.doc.views": "Lesen der Scans",
+  "ui.doc.views.default": "die vorgegebenen Größen: Suchen {find} px · Lesen {read} px",
+  "ui.doc.views.done": "abgestimmt {date}: Suchen {find} px · Lesen {read} px",
   "ui.setup.level": "Was darf der Agent tun, ohne nachzufragen?",
   "ui.setup.level.ask": "Mich bei allem außerhalb der Forschung fragen",
   "ui.setup.level.auto": "Selbstständig arbeiten – nur bei riskanten Schritten fragen (empfohlen)",
@@ -662,6 +693,7 @@
   "ui.help.cmd.pack": "Die Forschung in eine ZIP-Datei packen, damit jemand anderes weitermachen kann",
   "ui.help.cmd.unpack": "Einen zugeschickten Stammbaum entpacken",
   "ui.help.cmd.tidy": "Platz freigeben, den strom neben der Forschung belegt (erst gezeigt, nach Zustimmung)",
+  "ui.help.cmd.media.calibrate": "Die Größe der Scan-Ansichten für Agent und Modell der Forschung an ihren eigenen belegten Einträgen abstimmen (bezahlte Arbeit des Modells; die Kosten werden vorher genannt)",
   "ui.help.cmd.check": "Die Forschung prüfen: alles in Ordnung, nichts an strom vorbei geändert",
   "ui.help.cmd.config.get": "Eine Einstellung lesen",
   "ui.help.cmd.config.set": "Eine Einstellung ändern",
@@ -978,7 +1010,7 @@
   "ui.run.which.bad": "Nummern aus der Liste, 1 bis {n}: z. B. 2 oder 1,4 oder 2-5.",
   "ui.run.limit": "Für eine Aufgabe hat der Agent höchstens {minutes} Minuten; dann hält strom ihn an und die Aufgabe kommt zurück in die Warteschlange (Einstellung run.minutes).",
   "ui.run.empty": "Die Warteschlange ist leer – dem Agenten im Gespräch sagen, was er suchen soll.",
-  "ui.run.browser": "· {name}: Bilder über den eigenen Browser – der Agent bekommt Browser-Werkzeuge für {hosts}; Chrome mit der Claude-Erweiterung muss laufen",
+  "ui.run.browser": "· {name}: Bilder über den eigenen Browser – Browser-Werkzeuge für {hosts} in den Sitzungen, deren Aufgabe sie brauchen kann; Chrome mit der Claude-Erweiterung muss laufen",
   "ui.run.browser.model": "  Hinweis: Browser-Werkzeuge brauchen ein Modell, das seine Schritte prüft – Sonnet oder Opus, nicht {model}: strom config set model.lead sonnet",
   "ui.run.full": "· Berechtigungen: voll – der Agent darf alles außer dem, was die Berechtigungen des Stammbaums verbieten (zurück: strom config set agent.permissions auto)",
   "ui.menu.working.more": "Gerade arbeiten Agenten selbstständig: {n}.",
@@ -994,6 +1026,11 @@
   "ui.run.gate.no": "nein",
   "ui.run.gate.noanswer": "keine gültige Antwort (strom gate test)",
   "ui.run.stop.gate.declined": "nicht gestartet — die Bedingung „{name}“: {reason}",
+  "ui.run.gate.cap": "· {name}: eine Obergrenze ist gesetzt – vor jeder Sitzung geprüft; kein „trotzdem starten“ geht darüber hinaus",
+  "ui.run.stop.gate.cap": "die Obergrenze der Bedingung „{name}“ – {reason} (eine feste Grenze aus run.gate; kein „trotzdem starten“ geht darüber hinaus)",
+  "ui.run.cap.finish": "⏳ {session}: das Limit des Agenten bei {used} % ({kind}) – die Sitzung ist gebeten aufzuschreiben, was gefunden wurde, und zu schließen; über der Obergrenze beginnt keine nächste Sitzung",
+  "ui.run.limit.five_hour": "Fünf-Stunden-Fenster",
+  "ui.run.limit.seven_day": "Woche",
   "ui.run.loop": "Weiterarbeiten lassen, solange es Arbeit gibt und die Bedingung „{name}“ es erlaubt",
   "ui.consent.gate.set": "Die Bedingung „{name}“ entscheiden lassen, wann der allein arbeitende Agent weitermacht?",
   "ui.consent.gate.unset": "Die Bedingung „{name}“ entfernen — der allein arbeitende Agent fragt sie nicht mehr?",
@@ -1318,6 +1355,24 @@
   "log.research.done": "Richtung beendet: {name}",
   "log.mode.archive": "Die Forschung ist jetzt ein Archiv",
   "log.mode.research": "Die Forschung ist wieder eingeschaltet",
+  "log.reading.loose": "Durchgelesene Bilder: {n}",
+  "log.clips": "Einträge auf ihren Scans markiert: {n} von {total}",
+  "log.transcripts": "Einträge aus ihren Ausschnitten abgeschrieben: {n} von {total}",
+  "log.tree.create": "Forschung begonnen: {name}",
+  "log.repair": "Die Daten auf den zuletzt versiegelten Stand zurückgesetzt",
+  "log.chat.saved": "Nach einem Gespräch mit dem Agenten gespeichert",
+  "log.migrate": "Die Daten des Stammbaums für ein neueres strom aktualisiert",
+  "log.setting": "Einstellung der Forschung geändert: {key}",
+  "log.image": "{name}, Bild {image}",
+  "log.media.edit": "Bild geändert: {name}",
+  "log.media.retract": "Bild zurückgezogen: {name}",
+  "log.input.edit": "Material ergänzt: {name}",
+  "log.input.skip": "Material als unbrauchbar beiseitegelegt: {name}",
+  "log.input.sort": "Material sortiert: {name}",
+  "log.record.edit": "Geändert: {name}",
+  "ui.gate.timeout": "keine Antwort innerhalb von {s} s",
+  "ui.gate.signal": "durch {signal} beendet",
+  "ui.gate.status": "mit Exit-Status {status} beendet",
   "ui.waiting.title": "Der Agent braucht eine Antwort ({n}):",
   "ui.waiting.do": "Was zu tun ist: {what}",
   "ui.waiting.ask": "der Agent sagt es im Gespräch",
@@ -1478,6 +1533,13 @@
   "ui.gate.asked": "vor jeder Sitzung von strom run gefragt: {gate} (strom config unset run.gate: keine)",
   "ui.gate.unset": "keine wird gefragt: strom config set run.gate <Name> (nur der Benutzer)",
   "ui.gate.folder": "Ordner: {folder} – der hineinkopierte Ordner einer Bedingung ist installiert (die Schnittstelle: README.md dort)",
+  "ui.gate.cap.week": "Obergrenze gesetzt: vor jeder Sitzung jedes Laufs gefragt; eine laufende Sitzung wird bei {pct} % der Woche um den Abschluss gebeten",
+  "ui.gate.cap.window": "Obergrenze gesetzt: vor jeder Sitzung jedes Laufs gefragt; eine laufende Sitzung wird bei {pct} % des Fünf-Stunden-Fensters um den Abschluss gebeten",
+  "ui.gate.test.go": "weiter",
+  "ui.gate.test.wait": "warten bis {at}",
+  "ui.gate.test.stop": "anhalten",
+  "ui.gate.test.error": "Fehler – ein Lauf würde anhalten",
+  "ui.gate.test.hard": "(Obergrenze: ein fester Halt, kein „trotzdem starten“)",
   "ui.hook.none": "keine Hooks",
   "ui.hook.on": "eingeschaltet: {hooks} (strom hook off <Name>)",
   "ui.hook.unset": "keiner ist eingeschaltet: strom hook on <Name> (nur der Benutzer)",

package/assets/method/core.md

@@ -4,14 +4,14 @@ You work to the Genealogical Proof Standard: search thoroughly, cite every
 fact, analyse and correlate the evidence, resolve conflicts, and write the
 conclusion so the next researcher can follow it.
 
-<!-- for link verify enrich intake locate narrate -->
+<!-- for link verify enrich intake locate narrate links -->
 - **Certainty is explicit.** `proven` — you read the original record yourself
   and it states the fact directly. `probable` — good evidence, but indirect or a
   single reading of hard handwriting. `possible` — weak evidence. `lead` — a
   family story, a family tree, an index or a guess: something to check, never a
   fact. Family trees and memories are leads, always.
 <!-- end -->
-<!-- for link verify enrich intake locate -->
+<!-- for link verify enrich intake locate links -->
 - **A namesake is not your person.** Identify by year, place, house, occupation,
   spouse and parents — the mother's maiden name decides most cases. Two entries
   that give one name different parents (another mother) are **two people** —
@@ -65,7 +65,7 @@ conclusion so the next researcher can follow it.
   (`strom task list --off-tree`); they come back by themselves once the link
   is recorded.
 <!-- end -->
-<!-- for link verify enrich intake -->
+<!-- for link verify enrich intake links -->
 - **Say what a hypothesis would connect.** A hypothesis about a connection —
   whose child, the same person, a couple, siblings — gets each variant's links
   when you record or argue it: `strom hypothesis link H… B --child P… --of F…`
@@ -80,6 +80,16 @@ conclusion so the next researcher can follow it.
   links names the variant it is decided for:
   `strom hypothesis decide H… --variant B --decision "…"`.
 <!-- end -->
+<!-- for links -->
+  Read each variant whole (`strom hypothesis show H…`) and the people it
+  names (`strom person show P…`, `strom family show F…`); link only what its
+  words say beyond doubt — a namesake stays out. A link its claim does not say
+  comes off with `strom hypothesis link H… B --remove`; a variant that
+  connects nothing clear keeps none, and one that says what the tree records
+  already (marked so) has no link to make — the hypothesis stays open until
+  the records decide it. You read no records here: what would
+  decide a hypothesis is a task (`strom task add … --about H…`), not a search now.
+<!-- end -->
 - **Stay within the task.** New questions become new tasks (`strom task add`,
   with where and done-when), not detours.
 <!-- for link verify enrich intake locate -->

package/assets/method/reading.md

@@ -7,9 +7,9 @@ search depends on** (a surname, a birthplace, a parish) is read again on a
 crop at full resolution before it is recorded; what stays unsure is recorded
 as unsure and said so.
 
-Every image you open stays in your context to the end of the session: look at
-as few pixels as the question needs, write down what you saw at once, and after
-about 80 views write down what you found before you open more.
+Look at as few pixels as the question needs and write down what you saw at
+once: after about 30 views write down what you found before you open more, and
+never open again a view cleared from your context — your notes hold it.
 
 - **Look only through views**: `strom media view B0001:57` (record set and
   image number) makes a file in `.strom/views/` — open that file. Whole images
@@ -24,18 +24,19 @@ about 80 views write down what you found before you open more.
   page, where they are sharper than one view of it), `--crop … --crop …`
   (several entries of one image), `--split 2x2` (a page in overlapping parts),
   `strom media view B0001 --page 112 113`. Each file comes with its image, page
-  and `--clip`. At most 12 images and 24 views in one call.
+  and `--clip`. At most 12 images and 24 views in one call: with 4 views an
+  image (halves and crops), 6 images a call.
 - **Find, then crop.** `--grid` overlays tenths with labels; read off where the
   entry is and ask for exactly that part: `--crop 0.05,0.40,0.45,0.18` (x, y,
   width, height as fractions) or `--half left|right` for one page of a spread.
   A crop comes at full resolution (small ones enlarged). `--contrast` for faded
   ink, `--rotate 90` for sideways pages.
 <!-- for link verify enrich part -->
-- **Too small to read?** When a crop says it is enlarged, the scan has no more
-  detail there. A connector that can fetch a part of an image sharper says so
-  in that line: `strom fetch <connector> --recordset B0001 --images 57 --crop
-  …` (one request). Then view the same crop again: it comes from the sharper
-  part by itself.
+- **Too small to read?** A crop said enlarged: the scan has no more detail.
+  A connector that fetches a part sharper says so in that line: `strom fetch
+  <connector> --recordset B0001 --images 57 --crop …`; the same crop viewed
+  again comes from it. Whole images first, a part only where entries need
+  it: an archive's hourly cap stops the rest.
 <!-- end -->
 - **Browsing a book is a reader's job**: `strom read B0001 --images 40-69
   --question "…"` — readers in batches of ten, each with the full question.
@@ -51,8 +52,8 @@ about 80 views write down what you found before you open more.
   foreground and let it finish — your session ends with your turn, and
   whatever is left running in the background ends with it.
   (A scan-reader subagent where your agent has one, strom-scan-reader, or your
-  own subagents — on your own model, never a faster one — read too, in batches
-  of at most twelve with the whole question; what they report is lost with
+  own subagents — on your own model, never a faster one — read too, about six scans
+  each with the whole question; what they report is lost with
   your session unless you write it down: record each report as it comes back,
   before you send the next readers.) Only the entries
   that will be cited need your own eyes, at full resolution.

package/assets/plugins/gates/README.md

@@ -49,6 +49,17 @@ One line of JSON on stdout (the last line) may say more:
 - `reason`: why, for the user (in their language: `STROM_LANG`).
 - `wait` (seconds) or `until` (a time): when to ask again. Without them: in
   15 minutes; never sooner than a minute.
+- `hard` (`true`, with status 1 or 2): this answer is the user's own hard
+  limit — a cap set in `run.gate`. The run ends, saying the reason; no
+  "start anyway" goes past it.
+- `watch` (`{"kind": "seven_day", "finish": 0.99}`): the gate holds a cap on
+  that window of the agent's plan (`five_hour` or `seven_day`). strom then asks
+  it before **every** session, also of the runs you started yourself (there
+  only its hard stop counts), and asks a session at work to finish — write
+  down what it found and close — once the agent says the window's use reached
+  `finish` (0–1). A gate that never says `watch` is asked as before.
+
+Both are optional; an older strom ignores them.
 
 Plain text instead of JSON is the reason.
 
@@ -66,9 +77,13 @@ Environment variables, besides the user's own:
 | `STROM_SESSIONS` | sessions this run has had |
 | `STROM_COST_USD` | what this run has cost so far (as the agent reported it) |
 | `STROM_NEXT_TASK` | the task the next session would take |
+| `STROM_AGENT_LIMITS` | what the agent said of its plan's limits in this run, when it said any (Claude Code): JSON `[{"kind": "five_hour" \| "seven_day", "used": 0.97, "resetsAt": "<ISO time>", "at": "<when it said it>"}]` — absent otherwise; an older gate ignores it |
 
 A session already at work is never stopped by a gate: it is asked between
-sessions only (a session's own time limit is `run.minutes`).
+sessions only (a session's own time limit is `run.minutes`). Under a cap
+(`watch`) the session is asked to finish, as `strom session finish` does: its
+agent hears it from its next strom command and starts no new reader; work it
+delegated inside itself (a subagent) strom cannot stop half-way.
 
 The gate holds the runs that go on by themselves: `strom run --loop` and
 `--until`. Tasks you start yourself (one, `--max 3`, `--task T0007`, "work
@@ -91,5 +106,17 @@ 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.
 
+**A cap** — your own hard stop for the week:
+
+    strom config set run.gate "claude-usage 10 --cap 95"
+
+At 95 % of the week used no session starts: in every run, `--max` and
+`--task` and the menu's too, asked before each session, and no "start anyway"
+goes past it — the run ends saying the use and when the week resets. A session
+at work is asked to finish when Claude Code says the week is at 99 %. What
+Claude Code said in the run (`STROM_AGENT_LIMITS`, at most 15 minutes old) is
+read instead of asking `claude -p /usage`. `--cap` alone: the cap without the
+pace (`claude-usage --cap 95`).
+
 A gate is a program on this computer, put here by you (or by strom); the
 `.gitignore` of the plugins folder keeps it out of any repository.

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).",
+  "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.",
   "command": [
     "node",
     "gate.ts"

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

@@ -11,11 +11,22 @@
 // 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.
 //
+// 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
+// session of every run, and no "start anyway" goes past it; a session at work
+// is asked to finish when the week reaches 99 %. What the agent said of its
+// limits in this run (STROM_AGENT_LIMITS, at most 15 minutes old) is read
+// instead of asking `claude -p /usage`.
+//
 // strom writes this file; a copy of your own goes into a folder of its own name.
 
 import { spawnSync } from "node:child_process";
 
 const DAY = 86_400_000;
+/** What the agent said of its limits counts for this long; older: `claude -p /usage` is asked. */
+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;
 const lang = (process.env.STROM_LANG ?? "en").slice(0, 2);
 
@@ -27,7 +38,11 @@ const T: Record<string, Record<string, string>> = {
     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",
     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}",
     unread: "cannot read `claude -p /usage`: {detail}",
+    noweek: "no line \"Current week … resets …\"",
+    exit: "it ended with exit status {status}",
   },
   cs: {
     other: "agent není Claude Code — není co hlídat",
@@ -36,7 +51,11 @@ const T: Record<string, Record<string, string>> = {
     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",
     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}",
     unread: "nelze přečíst `claude -p /usage`: {detail}",
+    noweek: "chybí řádek „Current week … resets …“",
+    exit: "skončilo s kódem {status}",
   },
   de: {
     other: "der Agent ist nicht Claude Code — nichts zu prüfen",
@@ -45,50 +64,82 @@ const T: Record<string, Record<string, string>> = {
     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",
     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}",
     unread: "`claude -p /usage` nicht lesbar: {detail}",
+    noweek: "keine Zeile „Current week … resets …“",
+    exit: "mit Exit-Status {status} beendet",
   },
 };
 function say(key: string, v: Record<string, string | number> = {}): string {
   const s = (T[lang] ?? T.en!)[key] ?? T.en![key]!;
   return s.replace(/\{(\w+)\}/g, (_, k: string) => String(v[k] ?? ""));
 }
-function answer(code: 0 | 1 | 2, reason: string, until?: Date): never {
-  console.log(JSON.stringify({ reason, ...(until ? { until: until.toISOString() } : {}) }));
+function answer(code: 0 | 1 | 2, reason: string, until?: Date, hard?: boolean): never {
+  // under a cap: strom asks before every session and asks a session at work to finish near the week's end
+  const watch = cap !== undefined ? { kind: "seven_day", finish: FINISH_AT } : undefined;
+  console.log(JSON.stringify({ reason, ...(until ? { until: until.toISOString() } : {}), ...(hard ? { hard: true } : {}), ...(watch ? { watch } : {}) }));
   process.exit(code);
 }
 
-// ── your number: how many points usage must be behind the week gone ─────────
-const arg = process.argv[2] ?? "0";
+// ── your number: how many points usage must be behind the week gone; --cap: the week's hard stop ─
+const argv = process.argv.slice(2);
+let cap: number | undefined;
+let arg = "0";
+for (let i = 0; i < argv.length; i++) {
+  const a = argv[i]!;
+  if (a === "--cap" || a.startsWith("--cap=")) {
+    const v = a === "--cap" ? (argv[++i] ?? "") : a.slice(6);
+    if (!/^\d{1,3}$/.test(v) || Number(v) < 1 || Number(v) > 100) answer(2, say("badcap", { arg: v }));
+    cap = Number(v);
+  } else arg = a;
+}
 const min = Number(arg);
 if (!/^\d{1,2}$/.test(arg)) answer(2, say("bad", { arg }));
 
-if ((process.env.STROM_AGENT ?? "claude") !== "claude") answer(0, say("other"));
+if ((process.env.STROM_AGENT ?? "claude") !== "claude") {
+  cap = undefined; // another agent: no limits of Claude's to hold
+  answer(0, say("other"));
+}
 
-// ── what Claude Code says ───────────────────────────────────────────────────
-const r = spawnSync("claude", ["-p", "/usage"], { encoding: "utf8", timeout: 90_000, shell: process.platform === "win32", windowsHide: true });
-if (r.error || r.status !== 0) answer(2, say("unread", { detail: r.error?.message ?? (r.stderr || r.stdout || `exit ${r.status}`).trim().split("\n")[0] ?? "" }));
-const text = r.stdout;
-if (/API key/i.test(text) && !/Current week/i.test(text)) answer(0, say("api"));
+type Use = { used: number; resets?: Date };
+let session: Use | undefined;
+let week: Use | undefined;
 
-const LINE = /^Current (session|week)(?: \(([^)]+)\))?:\s*(\d+)%\s*used(?:\s*·\s*resets\s*(.+))?$/i;
-let session: { used: number; resets?: Date } | undefined;
-let week: { used: number; resets?: Date } | undefined;
-for (const raw of text.split(/\r?\n/)) {
-  const m = LINE.exec(raw.trim());
-  if (!m) continue;
-  const item = { used: Number(m[3]), ...(m[4] ? { resets: resetAt(m[4]) } : {}) };
-  if (m[1]!.toLowerCase() === "session") session = item;
-  // the limit of all models is the one that stops the work; a model's own week only if there is no other
-  else if (!week || /all models/i.test(m[2] ?? "")) week = item;
+// ── what the agent said in this run, when it is fresh ───────────────────────
+const said = fromAgent(process.env.STROM_AGENT_LIMITS);
+if (said) ({ session, week } = said);
+else {
+  // ── what Claude Code says ─────────────────────────────────────────────────
+  const r = spawnSync("claude", ["-p", "/usage"], { encoding: "utf8", timeout: 90_000, shell: process.platform === "win32", windowsHide: true });
+  // what Claude Code or the system said is said as it is; the gate's own words in the research language (STROM_LANG)
+  if (r.error || r.status !== 0) answer(2, say("unread", { detail: r.error?.message ?? ((r.stderr || r.stdout || "").trim().split("\n")[0] || say("exit", { status: String(r.status) })) }));
+  const text = r.stdout;
+  if (/API key/i.test(text) && !/Current week/i.test(text)) {
+    cap = undefined;
+    answer(0, say("api"));
+  }
+  const LINE = /^Current (session|week)(?: \(([^)]+)\))?:\s*(\d+)%\s*used(?:\s*·\s*resets\s*(.+))?$/i;
+  for (const raw of text.split(/\r?\n/)) {
+    const m = LINE.exec(raw.trim());
+    if (!m) continue;
+    const item = { used: Number(m[3]), ...(m[4] ? { resets: resetAt(m[4]) } : {}) };
+    if (m[1]!.toLowerCase() === "session") session = item;
+    // the limit of all models is the one that stops the work; a model's own week only if there is no other
+    else if (!week || /all models/i.test(m[2] ?? "")) week = item;
+  }
 }
-if (!week?.resets) answer(2, say("unread", { detail: "no line \"Current week … resets …\"" }));
+if (!week?.resets) answer(2, say("unread", { detail: say("noweek") }));
+// the cap first: the user's own hard stop, whatever the pace
+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 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: week.used, gone: Math.floor(gone), behind: Math.floor(behind), min };
+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
@@ -98,6 +149,33 @@ if (behind < min) {
 }
 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
+ * at most FRESH_MS old and not past its reset; else nothing — `claude -p /usage` is asked.
+ */
+function fromAgent(json: string | undefined): { session?: Use; week: Use } | undefined {
+  if (!json) return undefined;
+  let list: unknown;
+  try {
+    list = JSON.parse(json);
+  } catch {
+    return undefined;
+  }
+  if (!Array.isArray(list)) return undefined;
+  const of = (kind: string): Use | undefined => {
+    const l = list.find((x) => x && typeof x === "object" && (x as { kind?: unknown }).kind === kind) as { used?: unknown; resetsAt?: unknown; at?: unknown } | undefined;
+    if (!l || typeof l.used !== "number" || !Number.isFinite(l.used) || typeof l.at !== "string") return undefined;
+    const at = Date.parse(l.at);
+    const resets = typeof l.resetsAt === "string" ? new Date(l.resetsAt) : undefined;
+    if (Number.isNaN(at) || Date.now() - at > FRESH_MS || !resets || Number.isNaN(resets.getTime()) || resets.getTime() <= Date.now()) return undefined;
+    return { used: l.used * 100, resets };
+  };
+  const week = of("seven_day");
+  if (!week) return undefined;
+  const session = of("five_hour");
+  return { week, ...(session ? { session } : {}) };
+}
+
 /** "Sep 30 at 2pm (Europe/Prague)", "Oct 2 at 11:30am (UTC)" → the moment. */
 function resetAt(s: string): Date | undefined {
   const m = /^(\w{3})\w*\s+(\d{1,2})\s+at\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*\(([^)]+)\)/i.exec(s.trim());

package/dist/agents/files.js

@@ -74,9 +74,11 @@ they ask.
   - the agent working on its own: they start it from strom's menu ("Let the
     agent work on its own"); it works the task queue and tells them the result;
     with many tasks in the queue, suggest it — every task gets a fresh session;
-  - one task, one fresh context: after a session closes, 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;
+  - one task, one fresh context — in a conversation: after a session closes
+    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;
   - 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.

package/dist/agents/profiles.js

@@ -12,11 +12,14 @@
 export const TIERS = ["lead", "vision", "text", "cheap"];
 const DELEGATION_RULES = `- Browsing a book, an index or a range of images ("is our surname on this page?")
   is delegated; so is anything self-contained that returns little.
-- About ten scans (images B…:n) per delegate, never more than twelve; it opens
-  as many halves and crops of them as reading needs, but tell it to stop at
-  about 80 views and return what it has: every view stays in its context to
-  the end. It asks for the views of a scan (or of a few) in one call —
+- About six scans (images B…:n) per delegate, four views each (halves and
+  crops); tell it to write down what each call gave before the next, to stop
+  at about 30 views and return what it has, and never to open again a view
+  cleared from its context (its notes hold it). It asks for the
+  views of a scan (or of a few) in one call —
   \`strom media view B0001:57-60 --half both\` — and opens them together.
+- Fetch the images before you delegate: a delegate never fetches, nor waits
+  for an archive — it reports the images missing or too small, and you fetch them.
 - Every delegate gets the full question (what counts as a find, which years,
   which names) and returns for each image: image and page, find or nothing,
   what was illegible, the hand, and certainty per name — written as it goes.
@@ -28,11 +31,12 @@ export const SELF_READING = `## Reading scans (Codex, Antigravity, OpenCode, Gro
 
 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 at most ten: open a batch (one call gives its views —
-\`strom media view B0001:57-66 --half both\` — open them together), write
+in batches of about six: open a batch (one call gives its views —
+\`strom media view B0001:57-62 --half both\` — open them together), write
 down what it gave (strom search add … for what was not found, facts for what
-was), then open the next. Every image and view stays in your context to the end: after about 80
-views, write down what you found and go on. A name or place the next search depends on:
+was), then open the next. After about 30 views, write down what you found
+and go on; a view cleared from your context is not opened again — your
+notes hold it. A name or place the next search depends on:
 read it again on a crop at full resolution (\`strom media view … --crop\`)
 before you record it.
 OpenCode: this tree's subagent strom-scan-reader (strom and the file reader