strom-research 1.25.1-beta.1 → 1.25.2

package/CHANGELOG.cs.md

@@ -5,9 +5,37 @@
 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.25.2
+
+*3. 11. 2026 · patří k aplikaci Strom 3.21.2.*
+
+- **Brána týdne předplatného už neukončí běh kvůli jedné nepřečtené odpovědi.** Zeptá se znovu, pak čtvrt hodiny počká
+  a řekne, co dostala. Nepřihlášený agent se ohlásí už před prvním sezením i s postupem přihlášení; výchozí složka
+  agenta zadaná v prostředí se vynechá, takže agent zůstane u svého obvyklého přihlášení.
+- **Ztotožnění míst: kontrola zapíše, co zjistí, do záznamu místa.** Staré názvy a pravopisy, jiné tvary místa
+  v údajích a chybná fara (odebraná i s důvodem) se zapíší do záznamu i tam, kde souřadnice zadala osoba, nikdy jen
+  do dějin. Tvar blízko místa, které záznam už má, se odmítne a řekne se, jak ho k tomu záznamu přidat; dva záznamy
+  jednoho místa jde sloučit. Na prvním místě je dnešní název (místo dnes v Polsku polsky, německý název jako
+  historický). Otázka u místa nikdy nebere osobě její souřadnice. Už ztotožněná místa se jednou samy srovnají (názvy
+  zapsané i s jazykem a roky jako text, dnešní název první, souřadnice osoby, staré názvy jen v dějinách) a krok jde
+  vrátit. Souhrn sezení o místech začíná tím, co se udělalo – ztotožněno, ověřeno, s otázkou, nedohledáno – a jedno
+  sezení vezme víc míst sousedních oblastí. Z „v Lhotě v čp. 12“ už nezůstane místo „v Lhotě v“:
+  místem je obec, jak ji výzkum píše jinde, i když ji věta skloňuje. Každý název se do záznamu místa zapíše jen jednou.
+- **Fronta míst se po vyřízení míst vyprázdní.** Místo ztotožněné, ověřené, předané k otázce nebo nedohledané odejde z
+  fronty se všemi svými tvary, i s tím, který fakta mezitím píší jinak; místa, která sezení už udělalo, se znovu neberou
+  a počet čekajících sedí. Co ve frontě nechala dřívější verze, se odebere samo (jen vyřízená místa, krok jde vrátit);
+  kontrola vyžádaná u místa, které čeká na ztotožnění, zůstane jako kontrola, a kontrola čekající u tvaru, který fakta
+  nově píší jako jiné místo, přejde s nimi k tomu místu. Každý krok nad místy jde vrátit vlastním
+  číslem, i když čeká jiný (také odpovědi člověka). Chybné jméno v záznamu místa — překlep ze záznamu, který už žádný
+  fakt nepíše, jméno jiného místa — jde odebrat i s důvodem (`strom place names L… --drop`); sezení nad místy vidí další
+  jména záznamu s jazykem a roky; kontrola může uvést, o jaký zdroj se opřela; příslušnost jde zadat i k jednomu roku.
+- V rozporech úpravy z aplikace už číslo domu, které značku má, nedostane značku podruhé (polsky „nr domu nr domu 12“),
+  a pomlčka v titulku je podle jazyka výzkumu.
+- Plán toho, co agent udělá dál, už nespadne na čekajícím vyprávění o manželích: jmenuje oba manžele.
+
 ## 1.25.1
 
