strom-research 1.22.0-beta.2 → 1.22.0-beta.3

package/CHANGELOG.cs.md

@@ -7,13 +7,25 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 
 ## 1.22.0
 
-*Připravuje se: bety do 1.22.0-beta.2. Oddíl bude úplný s vydáním.*
+*Připravuje se: bety do 1.22.0-beta.3. Oddíl bude úplný s vydáním.*
 
 - **Jméno jednou v tom, co čeká.** Úkol k materiálu poslanému z aplikace Strom jmenoval ve widgetu a na stránce
   telefonu každého člověka dvakrát (podruhé v hranatých závorkách) a jeho text bez jmen nechal prázdné závorky; menu,
   `strom plan`, aplikace Strom i soubor GEDCOM ukazovaly jméno s jeho ID zopakované. Každé teď jméno řekne jednou.
 - **Widget otevře správný výzkum.** Při několika stromech stejného jména v aplikaci Strom mohl widget na ploše Macu
   otevřít jiný z nich; teď otevře strom svého výzkumu.
+- **Mnohem menší logy sezení.** Logy sezení a čtenářů už neuchovávají obrázky, na které se agent díval (jen jejich
+  velikost a cestu k náhledu), takže jsou o 95–99 % menší.
+- **Úklid, který stačí.** `strom tidy` zvládne logy jakékoli velikosti. Náhledy skenů, přerušená stahování a další,
+  co strom umí vyrobit znovu, se uklízejí i bez souhlasu; logy se pak jen zmenší, nikdy nesmažou. Po odmítnutí přijde
+  otázka ještě jednou, když `.strom` výrazně přeroste samotný výzkum.
+- **Archiv, který neodpovídá, zastaví smyčku agenta.** `strom fetch` řekne, kdy to zkusit znovu a co dělat mezitím;
+  stejný dotaz ve stejném sezení skončí hned (exit 8) a nic neodešle. Úkol, jehož archiv má pauzu, počká mimo frontu
+  (plán ho ukáže odložený do té doby) a `strom run --loop` do té doby počká, místo aby pouštěl sezení bez práce.
+- **Čtenáři nečekají na umlklou službu.** Čtenář, jehož agent po opakovaném pokusu služby zmlkne, se jednou obnoví
+  tam, kde skončil; když mlčí dál, hned skončí. Takový výpadek už nezmenšuje dávky čtení.
+- **Brána týdne předplatného pustí víc sezení za sebou.** Když jednou čeká na náskok, pustí znovu až se dvěma body navíc
+  (při 15: 17), místo jednoho sezení po každém čekání.
 
 ## 1.21.0
 

package/CHANGELOG.de.md

@@ -7,7 +7,7 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.22.0
 
-*In Vorbereitung: die Betas bis 1.22.0-beta.2. Der Abschnitt ist mit dem Release vollständig.*
+*In Vorbereitung: die Betas bis 1.22.0-beta.3. Der Abschnitt ist mit dem Release vollständig.*
 
 - **Jeder Name einmal in dem, was wartet.** Eine Aufgabe zu Material, das aus der Strom-App gesendet wurde, nannte im
   Widget und auf der Seite des Telefons jede Person zweimal (das zweite Mal in eckigen Klammern), und ihr Text ohne
@@ -15,6 +15,21 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   seiner ID wiederholt. Jedes nennt den Namen jetzt einmal.
 - **Das Widget öffnet die richtige Forschung.** Bei mehreren Stammbäumen gleichen Namens in der Strom-App konnte das
   Widget auf dem Mac-Schreibtisch einen der anderen öffnen; jetzt öffnet es den Stammbaum seiner eigenen Forschung.
+- **Viel kleinere Sitzungsprotokolle.** Die Protokolle der Sitzungen und Leser behalten die Bilder, die der Agent
+  angesehen hat, nicht mehr (nur ihre Größe und den Pfad der Ansicht) und sind dadurch 95–99 % kleiner.
+- **Aufräumen, das mithält.** `strom tidy` bewältigt Protokolle jeder Größe. Ansichten von Scans, abgebrochene
+  Downloads und anderes, was strom neu erstellen kann, werden auch ohne Zustimmung aufgeräumt; Protokolle werden dann
+  nur verkleinert, nie gelöscht. Nach einem Nein kommt die Frage noch einmal, wenn `.strom` weit über die Forschung
+  hinauswächst.
+- **Ein Archiv, das nicht antwortet, beendet die Schleife des Agenten.** `strom fetch` sagt, wann es wieder zu
+  versuchen ist und was bis dahin zu tun ist; dieselbe Anfrage in derselben Sitzung endet sofort (Exit 8) und sendet
+  nichts. Eine Aufgabe, deren Archiv pausiert, wartet bis dahin außerhalb der Warteschlange (der Plan zeigt sie bis zu
+  dieser Zeit zurückgestellt), und `strom run --loop` wartet bis dahin, statt Sitzungen ohne Arbeit zu starten.
+- **Leser warten nicht mehr auf einen verstummten Dienst.** Ein Leser, dessen Agent nach einem erneuten Versuch seines
+  Dienstes verstummt, wird einmal dort fortgesetzt, wo er aufhörte; bleibt er still, endet er sofort. Ein solcher
+  Ausfall verkleinert die Lesestapel nicht mehr.
+- **Das Tor der Abo-Woche lässt mehrere Sitzungen hintereinander laufen.** Wartet es einmal auf Vorsprung, lässt es
+  erst mit zwei Punkten mehr wieder los (bei 15: 17), statt einer Sitzung nach jedem Warten.
 
 ## 1.21.0
 

package/CHANGELOG.md

@@ -7,13 +7,27 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 1.22.0
 
-*In preparation: the betas up to 1.22.0-beta.2. The section is complete with the release.*
+*In preparation: the betas up to 1.22.0-beta.3. The section is complete with the release.*
 
 - **Each name once in what waits.** A task for material sent from the Strom app named each person twice in the
   widget and on the phone's page (the second time in brackets), and its text without names kept empty brackets; the
   menu, `strom plan`, the Strom app and the GEDCOM file showed the name with its ID repeated. Each says the name once.
 - **The widget opens the right research.** With several trees of one name in the Strom app, the widget on the Mac's
   desktop could open one of the others; it now opens the tree of its own research.