-*Připravuje se: bety do 1.25.1-beta.1. Oddíl bude úplný s vydáním.*
+*3. 11. 2026 · patří k aplikaci Strom 3.21.1.*
 
 - **Podmínky archivů ověřené znovu, přibyly polské zdroje.** Podmínky a robots.txt všech archivů, které strom zná,
   byly 3. listopadu 2026 přečteny znovu. eBadatelna SOA Praha nově nepouští k digitalizátům žádné roboty (její

package/CHANGELOG.de.md

@@ -5,9 +5,46 @@
 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.25.2
+
+*3.11.2026 · gehört zur Strom-App 3.21.2.*
+
+- **Das Tor der Abo-Woche beendet einen Lauf nicht mehr wegen einer unlesbaren Antwort.** Es fragt erneut, wartet dann
+  eine Viertelstunde und nennt, was es erhielt. Ein nicht angemeldeter Agent wird schon vor der ersten Sitzung gemeldet,
+  mit dem Weg zur Anmeldung; der in der Umgebung genannte Standardordner des Agenten wird weggelassen, so bleibt der
+  Agent bei seiner üblichen Anmeldung.
+- **Orte zuordnen: eine Prüfung schreibt, was sie findet, in den Datensatz des Ortes.** Alte Namen und Schreibweisen,
+  andere Formen des Ortes in den Angaben und eine falsche Pfarrei (mit Grund entfernt) kommen in den Datensatz, auch
+  wo die Koordinaten von der Person stammen, nie nur in die Geschichte. Eine Form nahe einem Ort, der schon einen
+  Datensatz hat, wird abgelehnt, mit dem Weg, sie diesem Datensatz hinzuzufügen; zwei Datensätze eines Ortes lassen sich
+  zusammenführen. Der heutige Name steht vorn (ein Ort heute in Polen polnisch, der deutsche Name als historischer).
+  Eine Frage zu einem Ort nimmt der Person nie ihre Koordinaten. Schon zugeordnete Orte werden einmal von selbst
+  berichtigt (Namen mit Sprache und Jahren als Text, der heutige Name vorn, die Koordinaten der Person, alte Namen nur
+  in der Geschichte), und der Schritt lässt sich zurücknehmen. Die Zusammenfassung einer Sitzung zu Orten beginnt mit
+  dem, was getan wurde – zugeordnet, bestätigt, mit Frage, nicht gefunden –, und eine Sitzung nimmt mehr Orte
+  benachbarter Gebiete. Aus „in Lhota in Nr. 12“ bleibt kein Ort „in Lhota in“ mehr:
+  Ort ist die Gemeinde, wie die Forschung sie sonst schreibt, auch wenn der Satz sie beugt. Jeder Name steht nur einmal
+  im Eintrag eines Ortes.
+- **Die Warteschlange der Orte leert sich, wenn die Orte erledigt sind.** Ein Ort, der bestimmt, geprüft, erfragt oder
+  nicht gefunden wurde, verlässt die Warteschlange mit allen seinen Formen, auch mit einer, die die Fakten inzwischen
+  anders schreiben; Orte, die eine Sitzung schon erledigt hat, werden nicht erneut genommen, und die Zahl des Wartenden
+  stimmt. Was eine frühere Version in der Warteschlange ließ, wird von selbst entfernt (nur erledigte Orte, der Schritt
+  lässt sich rückgängig machen); eine Prüfung, die für einen Ort verlangt wird, der auf die Bestimmung wartet, bleibt
+  als Prüfung, und eine Prüfung, die bei einer Form wartet, die die Fakten jetzt als anderen Ort schreiben, geht mit
+  ihnen zu diesem Ort. Jeder Schritt bei den Orten lässt sich mit seiner eigenen Nummer rückgängig machen, auch wenn ein anderer
+  wartet (auch die Antworten der Person). Ein falscher Name im Datensatz eines Ortes — ein Versehen eines Eintrags, das
+  kein Faktum mehr schreibt, der Name eines anderen Ortes — lässt sich mit Begründung entfernen (`strom place names L…
+  --drop`); die Sitzung über die Orte sieht die weiteren Namen des Datensatzes mit Sprache und Jahren; eine Prüfung kann
+  die Quelle nennen, auf die sie sich stützt; eine Zugehörigkeit lässt sich auch für ein einzelnes Jahr angeben.
+- In den Widersprüchen einer Änderung aus der App bekommt eine Hausnummer, die ihre Bezeichnung schon trägt, sie nicht
+  ein zweites Mal (polnisch „nr domu nr domu 12“), und der Gedankenstrich im Titel richtet sich nach der Sprache der
+  Forschung.
+- Der Plan dessen, was der Agent als Nächstes tut, bricht bei einer wartenden Geschichte eines Paares nicht mehr ab:
+  er nennt beide Partner.
+
 ## 1.25.1
 
-*In Vorbereitung: die Betas bis 1.25.1-beta.1. Der Abschnitt ist mit dem Release vollständig.*
+*3.11.2026 · gehört zur Strom-App 3.21.1.*
 
 - **Die Bedingungen der Archive erneut geprüft, polnische Quellen dazu.** Bedingungen und robots.txt jedes Archivs,
   das strom kennt, wurden am 3. November 2026 neu gelesen. Die eBadatelna des SOA Praha lässt jetzt keinen Roboter

package/CHANGELOG.md

@@ -5,9 +5,39 @@ English · [Čeština](CHANGELOG.cs.md) · [Deutsch](CHANGELOG.de.md) · [Polski
 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.25.2
+
+*2026-11-03 · goes with the Strom app 3.21.2.*
+
+- **The gate of the subscription's week no longer ends a run over one answer it cannot read.** It asks again, then
+  waits a quarter of an hour and says what it got. An agent not logged in is said before the first session, with how to
+  log in; the agent's default folder named in the environment is left out, so the agent keeps its usual login.
+- **Identifying places: a check writes what it finds into the place's record.** Old names and spellings, the facts'
+  other forms of the place and a wrong parish (taken off with the reason) go into the record also where the coordinates
+  are the person's, never only into the history. A form close to a place with a record already is refused with the way
+  to add it to that record; two records of one place can be merged. Today's name comes first (a place now in Poland
+  under its Polish name, the German one as historical). A question on a place never takes the person's coordinates
+  away from them. The places identified before are set right once by themselves (names written with their language
+  and years as text, today's name first, the person's coordinates, old names kept only in the history), and the step
+  can be undone. A session on the places begins its summary with what it did — identified, verified, asked, not
+  located — and takes more places of neighbouring areas at once. "in Lhota in no. 12" no longer leaves "in Lhota in" as
+  a place: the place is the municipality as the research writes it elsewhere, also where the sentence declined it. Each
+  name goes into a place's record once.
+- **The queue of places empties as the places are done.** A place identified, checked, asked about or not located leaves
+  the queue with every form of it, also one the facts write otherwise since; the places a session already did are no
+  longer taken again, and the count of what waits is right. What an earlier version left in the queue is taken out by
+  itself (only places dealt with, the step can be undone); a check asked of a place waiting to be identified is kept as
+  the check, and a check waiting for a form the facts now write as another place goes with them to that place. Each step on places is undone by its own number, also while another waits (the person's answers among
+  them). A wrong name of a place's record — a slip of a record no fact writes any more, another place's name — can be
+  taken off with the reason (`strom place names L… --drop`); the session on the places sees the record's other names
+  with their language and years; a check can name the reference it stood on; a jurisdiction can be given for one year.
+- In the conflicts of an edit from the app a house that says it is one already no longer gets its marker twice ("nr domu nr
+  domu 12" in Polish), and the title's dash is the one of the research's language.
+- The plan of what the agent does next no longer fails on a couple's story waiting: it names the two partners.
+
 ## 1.25.1
 
-*In preparation: the betas up to 1.25.1-beta.1. The section is complete with the release.*
+*2026-11-03 · goes with the Strom app 3.21.1.*
 
 - **The archives' terms checked again, Polish sources added.** The terms and robots.txt of every archive strom knows
   were read again on 3 November 2026. SOA Praha's eBadatelna now keeps every robot off its scans (its robots.txt of

package/CHANGELOG.pl.md

@@ -5,9 +5,41 @@
 Zmiany każdej wersji w skrócie. Pełne informacje o wydaniach i polecenia instalacji są na
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (po angielsku).
 
+## 1.25.2
+
+*3.11.2026 · współpracuje z aplikacją Strom 3.21.2.*
+
+- **Warunek tygodnia subskrypcji nie kończy już przebiegu z powodu jednej nieodczytanej odpowiedzi.** Pyta ponownie,
+  potem czeka kwadrans i podaje, co otrzymał. Niezalogowany agent jest zgłaszany już przed pierwszą sesją, ze sposobem
+  logowania; domyślny folder agenta podany w środowisku jest pomijany, więc agent zostaje przy swoim zwykłym logowaniu.
+- **Identyfikacja miejsc: sprawdzenie zapisuje to, co ustali, w rekordzie miejsca.** Dawne nazwy i pisownie, inne formy
+  miejsca w danych i błędna parafia (usunięta wraz z powodem) trafiają do rekordu także tam, gdzie współrzędne podała
+  osoba, nigdy tylko do historii. Forma blisko miejsca, które ma już rekord, zostaje odrzucona ze wskazaniem, jak ją
+  do tego rekordu dodać; dwa rekordy jednego miejsca można scalić. Na pierwszym miejscu jest dzisiejsza nazwa
+  (miejscowość dziś w Polsce po polsku, niemiecka nazwa jako historyczna). Pytanie o miejsce nigdy nie odbiera osobie
+  jej współrzędnych. Miejsca już zidentyfikowane zostają raz same poprawione (nazwy zapisane z językiem i latami jako
+  tekst, dzisiejsza nazwa pierwsza, współrzędne osoby, dawne nazwy tylko w historii), a krok można cofnąć.
+  Podsumowanie sesji o miejscach zaczyna się od tego, co zrobiono – zidentyfikowano, potwierdzono, z pytaniem, nie
+  odnaleziono – a jedna sesja bierze więcej miejsc z sąsiednich obszarów. Z „w Lhocie w nr 12” nie zostaje już
+  miejsce „w Lhocie w”: miejscem jest miejscowość tak, jak badanie zapisuje ją gdzie indziej, także gdy zdanie ją
+  odmienia. Każda nazwa trafia do rekordu miejsca tylko raz.
+- **Kolejka miejsc opróżnia się, gdy miejsca są załatwione.** Miejsce zidentyfikowane, sprawdzone, przekazane jako
+  pytanie albo nieustalone opuszcza kolejkę ze wszystkimi swoimi formami, także z tą, którą fakty zapisują teraz
+  inaczej; miejsca, które sesja już zrobiła, nie są brane ponownie, a liczba oczekujących się zgadza. To, co w kolejce
+  zostawiła wcześniejsza wersja, usuwa się samo (tylko załatwione miejsca, krok można cofnąć); sprawdzenie zlecone dla
+  miejsca czekającego na identyfikację zostaje jako sprawdzenie, a sprawdzenie czekające przy formie, którą fakty
+  zapisują teraz jako inne miejsce, przechodzi z nimi do tego miejsca. Każdy krok przy miejscach można cofnąć jego własnym
+  numerem, także gdy czeka inny (również odpowiedzi osoby). Błędną nazwę w rekordzie miejsca — pomyłkę z zapisu, której
+  żaden fakt już nie zapisuje, nazwę innego miejsca — można usunąć z uzasadnieniem (`strom place names L… --drop`);
+  sesja nad miejscami widzi pozostałe nazwy rekordu z językiem i latami; sprawdzenie może podać źródło, na którym się
+  oparło; przynależność można podać także dla jednego roku.
+- W sprzecznościach zmian z aplikacji numer domu, który ma już oznaczenie, nie dostaje go po raz drugi („nr domu nr
+  domu 12”), a myślnik w tytule zależy od języka badania.
+- Plan tego, co agent zrobi dalej, nie przerywa się już na oczekującej opowieści o parze: podaje oboje partnerów.
+
 ## 1.25.1
 
-*W przygotowaniu: bety do 1.25.1-beta.1. Sekcja będzie kompletna z wydaniem.*
+*3.11.2026 · współpracuje z aplikacją Strom 3.21.1.*
 
 - **Warunki archiwów sprawdzone ponownie, doszły źródła polskie.** Warunki i robots.txt każdego archiwum, które zna
   strom, zostały 3 listopada 2026 przeczytane na nowo. eBadatelna SOA Praha nie wpuszcza już żadnych robotów do swoich

package/assets/lang/cs.json

@@ -809,6 +809,12 @@
   "places.identify.why": "Osoba o to požádala: která obec toho jména to je, kde leží, její názvy a příslušnost – pro mapu, dějiny a domy.",
   "places.identify.done": "Každé místo fronty ztotožněné, s otázkou, nebo nedohledané.",
   "places.identify.result": "každé místo fronty ztotožněné, s otázkou, nebo nedohledané",
+  "places.count.identified": "ztotožněno {n}",
+  "places.count.verified": "ověřeno {n} (už ztotožněná, zkontrolováno)",
+  "places.count.undecided": "zkontrolováno, nerozhodnuto {n}",
+  "places.count.asked": "s otázkou {n}",
+  "places.count.unlocated": "nedohledáno {n}",
+  "places.count.merged": "sloučeno {n}",
   "history.region.what": "Události dějin v regionu {region}: války, epidemie, sčítání lidu, změny státu, vystěhovalectví",
   "history.region.where": "encyklopedie, státní instituce, archivy, Wikipedie v jazyce regionu s jejími odkazy",
   "history.region.why": "co předkové zažili, ukázané u jejich životů",
@@ -2628,6 +2634,7 @@
   "ui.conflict.titleAfter": "titul za jménem",
   "ui.conflict.parents": "rodiče",
   "ui.conflict.removed": "ve stromu",
+  "ui.conflict.title": "{who}: {what} – {ours} × {theirs}",
   "ui.conflict.removed.ours": "odebrání v aplikaci Strom ({day}, {sync})",
   "ui.conflict.removed.theirs": "úpravy v jiné kopii aplikace",
   "ui.conflict.removing.ours": "pozdější úpravy v jiné kopii aplikace",

package/assets/lang/de.json

@@ -809,6 +809,12 @@
   "places.identify.why": "Die Person hat darum gebeten: welcher Ort des Namens es ist, wo er liegt, seine Namen und Zugehörigkeiten – für die Karte, die Geschichte und die Häuser.",
   "places.identify.done": "Jeder Ort der Warteschlange bestimmt, als Frage gestellt oder als nicht auffindbar vermerkt.",
   "places.identify.result": "jeder Ort der Warteschlange bestimmt, als Frage gestellt oder als nicht auffindbar vermerkt",
+  "places.count.identified": "zugeordnet {n}",
+  "places.count.verified": "bestätigt {n} (schon zugeordnet, geprüft)",
+  "places.count.undecided": "geprüft, nicht entschieden {n}",
+  "places.count.asked": "mit Frage {n}",
+  "places.count.unlocated": "nicht gefunden {n}",
+  "places.count.merged": "zusammengeführt {n}",
   "history.region.what": "Ereignisse der Geschichte in {region}: Kriege, Epidemien, Volkszählungen, Wechsel des Staates, Auswanderung",
   "history.region.where": "Enzyklopädien, staatliche Institutionen, Archive, die Wikipedia in der Sprache der Region mit ihren Belegen",
   "history.region.why": "was die Vorfahren erlebten, bei ihren Lebensläufen gezeigt",
@@ -2628,6 +2634,7 @@
   "ui.conflict.titleAfter": "Titel nach dem Namen",
   "ui.conflict.parents": "Eltern",
   "ui.conflict.removed": "im Stammbaum",
+  "ui.conflict.title": "{who}: {what} – {ours} × {theirs}",
   "ui.conflict.removed.ours": "in der Strom-App entfernt ({day}, {sync})",
   "ui.conflict.removed.theirs": "in einer anderen Kopie der App bearbeitet",
   "ui.conflict.removing.ours": "später in einer anderen Kopie der App bearbeitet",

package/assets/lang/pl.json

@@ -809,6 +809,12 @@
   "places.identify.why": "Osoba o to poprosiła: która miejscowość o tej nazwie to jest, gdzie leży, jej nazwy i przynależność administracyjna – dla mapy, historii i domów.",
   "places.identify.done": "Każde miejsce z kolejki zidentyfikowane, z pytaniem albo nieodnalezione.",
   "places.identify.result": "każde miejsce z kolejki zidentyfikowane, z pytaniem albo nieodnalezione",
+  "places.count.identified": "zidentyfikowano {n}",
+  "places.count.verified": "potwierdzono {n} (już zidentyfikowane, sprawdzone)",
+  "places.count.undecided": "sprawdzono, nierozstrzygnięte {n}",
+  "places.count.asked": "z pytaniem {n}",
+  "places.count.unlocated": "nie odnaleziono {n}",
+  "places.count.merged": "scalono {n}",
   "history.region.what": "Wydarzenia historyczne w regionie {region}: wojny, epidemie, spisy ludności, zmiany państwa, emigracja",
   "history.region.where": "encyklopedie, instytucje państwowe, archiwa, Wikipedia w języku regionu wraz z jej przypisami",
   "history.region.why": "co przeżyli przodkowie, pokazane przy ich życiorysach",
@@ -2628,6 +2634,7 @@
   "ui.conflict.titleAfter": "tytuł po nazwisku",
   "ui.conflict.parents": "rodzice",
   "ui.conflict.removed": "w drzewie",
+  "ui.conflict.title": "{who}: {what} – {ours} × {theirs}",
   "ui.conflict.removed.ours": "usunięcie w aplikacji Strom ({day}, {sync})",
   "ui.conflict.removed.theirs": "zmiany w innej kopii aplikacji",
   "ui.conflict.removing.ours": "późniejsze zmiany w innej kopii aplikacji",

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

@@ -6,5 +6,5 @@
     "node",
     "gate.ts"
   ],
-  "timeout": 120
+  "timeout": 660
 }

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