+- **Much smaller session logs.** The logs of sessions and readers no longer keep the images the agent looked at
+  (only their size and the view's path), so they are 95–99 % smaller.
+- **Tidying that keeps up.** `strom tidy` handles logs of any size. Views of scans, downloads cut short and other
+  things strom makes again are kept in order even without a yes; logs are only made smaller then, never removed. After
+  a no, the question comes once more when `.strom` grows far beyond the research.
+- **An archive that stops answering stops the agent's loop.** `strom fetch` says when to try again and what to do
+  meanwhile; asked again in the same session it ends at once (exit 8) and sends nothing. A task whose archive is left
+  alone waits out of the queue until then (the plan shows it put off until that time), and `strom run --loop` waits
+  for that time instead of starting sessions with nothing to do.
+- **Readers no longer wait out a silent service.** A reader whose agent goes silent after a retry of its service is
+  resumed once where it stopped; still silent, it ends at once. Such a failure no longer makes the reading batches
+  smaller.
+- **The gate of the subscription's week lets several sessions run in a row.** Once it waits for points in hand, it goes again only
+  with two more (at 15: 17), instead of one session after every wait.
 
 ## 1.21.0
 

package/assets/lang/cs.json

@@ -250,7 +250,7 @@
   "ui.tune.context.none": "Kontext: nevyčistil se (čtenáři: {of})",
   "ui.tune.context.unknown": "Vyčištění kontextu: neznámé (spotřeba se hlásí až na konci)",
   "ui.tune.readers": "Čtenáři bez výsledku: {bad} z {n}",
-  "ui.tune.readers.halted": "Čtenáři zastavení přihlášením, limitem plánu nebo chybou: {n} – nepočítají se, o čtení neříkají nic",
+  "ui.tune.readers.halted": "Čtenáři zastavení přihlášením, limitem plánu, chybou nebo výpadkem služby: {n} – nepočítají se, o čtení neříkají nic",
   "ui.tune.books": "Knihy:",
   "ui.tune.more": "  … další: {n} (všechny: --json)",
   "ui.tune.book": "  {id} {title}: skeny {scans} · pohledy na sken {vps}",
@@ -544,6 +544,7 @@
   "ui.run.stop.user": "zastaveno ručně",
   "ui.run.stop.time": "časový limit",
   "ui.run.stop.empty": "žádné otevřené úkoly",
+  "ui.run.stop.asleep": "do {at} není co dělat – zbylé úkoly potřebují {host}, který teď neodpovídá",
   "ui.run.stop.problems": "doklady mají problém – strom check",
   "ui.run.stop.denied": "agent nesměl spouštět strom – nepustila ho jeho oprávnění nebo sandbox; nic dalšího se nespustilo",
   "ui.run.stop.limit": "limit předplatného{resets}",
@@ -1124,6 +1125,7 @@
   "ui.tidy.no": "Nic se nesmazalo.",
   "ui.consent.tidy": "Uvolnit asi {size} vedle výzkumu {name} (staré záznamy sezení, náhledy skenů, dávno zapsaná poslání)? Výzkum i jeho skeny zůstanou.",
   "ui.tidy.first": "Vedle výzkumu se nastřádalo, co jde uvolnit, asi {size} (záznamy práce, náhledy snímků a podobně – nikdy výzkum). Ukazuje se tu jednou; později v menu Nastavení → Údržba → Místo na disku.",
+  "ui.tidy.again": "Co si strom drží vedle výzkumu, narostlo na {strom} (samotný výzkum má {research}); uvolnit jde asi {size} (hlavně záznamy práce – nikdy výzkum). Ukazuje se tu ještě jednou, naposledy; později v menu Nastavení → Údržba → Místo na disku.",
   "ui.tidy.hint": "Vedle výzkumu si strom drží {strom}, z toho jde uvolnit {size}: strom tidy (v menu Nastavení → Údržba → Místo na disku)",
   "ui.error.consent": "tady je potřeba souhlas – {question}",
   "ui.error.consent.hint": "spustit ve vlastním terminálu: {set}",
@@ -1642,6 +1644,8 @@
   "ui.plan.title": "Co agent udělá dál – {name}:",
   "ui.plan.now": "právě teď",
   "ui.plan.images": " (nejdřív potřebuje snímky)",
+  "ui.plan.later": "později",
+  "ui.plan.asleep": " (odloženo do {at}: {host} teď neodpovídá)",
   "ui.plan.more": "… a další úkoly: {n}",
   "ui.plan.stories": "Potom vyprávění: {n} ({names})",
   "ui.plan.waiting": "Čeká: {count} · v menu: Co čeká",
@@ -1670,6 +1674,8 @@
   "ui.run.beside.sure": "Spustit další vedle něj?",
   "ui.run.gate": "· podmínka: {name} — ptá se před každým sezením; běh může nechat čekat",
   "ui.run.gate.wait": "⏸ čekám do {at} — {reason} (Ctrl-C běh ukončí)",
+  "ui.run.asleep.wait": "⏸ čekám do {at} – zbylé úkoly potřebují {host}, který teď neodpovídá (Ctrl-C běh ukončí)",
+  "ui.run.asleep.why": "{host} teď neodpovídá",
   "ui.run.stop.gate": "podmínka „{name}“ řekla dost — {reason}",
   "ui.run.stop.gate.error": "podmínka „{name}“ neodpověděla, jak má — {reason} (strom gate test)",
   "ui.run.gate.once": "· podmínka: {name} — tyto úkoly jsou spuštěné ručně: zeptám se jí jednou, a kdyby nespouštěla, přijde otázka, zda přesto začít",

package/assets/lang/de.json

@@ -250,7 +250,7 @@
   "ui.tune.context.none": "Kontext: nicht geleert (Leser: {of})",
   "ui.tune.context.unknown": "Leeren des Kontexts: unbekannt (der Verbrauch wird erst am Ende genannt)",
   "ui.tune.readers": "Leser ohne Ergebnis: {bad} von {n}",
-  "ui.tune.readers.halted": "Leser, die eine Anmeldung, das Limit des Plans oder ein Fehler gestoppt hat: {n} – nicht gezählt, nichts über das Lesen",
+  "ui.tune.readers.halted": "Leser, die eine Anmeldung, das Limit des Plans, ein Fehler oder ein Ausfall des Dienstes gestoppt hat: {n} – nicht gezählt, nichts über das Lesen",
   "ui.tune.books": "Bücher:",
   "ui.tune.more": "  … weitere: {n} (alle: --json)",
   "ui.tune.book": "  {id} {title}: Scans {scans} · Ansichten pro Scan {vps}",
@@ -544,6 +544,7 @@
   "ui.run.stop.user": "von Hand angehalten",
   "ui.run.stop.time": "Zeitlimit",
   "ui.run.stop.empty": "keine offenen Aufgaben",
+  "ui.run.stop.asleep": "bis {at} nichts zu tun – die übrigen Aufgaben brauchen {host}, der gerade nicht antwortet",
   "ui.run.stop.problems": "die Belege haben Probleme – strom check",
   "ui.run.stop.denied": "der Agent durfte strom nicht starten – seine Berechtigungen oder seine Sandbox ließen es nicht zu; nichts weiter wurde gestartet",
   "ui.run.stop.limit": "Limit des Abonnements{resets}",
@@ -1124,6 +1125,7 @@
   "ui.tidy.no": "Nichts wurde gelöscht.",
   "ui.consent.tidy": "Etwa {size} neben der Forschung {name} freigeben (alte Sitzungsprotokolle, Ansichten von Scans, längst geschriebene Sendungen)? Die Forschung und ihre Scans bleiben.",
   "ui.tidy.first": "Neben der Forschung hat sich angesammelt, was freigegeben werden kann, etwa {size} (Protokolle, Ansichten von Scans und Ähnliches – nie die Forschung). Wird hier einmal gezeigt; später im Menü Einstellungen → Wartung → Speicherplatz.",
+  "ui.tidy.again": "Was strom neben der Forschung hält, ist auf {strom} angewachsen (die Forschung selbst: {research}); davon lassen sich etwa {size} freigeben (vor allem Protokolle der Arbeit – nie die Forschung). Wird hier noch ein letztes Mal gezeigt; später im Menü Einstellungen → Wartung → Speicherplatz.",
   "ui.tidy.hint": "Neben der Forschung hält strom {strom}, davon lassen sich {size} freigeben: strom tidy (im Menü Einstellungen → Wartung → Speicherplatz)",
   "ui.error.consent": "dafür braucht es eine Zustimmung – {question}",
   "ui.error.consent.hint": "im eigenen Terminal ausführen: {set}",
@@ -1642,6 +1644,8 @@
   "ui.plan.title": "Was der Agent als Nächstes tut – {name}:",
   "ui.plan.now": "gerade jetzt",
   "ui.plan.images": " (braucht zuerst die Scans)",
+  "ui.plan.later": "später",
+  "ui.plan.asleep": " (zurückgestellt bis {at}: {host} antwortet gerade nicht)",
   "ui.plan.more": "… und {n, plural, one {# weitere Aufgabe} other {# weitere Aufgaben}}",
   "ui.plan.stories": "Danach die Geschichten: {n} ({names})",
   "ui.plan.waiting": "Wartet: {count} · im Menü: Was wartet",
@@ -1670,6 +1674,8 @@
   "ui.run.beside.sure": "Einen weiteren daneben starten?",
   "ui.run.gate": "· Bedingung: {name} — vor jeder Sitzung gefragt; sie kann den Lauf warten lassen",
   "ui.run.gate.wait": "⏸ warte bis {at} — {reason} (Strg-C beendet den Lauf)",
+  "ui.run.asleep.wait": "⏸ warte bis {at} — die übrigen Aufgaben brauchen {host}, der gerade nicht antwortet (Strg-C beendet den Lauf)",
+  "ui.run.asleep.why": "{host} antwortet gerade nicht",
   "ui.run.stop.gate": "die Bedingung „{name}“ sagte Halt — {reason}",
   "ui.run.stop.gate.error": "die Bedingung „{name}“ gab keine gültige Antwort — {reason} (strom gate test)",
   "ui.run.gate.once": "· Bedingung: {name} — diese Aufgaben sind von Hand gestartet: sie wird einmal gefragt, und würde sie nicht starten, wird nachgefragt",

package/assets/plugins/gates/README.md

@@ -29,6 +29,10 @@ the gates here. `strom config unset run.gate`: no gate.
   is strom's own Node (TypeScript runs as it is) — best on every system. What
   the user gives the gate after its name (`run.gate "my-gate 20 night"`) is
   added to these arguments.
+
+What a gate remembers between askings it keeps in its own folder (strom asks it
+there): strom never touches a file there but those of the gates it ships
+(`gate.json`, `gate.ts`).
 - `timeout`: seconds it may take (default 120). No answer in time: an error.
 
 ## The answer
@@ -124,6 +128,13 @@ 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.
 
+Once it waited for want of points in hand, it goes again only with 2 more (at
+15: 17 in hand; early in the week its share, as the number's), and then goes
+until fewer than the number are in hand: several sessions in a row instead of
+one after every wait ("until 17 in hand, then several sessions in a row"). It
+remembers the week it waits in (`hold.json` in its folder); a new week starts
+free.
+
 **A cap** — your own hard stop for the week:
 
     strom config set run.gate "claude-usage 10 --cap 95"

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; 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.",
+  "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; once it waited, it goes again only with 2 more in hand, then for several sessions in a row): 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

@@ -22,6 +22,12 @@
 // 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.
 //
+// Once it waited for want of points in hand, it goes again only with RESERVE
+// more (at 15: 17), and then goes until fewer than the number are in hand — so
+// several sessions run in a row, not one after each wait. The reserve grows
+// with the week as the number does. Run by strom (STROM_GATE), the gate keeps
+// the week it waits in in its own folder (hold.json); a new week starts free.
+//
 // 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
@@ -31,6 +37,7 @@
 //
 // strom writes this file; a copy of your own goes into a folder of its own name.
 
+import fs from "node:fs";
 import { spawnSync } from "node:child_process";
 
 const DAY = 86_400_000;
@@ -49,6 +56,14 @@ const END_WINDOW = 2 * 3_600_000;
 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;
+/**
+ * Once it waited for want of points in hand, this many more are needed before it goes again (with the full number;
+ * early in the week its share, as the number's): a session takes about a point of the week, so the work goes on in
+ * runs of a few sessions instead of one after every wait — each session reads its brief anew. With no number too.
+ */
+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);
 
 const T: Record<string, Record<string, string>> = {
@@ -58,7 +73,7 @@ const T: Record<string, Record<string, string>> = {
     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}",
+    hold: " — until {target} in hand, then several sessions in a row; 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",
@@ -78,7 +93,7 @@ const T: Record<string, Record<string, string>> = {
     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}",
+    hold: " — čeká na náskok {target}, pak víc sezení za sebou; 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í",
@@ -98,7 +113,7 @@ const T: Record<string, Record<string, string>> = {
     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}",
+    hold: " — wartet auf Vorsprung {target}, dann mehrere Sitzungen am Stück; 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",
@@ -188,22 +203,56 @@ 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 };
+// the reserve once it waited: grown with the week as the number is (its share of the need), whole with no number
+const reserve = min > 0 ? (RESERVE * need) / min : RESERVE;
+const held = holding(resets);
 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 }));
+if (behind >= need + (held ? reserve : 0)) {
+  hold(undefined);
+  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
+// it waits for want of points in hand: from now on it goes again only with the reserve too
+if (!held) hold(resets);
+// else it waits for the first of: the week caught up with the reserve (gone − used ≥ need + reserve = k·need,
+// k = 1 + RESERVE/n: with the full number gone = used + n + RESERVE, early in the week gone·(1 − k/2) = used — never
+// when k ≥ 2), 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 k = 1 + RESERVE / min;
+const byHalf = min > 0 && k < 2 ? week.used / (1 - k / 2) : Infinity;
+const caught = start + (Math.min(week.used + min + RESERVE, byHalf) / 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 });
+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)));
 
+/** 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;
+  try {
+    const week = Date.parse((JSON.parse(fs.readFileSync(HOLD, "utf8")) as { week?: string }).week ?? "");
+    return Math.abs(week - resets) < DAY;
+  } catch {
+    return false;
+  }
+}
+
+/** The week it now waits in for the reserve, or none (gone). Never fails: without it the gate only forgets. */
+function hold(resets: number | undefined): void {
+  if (!HOLD) return;
+  try {
+    if (resets === undefined) fs.rmSync(HOLD, { force: true });
+    else fs.writeFileSync(HOLD, JSON.stringify({ week: new Date(resets).toISOString(), since: new Date().toISOString() }) + "\n");
+  } catch {
+    // a folder it may not write here: it asks as if for the first time
+  }
+}
+
 /** 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;

package/dist/brief/brief.js

@@ -18,7 +18,7 @@ import { calibrationLine } from "../core/calibration.js";
 import { taskRecordsets } from "../core/frontier.js";
 import { reviewItems } from "../core/review.js";
 import { byHandOnly, listConnectors, missingConsents, readyConnectors, routeOf } from "../core/connector.js";
-import { clock, hostAllowed, hostState, REFUSED_FOREVER } from "../core/net.js";
+import { clock, clockUp, hostAllowed, hostState, leftAloneFor, REFUSED_FOREVER } from "../core/net.js";
 import { archiveLevel } from "../core/terms.js";
 import { onHost, permissionQuestions, setHosts } from "../core/archivewait.js";
 import { runs, runsArg, shellArg } from "../cli/format.js";
@@ -762,7 +762,9 @@ function archiveLine(tree, b, repo, shared, installed, qs = []) {
         try {
             const st = hostState(net, host);
             if (st.blockedUntil && st.blockedUntil > Date.now())
-                parts.push(`${host} left alone until ${clock(st.blockedUntil)}${st.reason ? ` (${st.reason})` : ""} — nothing to it before then`);
+                parts.push(`${host} left alone until ${clock(st.blockedUntil)}${st.reason ? ` (${st.reason})` : ""} — nothing to it before then${
+                // it went silent, or asked to slow down: the work goes elsewhere meanwhile, never a fetch asked again and again
+                leftAloneFor(st, Date.now()) ? `: work on what needs nothing from it, else back to the queue for later (strom session close --continue) and on after ${clockUp(st.blockedUntil)}` : ""}`);
         }
         catch {
             // the host's state unreadable: the level says enough

package/dist/cli/menu.js

@@ -11,7 +11,7 @@ import path from "node:path";
 import { ui } from "./ui.js";
 import { isAgent } from "../core/which.js";
 import { offerAdopt } from "./seal.js";
-import { mb, setTidyAsked, tidyAsked, tidyOn, tidyPlan, TIDY_SAID } from "../core/tidy.js";
+import { mb, setTidyAsked, tidyAskAgain, tidyAsked, tidyOn, tidyPlan, TIDY_SAID } from "../core/tidy.js";
 import { calibrationLabel, calibrationOffer } from "../core/viewsizes.js";
 /** A line as a sentence: its first letter capital (a catalog's text that also stands inside a line). */
 const sentence = (s) => s.charAt(0).toUpperCase() + s.slice(1);