@@ -35,6 +35,13 @@
 // limits in this run (STROM_AGENT_LIMITS, at most 15 minutes old) is read
 // instead of asking `claude -p /usage`.
 //
+// What `claude -p /usage` says is not always read: an answer without the
+// week's line, an exit status, no answer in time. It asks again (ATTEMPTS, a
+// pause between), and then waits a while (UNREAD_WAIT) rather than stopping
+// the run for good — what it got is in its reason (the first line, shortened).
+// A Claude Code not logged in (`claude auth status`; its /usage is then a bare
+// /cost) stops the run, saying how to log in.
+//
 // strom writes this file; a copy of your own goes into a folder of its own name.
 
 import fs from "node:fs";
@@ -65,6 +72,18 @@ const RESERVE = 2;
 /** The week it waits in for the reserve, in the gate's own folder — only when strom asks it (STROM_GATE). */
 const HOLD = process.env.STROM_GATE ? "hold.json" : undefined;
 const lang = (process.env.STROM_LANG ?? "en").slice(0, 2);
+/**
+ * How many times `claude -p /usage` is asked before the gate waits; each asking may take ASK_MS — it reads the
+ * computer's own sessions for its advice too, which took over a minute on a busy computer (2026-11-03: 75 s).
+ */
+const ATTEMPTS = 3;
+const ASK_MS = 180_000;
+/** The pause between two askings (tests give a shorter one: CLAUDE_USAGE_RETRY_MS). */
+const RETRY_MS = /^\d+$/.test(process.env.CLAUDE_USAGE_RETRY_MS ?? "") ? Number(process.env.CLAUDE_USAGE_RETRY_MS) : 30_000;
+/** All the askings within this, inside the gate's timeout (gate.json: 660 s). */
+const BUDGET_MS = 600_000;
+/** Unread after every asking: asked again this much later — a run is not stopped for one answer it could not read. */
+const UNREAD_WAIT = 15 * 60_000;
 
 const T: Record<string, Record<string, string>> = {
   en: {
@@ -84,8 +103,15 @@ const T: Record<string, Record<string, string>> = {
     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}",
+    unreadWait: "cannot read `claude -p /usage` ({tries}×): {detail} — asked again in {min} minutes",
     noweek: "no line \"Current week … resets …\"",
+    said: "{detail}; it said: \"{line}\"",
+    nothing: "{detail}; it said nothing",
+    unused: "week 0 % used — nothing used yet",
     exit: "it ended with exit status {status}",
+    timeout: "no answer in {s} s",
+    login: "Claude Code is not logged in — to log in once: claude, then /login",
+    loginDir: "Claude Code is not logged in with CLAUDE_CONFIG_DIR={dir} — to log in once with the same variable (CLAUDE_CONFIG_DIR={dir} claude, then /login), or to start strom without it",
   },
   cs: {
     other: "agent není Claude Code — není co hlídat",
@@ -104,8 +130,15 @@ const T: Record<string, Record<string, string>> = {
     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}",
+    unreadWait: "nelze přečíst `claude -p /usage` ({tries}×): {detail} — znovu za {min} minut",
     noweek: "chybí řádek „Current week … resets …“",
+    said: "{detail}; vypsalo: „{line}“",
+    nothing: "{detail}; nevypsalo nic",
+    unused: "týden: využito 0 % — zatím nic",
     exit: "skončilo s kódem {status}",
+    timeout: "bez odpovědi do {s} s",
+    login: "Claude Code není přihlášený — přihlásit jednou: claude, pak /login",
+    loginDir: "Claude Code není přihlášený s CLAUDE_CONFIG_DIR={dir} — přihlásit jednou se stejnou proměnnou (CLAUDE_CONFIG_DIR={dir} claude, pak /login), nebo spustit strom bez ní",
   },
   de: {
     other: "der Agent ist nicht Claude Code — nichts zu prüfen",
@@ -124,8 +157,42 @@ const T: Record<string, Record<string, string>> = {
     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}",
+    unreadWait: "`claude -p /usage` nicht lesbar ({tries}×): {detail} — erneut in {min} Minuten",
     noweek: "keine Zeile „Current week … resets …“",
+    said: "{detail}; Ausgabe: „{line}“",
+    nothing: "{detail}; keine Ausgabe",
+    unused: "Woche: 0 % genutzt — noch nichts",
     exit: "mit Exit-Status {status} beendet",
+    timeout: "keine Antwort in {s} s",
+    login: "Claude Code ist nicht angemeldet — einmal anmelden: claude, dann /login",
+    loginDir: "Claude Code ist mit CLAUDE_CONFIG_DIR={dir} nicht angemeldet — einmal mit derselben Variable anmelden (CLAUDE_CONFIG_DIR={dir} claude, dann /login) oder strom ohne sie starten",
+  },
+  pl: {
+    other: "agent to nie Claude Code — nie ma czego pilnować",
+    api: "Claude Code działa na kluczu API, nie w subskrypcji — bez limitów planu",
+    head: "tydzień: wykorzystano {used} %, upłynęło {gone} %, zapas {behind} (potrzeba co najmniej {min}{early})",
+    early: " – na początku tygodnia połowa tego, co upłynęło",
+    resetIn: "; tydzień odnowi się za {reset}",
+    hold: " — czeka na zapas {target}, potem kilka sesji z rzędu; tydzień odnowi się za {reset}",
+    last: " — do ostatnich {window} przed odnowieniem tygodnia za {reset}",
+    reset: " — do odnowienia tygodnia za {reset}",
+    end: "tydzień: wykorzystano {used} %, odnowi się za {reset} — pozostałe {room} % wystarczy na sesję",
+    session: "sesja wyczerpana — do jej odnowienia; tydzień odnowi się za {reset}",
+    hours: "{n} godz.",
+    days: "{n} dni",
+    bad: "liczba musi wynosić od 0 do 99, nie \"{arg}\"",
+    badcap: "limit musi wynosić od 1 do 100 (\"--cap 95\"), nie \"{arg}\"",
+    cap: "tydzień: wykorzystano {used} % – osiągnięto limit {cap} %; odnowi się {resets}",
+    unread: "nie można odczytać `claude -p /usage`: {detail}",
+    unreadWait: "nie można odczytać `claude -p /usage` ({tries}×): {detail} — ponownie za {min} minut",
+    noweek: "brak wiersza „Current week … resets …”",
+    said: "{detail}; wypisało: „{line}”",
+    nothing: "{detail}; nic nie wypisało",
+    unused: "tydzień: wykorzystano 0 % — jeszcze nic",
+    exit: "zakończyło się kodem {status}",
+    timeout: "brak odpowiedzi w ciągu {s} s",
+    login: "Claude Code nie jest zalogowany — zalogować się raz: claude, potem /login",
+    loginDir: "Claude Code nie jest zalogowany z CLAUDE_CONFIG_DIR={dir} — zalogować się raz z tą samą zmienną (CLAUDE_CONFIG_DIR={dir} claude, potem /login) albo uruchomić strom bez niej",
   },
 };
 function say(key: string, v: Record<string, string | number> = {}): string {
@@ -167,26 +234,39 @@ let week: Use | undefined;
 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;
+  // ── what Claude Code says: asked again when it cannot be read, then a wait — never a stop for one answer ─────
+  const began = Date.now();
+  let detail = "";
+  let tries = 0;
+  for (;;) {
+    tries++;
+    const read = askUsage(Math.min(ASK_MS, BUDGET_MS - (Date.now() - began)));
+    if ("api" in read) {
+      cap = undefined;
+      answer(0, say("api"));
+    }
+    if ("week" in read) {
+      ({ session, week } = read);
+      break;
+    }
+    detail = read.detail;
+    // not logged in (its /usage a bare /cost): no asking again makes it read — said with how to log in
+    if (tries === 1 && loggedIn() === false) {
+      cap = undefined;
+      const dir = process.env.CLAUDE_CONFIG_DIR?.trim();
+      answer(2, dir ? say("loginDir", { dir }) : say("login"));
+    }
+    if (tries >= ATTEMPTS || BUDGET_MS - (Date.now() - began) < RETRY_MS + ASK_MS / 2) break;
+    sleep(RETRY_MS);
   }
+  if (!week) answer(1, say("unreadWait", { tries, detail, min: UNREAD_WAIT / 60_000 }), new Date(Date.now() + UNREAD_WAIT));
+}
+if (!week) answer(2, say("unread", { detail: say("noweek") }));
+// the week's line without its reset: nothing used yet goes (a new week), else what it says is not read
+if (!week.resets) {
+  if (week.used === 0) answer(0, say("unused"));
+  answer(1, say("unreadWait", { tries: 1, detail: say("noweek"), min: UNREAD_WAIT / 60_000 }), new Date(Date.now() + UNREAD_WAIT));
 }