@@ -214,11 +214,13 @@ export async function runMenu(ctx, run) {
             const disk = tidyPlan(tree);
             if (disk.frees >= TIDY_SAID) {
                 // never tidied (an older strom gathered it): its first tidy offered once, shown and asked as strom tidy asks
-                // (Enter says no) — nothing goes unasked; then kept in order by itself. Nobody to ask (no terminal,
-                // STROM_NONINTERACTIVE): only said, the offer kept for the person
-                if (!tidyOn(root) && !tidyAsked(root) && !isAgent(ctx.env) && ctx.interactive) {
-                    setTidyAsked(root);
-                    out(t("ui.tidy.first", { size: mb(disk.frees, lang) }));
+                // (Enter says no) — nothing but what strom makes again goes unasked; then kept in order by itself. Said no and
+                // grown far beyond the research since (tidyAskAgain): offered once more, never again. Nobody to ask (no
+                // terminal, STROM_NONINTERACTIVE): only said, the offer kept for the person
+                const again = tidyAskAgain(root, disk);
+                if (!tidyOn(root) && (!tidyAsked(root) || again) && !isAgent(ctx.env) && ctx.interactive) {
+                    setTidyAsked(root, again);
+                    out(again ? t("ui.tidy.again", { strom: mb(disk.size.strom, lang), research: mb(disk.size.research, lang), size: mb(disk.frees, lang) }) : t("ui.tidy.first", { size: mb(disk.frees, lang) }));
                     out();
                     await run(["tidy"]);
                     out();

package/dist/cli/ui.js

@@ -224,7 +224,7 @@ export const UI = {
     "ui.tune.context.none": "Context: not cleared (readers: {of})",
     "ui.tune.context.unknown": "Context clears: not known (the use is said only at the end)",
     "ui.tune.readers": "Readers without a result: {bad} of {n}",
-    "ui.tune.readers.halted": "Readers stopped by a login, a plan's limit or a failure: {n} — not counted, nothing of the reading",
+    "ui.tune.readers.halted": "Readers stopped by a login, a plan's limit, a failure or their service gone silent: {n} — not counted, nothing of the reading",
     "ui.tune.books": "Books:",
     "ui.tune.more": "  … {n} more (all of them: --json)",
     "ui.tune.book": "  {id} {title}: scans {scans} · views per scan {vps}",
@@ -521,6 +521,7 @@ export const UI = {
     "ui.run.stop.user": "by hand",
     "ui.run.stop.time": "time limit",
     "ui.run.stop.empty": "no open tasks",
+    "ui.run.stop.asleep": "nothing to do until {at} — the tasks left need {host}, which is not answering now",
     "ui.run.stop.problems": "the evidence has problems — strom check",
     "ui.run.stop.denied": "the agent was not allowed to run strom — its permissions or its sandbox kept it away; nothing more was started",
     "ui.run.stop.limit": "subscription limit{resets}",
@@ -1015,6 +1016,7 @@ export const UI = {
     "ui.tidy.no": "Nothing was removed.",
     "ui.consent.tidy": "Free about {size} beside the research {name} (old logs, views of scans, sends written long ago)? The research and its images stay.",
     "ui.tidy.first": "Beside the research strom has gathered what can go, about {size} (logs, views of scans and the like — never the research). Shown once here; later in the menu: Settings → Maintenance → Disk space.",
+    "ui.tidy.again": "What strom keeps beside the research has grown to {strom} (the research itself: {research}); about {size} of it can go (mostly logs of work — never the research). Shown here once more, the last time; later in the menu: Settings → Maintenance → Disk space.",
     "ui.tidy.hint": "Beside the research strom keeps {strom}, {size} of it can go: strom tidy (the menu: Settings → Maintenance → Disk space)",
     "ui.fixes.title": "Fixes: what earlier versions of strom, or earlier models, left behind in this research",
     "ui.fixes.none": "Nothing waits: nothing in this research to set right or to read again.",
@@ -1631,6 +1633,8 @@ export const UI = {
     "ui.plan.title": "What the agent will do next – {name}:",
     "ui.plan.now": "now",
     "ui.plan.images": " (needs the scans first)",
+    "ui.plan.later": "later",
+    "ui.plan.asleep": " (put off until {at}: {host} is not answering now)",
     "ui.plan.more": "… and {n, plural, one {# more task} other {# more tasks}}",
     "ui.plan.stories": "Then the stories: {n} ({names})",
     "ui.plan.waiting": "Waiting: {count} · in the menu: What waits",
@@ -1660,6 +1664,8 @@ export const UI = {
     "ui.run.others": "⚠ Another run works in this family tree already (since {since}): this one takes other tasks — the costs add up.",
     "ui.run.gate": "· condition: {name} — asked before each session; it may make the run wait",
     "ui.run.gate.wait": "⏸ waiting until {at} — {reason} (Ctrl-C ends the run)",
+    "ui.run.asleep.wait": "⏸ waiting until {at} — the tasks left need {host}, which is not answering now (Ctrl-C ends the run)",
+    "ui.run.asleep.why": "{host} is not answering now",
     "ui.run.stop.gate": "the condition “{name}” said stop — {reason}",
     "ui.run.stop.gate.error": "the condition “{name}” gave no proper answer — {reason} (strom gate test)",
     "ui.run.gate.once": "· condition: {name} — these tasks are started by hand: it is asked once, and if it would not start, \"start anyway?\" is asked",

package/dist/commands/browse.js

@@ -13,7 +13,8 @@ import { knownGenerations, ownerName, pedigree, personCard, recent, treeStats }
 import { displayName } from "../core/people.js";
 import { humanTask } from "../cli/human.js";
 export { humanTask };
-import { lacksImages } from "../core/queue.js";
+import { lacksImages, waitsForArchive } from "../core/queue.js";
+import { clockUp } from "../core/net.js";
 import { forStory } from "../core/stories.js";
 import { isArchive } from "../core/mode.js";
 import { actsAsArchive, stateOf } from "../core/state.js";
@@ -212,13 +213,20 @@ register({
         const waiting = waits.length;
         const shown = work.slice(0, count);
         let n = 0;
-        const rows = shown.map((t) => [
-            `  ${t.state === "doing" ? ui(lang, "ui.plan.now") : `${++n}.`}`,
-            `${truncate(humanTask(tree, t.what, lang), 110)}${lacksImages(tree, t) ? ui(lang, "ui.plan.images") : ""}`,
-        ]);
+        // put off for a while: their archive is not answering now (core/leftalone.ts) — back in the queue by themselves then
+        const held = waitsForArchive(tree);
+        const inQueue = new Set(queue.map((t) => t.id));
+        const later = rankedQueue(tree, { strategy: ctx.settings.strategy(tree.config), awake: true })
+            .map((r) => r.task)
+            .filter((t) => !inQueue.has(t.id) && !forStory(t))
+            .flatMap((t) => ((a) => (a ? [{ t, a }] : []))(held(t)));
+        const rows = [
+            ...shown.map((t) => [`  ${t.state === "doing" ? ui(lang, "ui.plan.now") : `${++n}.`}`, `${truncate(humanTask(tree, t.what, lang), 110)}${lacksImages(tree, t) ? ui(lang, "ui.plan.images") : ""}`]),
+            ...later.slice(0, 5).map(({ t, a }) => [`  ${ui(lang, "ui.plan.later")}`, `${truncate(humanTask(tree, t.what, lang), 110)}${ui(lang, "ui.plan.asleep", { at: clockUp(a.until), host: a.host })}`]),
+        ];
         const storyNames = [...new Set(stories.map((t) => tree.get(t.subject[0] ?? "")).filter((p) => !!p).map((p) => `${displayName(p)} [${p.id}]`))];
         const out = [ui(lang, "ui.plan.title", { name: tree.config.name })];
-        if (!queue.length)
+        if (!queue.length && !later.length)
             out.push(`  ${ui(lang, "ui.plan.none")}`);
         else {
             if (rows.length)
@@ -233,7 +241,10 @@ register({
         if (queue.length)
             out.push("", ui(lang, "ui.plan.steer"));
         const item = (t) => ({ id: t.id, what: humanTask(tree, t.what, lang), level: t.level, state: t.state, needsImages: lacksImages(tree, t) });
-        return { text: lines(...out), data: { tasks: work.map(item), stories: stories.map(item), waiting } };
+        return {
+            text: lines(...out),
+            data: { tasks: work.map(item), stories: stories.map(item), waiting, ...(later.length ? { later: later.map(({ t, a }) => ({ ...item(t), until: new Date(a.until).toISOString(), host: a.host })) } : {}) },
+        };
     },
 }, {
     path: ["recent"],