-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);
@@ -231,6 +311,59 @@ const tail =
   at === caught ? say("hold", { reset, target: Math.ceil(need + reserve) }) : 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)));
 
+/**
+ * `claude -p /usage` once: the session's and the week's use, an API key's answer, or why it was not read — with the
+ * first line it said (shortened, no e-mail address), so the gate's log says what Claude Code answered.
+ */
+function askUsage(timeout: number): { session?: Use; week: Use } | { api: true } | { detail: string } {
+  const r = spawnSync("claude", ["-p", "/usage"], { encoding: "utf8", timeout: Math.max(5_000, timeout), shell: process.platform === "win32", windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+  // what Claude Code or the system said is said as it is; the gate's own words in the research language (STROM_LANG)
+  const out = `${r.stdout ?? ""}\n${r.stderr ?? ""}`;
+  const line = firstLine(r.status === 0 ? (r.stdout ?? "") : out);
+  const why = (detail: string) => ({ detail: line ? say("said", { detail, line }) : say("nothing", { detail }) });
+  if (r.error) return (r.error as NodeJS.ErrnoException).code === "ETIMEDOUT" ? why(say("timeout", { s: Math.round(timeout / 1000) })) : { detail: r.error.message };
+  if (r.status !== 0) return why(say("exit", { status: String(r.status) }));
+  const text = r.stdout ?? "";
+  if (/API key/i.test(text) && !/Current week/i.test(text)) return { api: true };
+  let session: Use | undefined;
+  let week: Use | undefined;
+  const LINE = /^Current (session|week)(?: \(([^)]+)\))?:\s*(\d+(?:\.\d+)?)\s*%\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 at = m[4] ? resetAt(m[4]) : undefined;
+    const item = { used: Number(m[3]), ...(at ? { resets: at } : {}) };
+    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 || (!week.resets && week.used !== 0)) return why(say("noweek"));
+  return { week, ...(session ? { session } : {}) };
+}
+
+/** The first line said that is not empty, shortened, without an e-mail address (an account's name stays out of the log). */
+function firstLine(text: string): string {
+  const line = text.split(/\r?\n/).map((l) => l.trim()).find(Boolean) ?? "";
+  const clean = line.replace(/[\p{L}\p{N}._%+-]+@[\p{L}\p{N}.-]+/gu, "…@…");
+  return clean.length > 80 ? `${clean.slice(0, 79)}…` : clean;
+}
+
+/** `claude auth status` says whether it is logged in; undefined when it cannot tell (an older Claude Code). */
+function loggedIn(): boolean | undefined {
+  try {
+    const r = spawnSync("claude", ["auth", "status"], { encoding: "utf8", timeout: 20_000, shell: process.platform === "win32", windowsHide: true, stdio: ["ignore", "pipe", "ignore"] });
+    const said = JSON.parse((r.stdout ?? "").trim()) as { loggedIn?: unknown };
+    return typeof said?.loggedIn === "boolean" ? said.loggedIn : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Waits here (the gate is one short program: nothing else to do meanwhile). */
+function sleep(ms: number): void {
+  if (ms > 0) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
 /** It waits for the reserve in this week (the week it remembers ends within a day of this one's reset). */
 function holding(resets: number): boolean {
   if (!HOLD) return false;
@@ -287,16 +420,33 @@ function fromAgent(json: string | undefined): { session?: Use; week: Use } | und
   return { week, ...(session ? { session } : {}) };
 }
 
-/** "Sep 30 at 2pm (Europe/Prague)", "Oct 2 at 11:30am (UTC)" → the moment. */
+/**
+ * "Sep 30 at 2pm (Europe/Prague)", "Oct 2 at 11:30am (UTC)", "Nov 4 at 13:00 (Europe/Prague)", "Nov 4, 1pm (UTC)" → the
+ * moment; a time alone ("6pm (Europe/Prague)", a session's) → its next coming.
+ */
 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());
+  const m = /^(?:([A-Za-z]{3})[A-Za-z]*\.?\s+(\d{1,2})(?:\s+at|,)?\s+)?(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*([ap]\.?m\.?)?\s*\(([^)]+)\)/i.exec(s.trim());
   if (!m) return undefined;
-  const month = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"].indexOf(m[1]!.toLowerCase());
-  if (month < 0) return undefined;
-  const hour = (Number(m[3]) % 12) + (m[5]!.toLowerCase() === "pm" ? 12 : 0);
+  const ampm = m[5]?.replace(/\./g, "").toLowerCase();
+  const h = Number(m[3]);
+  if (ampm ? h < 1 || h > 12 : h > 23) return undefined;
+  const hour = ampm ? (h % 12) + (ampm === "pm" ? 12 : 0) : h;
+  const minute = Number(m[4] ?? 0);
   const zone = m[6]!;
+  if (!m[1]) {
+    // a time alone: today's in the zone, else tomorrow's
+    const [y, mo, d] = new Intl.DateTimeFormat("en-CA", { timeZone: zone, year: "numeric", month: "2-digit", day: "2-digit" }).format(new Date()).split("-").map(Number) as [number, number, number];
+    for (const add of [0, 1]) {
+      const guess = Date.UTC(y, mo - 1, d + add, hour, minute);
+      const at = guess - offsetMs(guess, zone);
+      if (at > Date.now()) return new Date(at);
+    }
+    return undefined;
+  }
+  const month = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"].indexOf(m[1].toLowerCase());
+  if (month < 0) return undefined;
   for (const year of [new Date().getUTCFullYear(), new Date().getUTCFullYear() + 1]) {
-    const guess = Date.UTC(year, month, Number(m[2]), hour, Number(m[4] ?? 0));
+    const guess = Date.UTC(year, month, Number(m[2]), hour, minute);
     const at = guess - offsetMs(guess, zone);
     if (at > Date.now() - DAY) return new Date(at);
   }