strom-research 1.28.0-beta.1 → 1.28.0-beta.3

package/CHANGELOG.cs.md

@@ -7,7 +7,7 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 
 ## 1.28.0
 
-*Připravuje se: bety do 1.28.0-beta.1. Oddíl bude úplný s vydáním.*
+*Připravuje se: bety do 1.28.0-beta.3. Oddíl bude úplný s vydáním.*
 
 - **Jak Strom funguje je přímo ve stromu: `strom doc`.** Dokumentace aplikace a výzkumu v češtině, angličtině, němčině
   a polštině je součástí stromu a čte se i bez internetu: `strom doc` vypíše kapitoly, `strom doc R10.1` jedno pravidlo
@@ -26,9 +26,22 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 - **Překlad vedle přepisu.** Záznam v jiném jazyce nebo písmu, než je jazyk výzkumu – latina, kurent, polština,
   azbuka –, dostane vedle doslovného přepisu i překlad do jazyka výzkumu.
 
+- **Kde agent pracuje, pro mapu aplikace Strom.** Během práce agenta strom aplikaci říká, ke kterému místu patří kniha,
+  kterou agent zkoumá – farnost nebo obec jejích zápisů, nikdy archiv –, aby ho aplikace při sledování práce mohla
+  ukázat na mapě. Když to výzkum neví, nic neříká a aplikace zůstane u míst osoby. Práce na rodině uvede pár – manžela,
+  jinak manželku – i rodinu samotnou, aby se aplikace mohla zaměřit na pár.
+
 - **DigiArchiv SOA v Třeboni:** podmínky, jak je archiv potvrdil – ručně jen vybrané snímky, nikdy celá kniha, žádné
   nástroje ke stahování – a jak citovat trvalý odkaz na snímek.
 
+- **Seznam před během ukazuje, co běh vezme.** V položce Nechat agenta pracovat samotného jsou mezi úkoly v pořadí, v jakém je agent
+  vezme, i úkoly dějin míst, když na ně přijde řada – místa údajů k zařazení jdou napřed –, označené jako dějiny.
+
+- **Podmínka běhu na jednom řádku.** Co podmínka (`run.gate`) odpověděla, jak se ptá – před každým sezením, nebo při
+  ručním spuštění jednou – a její strop se před prvním sezením řeknou na jednom řádku, ne na třech. Agent, který čte
+  webové stránky přes vlastního pomocníka, se už nehlásí jako bez nástroje na čtení webu; nástroj, který opravdu
+  chybí, se řekne v jazyce výzkumu.
+
 ## 1.27.0
 
 *5. 11. 2026 · patří k aplikaci Strom 3.23.0.*

package/CHANGELOG.de.md

@@ -7,7 +7,7 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.28.0
 
-*In Vorbereitung: die Betas bis 1.28.0-beta.1. Der Abschnitt ist mit dem Release vollständig.*
+*In Vorbereitung: die Betas bis 1.28.0-beta.3. Der Abschnitt ist mit dem Release vollständig.*
 
 - **Wie Strom funktioniert gehört zu strom: `strom doc`.** Die Dokumentation der App und der Forschung auf Tschechisch,
   Englisch, Deutsch und Polnisch ist Teil von strom und liest sich auch ohne Internet: `strom doc` listet die Kapitel,
@@ -29,10 +29,25 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   Latein, Kurrent, Polnisch, Kyrillisch – bekommt neben der wörtlichen Abschrift eine Übersetzung in die Sprache der
   Forschung.
 
+- **Wo der Agent arbeitet, für die Karte der Strom-App.** Während ein Agent arbeitet, sagt strom der App, zu welchem
+  Ort das Buch gehört, das er untersucht – die Pfarrei oder das Dorf seiner Einträge, nie das Archiv –, damit die App
+  ihn beim Verfolgen der Arbeit auf der Karte zeigen kann. Weiß die Forschung es nicht, sagt sie nichts, und die App
+  bleibt bei den Orten der Person. Arbeit an einer Familie nennt das Paar – den Ehemann, sonst die Ehefrau – und die
+  Familie selbst, damit die App sich dem Paar zuwenden kann.
+
 - **DigiArchiv des Staatlichen Gebietsarchivs Třeboň:** seine Bedingungen, wie das Archiv sie bestätigt hat – von Hand
   nur ausgewählte Bilder, nie ein ganzes Buch, keine Download-Werkzeuge – und wie der dauerhafte Link eines Bildes
   zitiert wird.
 
+- **Die Liste vor einem Lauf zeigt, was der Lauf nimmt.** Unter „Den Agenten allein arbeiten lassen“ stehen unter den
+  Aufgaben in der Reihenfolge, in der der Agent sie nimmt, nun auch die Aufgaben der Geschichte der Orte, wenn sie an der
+  Reihe sind – die Orte der Angaben zuerst –, als Geschichte gekennzeichnet.
+
+- **Die Bedingung eines Laufs in einer Zeile.** Was die Bedingung (`run.gate`) geantwortet hat, wie sie gefragt wird
+  – vor jeder Sitzung oder bei von Hand gestarteten Aufgaben einmal – und ihre Obergrenze stehen vor der ersten Sitzung
+  in einer Zeile, nicht in dreien. Ein Agent, der Webseiten über seinen eigenen Helfer liest, wird nicht mehr
+  als ohne Werkzeug zum Lesen des Webs gemeldet; ein Werkzeug, das wirklich fehlt, wird in der Sprache der Forschung gesagt.
+
 ## 1.27.0
 
 *5.11.2026 · gehört zur Strom-App 3.23.0.*

package/CHANGELOG.md

@@ -7,7 +7,7 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 1.28.0
 
-*In preparation: the betas up to 1.28.0-beta.1. The section is complete with the release.*
+*In preparation: the betas up to 1.28.0-beta.3. The section is complete with the release.*
 
 - **How Strom works comes with strom: `strom doc`.** The documentation of the app and the research, in Czech, English,
   German and Polish, is part of strom and reads offline: `strom doc` lists its chapters, `strom doc R10.1` shows one rule
@@ -27,9 +27,24 @@ The changes of each version in short. The full notes and the install lines are o
 - **A translation beside the transcript.** A record in another language or script than the research's – Latin, German
   Kurrent, Polish, Cyrillic – gets a translation into the research's language beside its word-for-word transcript.
 
+- **Where the agent works, for the map of the Strom app.** While an agent works, strom tells the app which place the
+  book it examines belongs to – the parish or village of its records, never the archive – so the app can show it on the
+  map when following the work. When the research does not know it, it says nothing, and the app keeps to the person's
+  own places. Work on a family names the couple – the husband, else the wife – and the family itself, so the app can
+  turn to the pair.
+
 - **DigiArchiv of the regional archive in Třeboň:** its terms as the archive confirmed them – selected images saved by
   hand only, never a whole book, no download tools – and how to cite an image's permanent link.
 
+- **The list before a run shows what the run takes.** Under Let the agent work on its own, the tasks listed in the order
+  the agent takes them now include the tasks of the history of the places in their turn – the places of the facts to
+  map come first – marked as history.
+
+- **The condition of a run in one line.** What the condition (`run.gate`) answered, how it is asked – before each
+  session, once for tasks started by hand – and its cap are said in one line before the first session, not in three.
+  An agent that reads web pages through its own helper is no longer reported as missing its web fetch; a tool
+  really missing is said in the research's language.
+
 ## 1.27.0
 
 *2026-11-05 · goes with the Strom app 3.23.0.*

package/CHANGELOG.pl.md

@@ -7,7 +7,7 @@ Zmiany każdej wersji w skrócie. Pełne informacje o wydaniach i polecenia inst
 
 ## 1.28.0
 
-*W przygotowaniu: bety do 1.28.0-beta.1. Sekcja będzie kompletna z wydaniem.*
+*W przygotowaniu: bety do 1.28.0-beta.3. Sekcja będzie kompletna z wydaniem.*
 
 - **Jak działa Strom – w samym stromie: `strom doc`.** Dokumentacja aplikacji i badań po czesku, angielsku, niemiecku i
   polsku jest częścią stromu i czyta się ją także bez internetu: `strom doc` wypisuje rozdziały, `strom doc R10.1` jedną
@@ -28,9 +28,24 @@ Zmiany każdej wersji w skrócie. Pełne informacje o wydaniach i polecenia inst
 - **Tłumaczenie obok transkrypcji.** Wpis w innym języku lub piśmie niż język badań – łacina, kurrenta, niemiecki,
   cyrylica – otrzymuje obok dosłownej transkrypcji tłumaczenie na język badań.
 
+- **Gdzie pracuje agent – dla mapy aplikacji Strom.** Podczas pracy agenta strom podaje aplikacji, do którego miejsca
+  należy księga, którą agent bada – parafia lub wieś jej wpisów, nigdy archiwum – aby aplikacja mogła je pokazać na
+  mapie podczas śledzenia pracy. Gdy badania tego nie wiedzą, nic nie podają, a aplikacja pozostaje przy miejscach
+  osoby. Praca nad rodziną podaje parę – męża, a jeśli go brak, żonę – oraz samą rodzinę, aby aplikacja mogła skupić
+  się na parze.
+
 - **DigiArchiv Archiwum Państwowego w Třeboniu:** jego warunki, tak jak potwierdziło je archiwum – ręcznie tylko wybrane
   skany, nigdy cała księga, żadnych narzędzi do pobierania – i jak cytować stały link do skanu.
 
+- **Lista przed uruchomieniem pokazuje, co weźmie agent.** W pozycji „Pozwól agentowi pracować samodzielnie“ wśród
+  zadań w kolejności, w jakiej bierze je agent, są teraz także zadania historii miejsc, gdy przychodzi ich kolej –
+  miejsca danych najpierw –, oznaczone jako historia.
+
+- **Warunek przebiegu w jednym wierszu.** Co odpowiedział warunek (`run.gate`), jak jest pytany – przed każdą sesją
+  albo raz przy zadaniach uruchomionych ręcznie – i jego pułap są podane przed pierwszą sesją w jednym wierszu, nie w
+  trzech. Agent, który czyta strony internetowe przez własnego pomocnika, nie jest już zgłaszany jako
+  pozbawiony narzędzia do czytania stron; narzędzie, którego naprawdę brak, jest podawane w języku badań.
+
 ## 1.27.0
 
 *5.11.2026 · współpracuje z aplikacją Strom 3.23.0.*

package/assets/lang/cs.json

@@ -614,6 +614,7 @@
   "ui.run.denied": "  · oprávnění odmítla {n}×: {what}",
   "ui.run.refused": "  · strom odmítl {n}× (limit {per, plural, one {# webového požadavku} other {# webových požadavků}} na jeden server v sezení nebo limit serveru): {what}",
   "ui.run.recover": "  · spojení agenta selhalo ({why}) — jeho sezení pokračuje za {s} s ({n}/{max})",
+  "ui.run.missingtools": "  · Claude Code nenačetl {tools} – sezení se bez toho nemusí obejít; s nastavením agent.addons on běží se vším jako dřív",
   "ui.run.exitOnly": "  · {session}: agent sezení uzavřel a pak skončil s kódem {code} — bráno jako hotové, běh pokračuje",
   "session.user": "zastaveno uživatelem",
   "session.run": "běh se zastavil dřív, než sezení skončilo (přerušení, nebo vypnutý počítač)",
@@ -2009,6 +2010,7 @@
   "ui.run.skip.held": "  · {task} vynechán: pracuje na něm jiný agent",
   "ui.run.next": "Na řadě jsou tyto úkoly, v pořadí, v jakém je agent vezme:",
   "ui.run.story": " (vyprávění)",
+  "ui.run.ofhistory": " (dějiny)",
   "ui.run.what": "Co má agent udělat?",
   "ui.run.queue": "Pracovat v pořadí fronty – počet úkolů se zadá",
   "ui.run.pick": "Jen vybrané úkoly ze seznamu",
@@ -2022,21 +2024,21 @@
   "ui.menu.working.more": "Samostatně teď pracují agenti: {n}.",
   "ui.run.beside": "⚠ Agent už tu pracuje sám (běhy: {n}). Další vedle něj si vezme jiné úkoly – náklady se sčítají.",
   "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ání do {at} — {reason} (Ctrl-C běh ukončí)",
   "ui.run.asleep.wait": "⏸ čekání 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} — ruční spuštění: při nesplněné podmínce jedna otázka, zda přesto začít",
   "ui.run.gate.anyway": "Podmínka „{name}“ by teď nespouštěla — {reason}. Spustit přesto?",
   "ui.run.gate.anyway.here": "Spustit přesto?",
   "ui.run.gate.later": "zatím ne",
   "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.gate.said": "· podmínka {name}: {word}{reason} (kód {status}; .strom/gate.log)",
+  "ui.run.gate.said": "· podmínka {name}{how}: {word}{reason} (kód {status}; .strom/gate.log)",
+  "ui.run.gate.how.each": " (ptá se před každým sezením)",
+  "ui.run.gate.how.once": " (ruční spuštění: ptá se jednou)",
+  "ui.run.gate.how.cap": " (strop: hlídá 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",

package/assets/lang/de.json

@@ -614,6 +614,7 @@
   "ui.run.denied": "  · Berechtigungen verweigert {n}×: {what}",
   "ui.run.refused": "  · strom hat {n}× abgelehnt (die Grenze von {per, plural, one {# Webanfrage} other {# Webanfragen}} an einen Server in einer Sitzung oder die des Servers): {what}",
   "ui.run.recover": "  · die Verbindung des Agenten ist abgebrochen ({why}) — seine Sitzung geht in {s} s weiter ({n}/{max})",
+  "ui.run.missingtools": "  · Claude Code hat {tools} nicht geladen – die Sitzung kommt ohne vielleicht nicht aus; mit der Einstellung agent.addons on läuft sie wie früher mit allem",
   "ui.run.exitOnly": "  · {session}: der Agent hat die Sitzung abgeschlossen und danach mit Code {code} geendet — als erledigt gewertet, der Lauf geht weiter",
   "session.user": "vom Benutzer angehalten",
   "session.run": "der Lauf brach ab, bevor die Sitzung endete (unterbrochen, oder der Computer wurde ausgeschaltet)",
@@ -2009,6 +2010,7 @@
   "ui.run.skip.held": "  · {task} ausgelassen: ein anderer Agent arbeitet daran",
   "ui.run.next": "Als Nächstes in der Warteschlange, in der Reihenfolge, in der der Agent sie nimmt:",
   "ui.run.story": " (eine Geschichte)",
+  "ui.run.ofhistory": " (Geschichte)",
   "ui.run.what": "Was soll der Agent tun?",
   "ui.run.queue": "Die Warteschlange in dieser Reihenfolge abarbeiten – wie viele, steht zur Wahl",
   "ui.run.pick": "Nur die aus der Liste gewählten Aufgaben",
@@ -2022,21 +2024,21 @@
   "ui.menu.working.more": "Gerade arbeiten Agenten selbstständig: {n}.",
   "ui.run.beside": "⚠ Hier arbeitet schon ein Agent selbstständig (Läufe: {n}). Ein weiterer daneben nimmt andere Aufgaben – die Kosten addieren sich.",
   "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": "⏸ Warten bis {at} — {reason} (Strg-C beendet den Lauf)",
   "ui.run.asleep.wait": "⏸ Warten 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} — von Hand gestartet: ist die Bedingung nicht erfüllt, eine Frage, ob trotzdem begonnen wird",
   "ui.run.gate.anyway": "Die Bedingung „{name}“ würde jetzt nicht starten — {reason}. Trotzdem starten?",
   "ui.run.gate.anyway.here": "Trotzdem starten?",
   "ui.run.gate.later": "noch nicht",
   "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.gate.said": "· Bedingung {name}: {word}{reason} (Code {status}; .strom/gate.log)",
+  "ui.run.gate.said": "· Bedingung {name}{how}: {word}{reason} (Code {status}; .strom/gate.log)",
+  "ui.run.gate.how.each": " (vor jeder Sitzung gefragt)",
+  "ui.run.gate.how.once": " (von Hand gestartet: einmal gefragt)",
+  "ui.run.gate.how.cap": " (Obergrenze: 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",

package/assets/lang/pl.json

@@ -614,6 +614,7 @@
   "ui.run.denied": "  · uprawnienia odmówiły {n}×: {what}",
   "ui.run.refused": "  · strom odmówił {n}× (limit {per, plural, one {# zapytania internetowego} few {# zapytań internetowych} many {# zapytań internetowych} other {# zapytań internetowych}} do jednego serwera w sesji albo limit serwera): {what}",
   "ui.run.recover": "  · połączenie agenta zostało przerwane ({why}) — jego sesja będzie kontynuowana za {s} s ({n}/{max})",
+  "ui.run.missingtools": "  · Claude Code nie wczytał {tools} – sesja może się bez tego nie obejść; z ustawieniem agent.addons on działa ze wszystkim, jak dawniej",
   "ui.run.exitOnly": "  · {session}: agent zamknął sesję, a potem zakończył się kodem {code} — uznane za ukończone, przebieg trwa dalej",
   "session.user": "zatrzymano przez użytkownika",
   "session.run": "przebieg zatrzymał się, zanim sesja się zakończyła (przerwanie albo wyłączony komputer)",
@@ -2009,6 +2010,7 @@
   "ui.run.skip.held": "  · {task} pominięte: pracuje nad nim inny agent",
   "ui.run.next": "Teraz kolej na te zadania, w kolejności, w jakiej weźmie je agent:",
   "ui.run.story": " (opowieść)",
+  "ui.run.ofhistory": " (historia)",
   "ui.run.what": "Co ma zrobić agent?",
   "ui.run.queue": "Praca według kolejki – liczba zadań do podania",
   "ui.run.pick": "Tylko wybrane zadania z listy",
@@ -2022,21 +2024,21 @@
   "ui.menu.working.more": "Agenci pracujący teraz samodzielnie: {n}.",
   "ui.run.beside": "⚠ Agent już tu pracuje samodzielnie (przebiegi: {n}). Kolejny obok niego weźmie inne zadania – koszty się sumują.",
   "ui.run.beside.sure": "Uruchomić kolejnego obok niego?",
-  "ui.run.gate": "· warunek: {name} – pytany przed każdą sesją; może kazać przebiegowi czekać",
   "ui.run.gate.wait": "⏸ oczekiwanie do {at} – {reason} (Ctrl-C kończy przebieg)",
   "ui.run.asleep.wait": "⏸ oczekiwanie do {at} – pozostałe zadania potrzebują {host}, który teraz nie odpowiada (Ctrl-C kończy przebieg)",
   "ui.run.asleep.why": "{host} teraz nie odpowiada",
   "ui.run.stop.gate": "warunek „{name}” powiedział dość – {reason}",
   "ui.run.stop.gate.error": "warunek „{name}” nie odpowiedział, jak powinien – {reason} (strom gate test)",
-  "ui.run.gate.once": "· warunek: {name} – uruchomienie ręczne: gdy warunek nie jest spełniony, jedno pytanie, czy mimo to zacząć",
   "ui.run.gate.anyway": "Warunek „{name}” teraz by nie uruchomił – {reason}. Uruchomić mimo to?",
   "ui.run.gate.anyway.here": "Uruchomić mimo to?",
   "ui.run.gate.later": "jeszcze nie",
   "ui.run.gate.no": "nie",
   "ui.run.gate.noanswer": "nie odpowiedział, jak powinien (strom gate test)",
   "ui.run.stop.gate.declined": "nie uruchomiono – warunek „{name}”: {reason}",
-  "ui.run.gate.cap": "· {name}: ustawiony pułap – sprawdzany przed każdą sesją; żadne „mimo to zacząć” go nie przekroczy",
-  "ui.run.gate.said": "· warunek {name}: {word}{reason} (kod {status}; .strom/gate.log)",
+  "ui.run.gate.said": "· warunek {name}{how}: {word}{reason} (kod {status}; .strom/gate.log)",
+  "ui.run.gate.how.each": " (pytany przed każdą sesją)",
+  "ui.run.gate.how.once": " (uruchomienie ręczne: pytany raz)",
+  "ui.run.gate.how.cap": " (pułap: sprawdzany przed każdą sesją, żadne „mimo to zacząć” go nie przekroczy)",
   "ui.run.stop.gate.cap": "pułap warunku „{name}” – {reason} (sztywna granica z run.gate; „mimo to zacząć” jej nie przekroczy)",
   "ui.run.cap.finish": "⏳ {session}: limit agenta na {used} % ({kind}) – sesja dostała prośbę o zapisanie, co znalazła, i zakończenie; po przekroczeniu pułapu kolejna sesja nie ruszy",
   "ui.run.limit.five_hour": "okno pięciogodzinne",

package/dist/cli/menu.js

@@ -27,7 +27,7 @@ import { taskQueue } from "../commands/tasks.js";
 import { humanTask } from "../commands/browse.js";
 import { loadGate } from "../core/gate.js";
 import { lacksImages } from "../core/queue.js";
-import { historyOn } from "../core/pastevents.js";
+import { forHistory, historyOn } from "../core/pastevents.js";
 import { othersAtWork } from "../core/session.js";
 import { DEFAULT_RUN_MINUTES } from "../core/config.js";
 import { truncate } from "./format.js";
@@ -318,10 +318,11 @@ export async function runMenu(ctx, run) {
                         await pause(lang);
                         return;
                     }
-                    // What comes next, as the agent working alone takes it (a story now and then), without what others hold.
+                    // What comes next, as strom run takes it (commands/session.ts): a story now and then, the tasks of history by
+                    // their pace (the places to map before the research), without what others hold.
                     const fresh = Tree.open(root, ctx.env);
                     const held = othersAtWork(fresh, fresh.env).tasks;
-                    const queue = taskQueue(fresh, { strategy: ctx.settings.strategy(fresh.config), storyTurn: true }).filter((x) => !held.has(x.id));
+                    const queue = taskQueue(fresh, { strategy: ctx.settings.strategy(fresh.config), storyTurn: true, history: true }).filter((x) => !held.has(x.id));
                     const shown = queue.slice(0, RUN_LIST);
                     // The tasks of history alone, in their order whatever its pace (strom run --history): only while it is on.
                     const history = historyOn(fresh, ctx.settings) ? taskQueue(fresh, { strategy: ctx.settings.strategy(fresh.config), history: "only" }).filter((x) => !held.has(x.id)) : [];
@@ -336,7 +337,7 @@ export async function runMenu(ctx, run) {
                     if (shown.length) {
                         out(t("ui.run.next"));
                         for (const [k, x] of shown.entries())
-                            out(`  ${String(k + 1).padStart(2)}. ${truncate(humanTask(fresh, x.what, lang), 100)}${forStory(x) ? t("ui.run.story") : ""}${lacksImages(fresh, x) ? t("ui.plan.images") : ""}`);
+                            out(`  ${String(k + 1).padStart(2)}. ${truncate(humanTask(fresh, x.what, lang), 100)}${forStory(x) ? t("ui.run.story") : forHistory(x) ? t("ui.run.ofhistory") : ""}${lacksImages(fresh, x) ? t("ui.plan.images") : ""}`);
                         if (queue.length > shown.length)
                             out(`      ${t("ui.plan.more", { n: queue.length - shown.length })}`);
                     }

package/dist/cli/ui.js

@@ -591,6 +591,7 @@ export const UI = {
     "ui.run.denied": "  · permissions refused {n}×: {what}",
     "ui.run.refused": "  · strom refused {n}× (its limit of {per, plural, one {# web request} other {# web requests}} to one server in a session, or the server's own): {what}",
     "ui.run.recover": "  · the agent's connection failed ({why}) — its session goes on in {s} s ({n}/{max})",
+    "ui.run.missingtools": "  · Claude Code did not load {tools} — the session may not manage without; with the setting agent.addons on it runs with everything, as before",
     "ui.run.exitOnly": "  · {session}: the agent closed the session, then ended with exit code {code} — taken as done, the run goes on",
     "ui.tree.created": "✓ The family tree \"{name}\" is ready: {dir}",
     "ui.chat.trust": "The first time, Claude Code asks whether this folder is trusted. It is the family tree's folder, made by strom — confirm with \"Yes, proceed\".",
@@ -1991,6 +1992,7 @@ export const UI = {
     "ui.run.skip.held": "  · {task} left out: another agent is working on it",
     "ui.run.next": "Next in the queue, in the order the agent takes them:",
     "ui.run.story": " (a story)",
+    "ui.run.ofhistory": " (history)",
     "ui.run.what": "What should the agent do?",
     "ui.run.queue": "Work through the queue in this order – as many as chosen",
     "ui.run.pick": "Only the tasks picked from the list",
@@ -2005,21 +2007,21 @@ export const UI = {
     "ui.run.beside": "⚠ An agent is already working on its own here (runs: {n}). Another one beside it takes other tasks — the costs add up.",
     "ui.run.beside.sure": "Start another one beside it?",
     "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} — a run started by hand: when the condition is not met, one question whether to start anyway",
     "ui.run.gate.anyway": "The condition “{name}” would not start now — {reason}. Start anyway?",
     "ui.run.gate.anyway.here": "Start anyway?",
     "ui.run.gate.later": "not yet",
     "ui.run.gate.no": "no",
     "ui.run.gate.noanswer": "no proper answer (strom gate test)",
     "ui.run.stop.gate.declined": "not started — the condition “{name}”: {reason}",
-    "ui.run.gate.cap": "· {name}: a cap is set — checked before every session; no “start anyway” goes past it",
-    "ui.run.gate.said": "· condition {name}: {word}{reason} (exit {status}; .strom/gate.log)",
+    "ui.run.gate.said": "· condition {name}{how}: {word}{reason} (exit {status}; .strom/gate.log)",
+    "ui.run.gate.how.each": " (asked before each session)",
+    "ui.run.gate.how.once": " (a run started by hand: asked once)",
+    "ui.run.gate.how.cap": " (a cap: checked before each session, no “start anyway” goes past it)",
     "ui.run.stop.gate.cap": "the cap of the condition “{name}” — {reason} (a hard stop set in run.gate; no “start anyway” goes past it)",
     "ui.run.cap.finish": "⏳ {session}: the agent's limit at {used} % ({kind}) — the session is asked to write down what it found and close; past the cap no next session starts",
     "ui.run.limit.five_hour": "five-hour window",

package/dist/commands/session.js

@@ -896,8 +896,9 @@ register(updatedDuringRun({
             // --task) are their choice: the gate is asked once, and when it would not start, the user decides.
             const gateHolds = Boolean(opts.loop || until);
             let gateAnswered = false;
-            if (gate)
-                out(ui(lang, gateHolds ? "ui.run.gate" : "ui.run.gate.once", { name: gate.manifest.title ?? gate.name }));
+            // how the gate is asked (before each session, once, its cap) is said in its first answer's line, never a line of its own
+            let gateTold = false;
+            let capTold = false;
             // Claude Code of a folder said outright (CLAUDE_CONFIG_DIR, agent.claudeConfigDir) not logged in there: no session
             // would work — said before the first one, with how to log in (found 2026-11-03)
             const loggedOut = runnerId === "claude" && claudeConfigSet(runEnv) !== undefined && claudeLoggedIn(runEnv, runner.command) === false;
@@ -1002,10 +1003,14 @@ register(updatedDuringRun({
                     const name = gate.manifest.title ?? gate.name;
                     // what it answered, in one line (a wait the run keeps to says it in its own line below)
                     const waits = gateHolds && said.verdict === "wait" && !said.hard && !(until && Date.now() + said.waitMs > until);
-                    if (!waits)
-                        out(gateSaid(lang, name, said));
-                    if (said.watch && !watch)
-                        out(ui(lang, "ui.run.gate.cap", { name }));
+                    if (!waits) {
+                        // one line: what it answered, and the first time how it is asked (a cap: when it is first said)
+                        const how = said.watch && !capTold ? "cap" : !gateTold ? (gateHolds ? "each" : "once") : undefined;
+                        out(gateSaid(lang, name, said, how));
+                        gateTold = true;
+                        if (said.watch)
+                            capTold = true;
+                    }
                     watch = said.watch;
                     if (said.hard && said.verdict !== "go") {
                         noted("stop");
@@ -1163,6 +1168,8 @@ register(updatedDuringRun({
                     onProgress: (l) => out(`  · ${l}`),
                     // its connection failed on the way (a passing network error): its session resumed after a wait
                     onRecover: (r) => out(ui(lang, "ui.run.recover", { why: r.why, s: Math.round(r.waitMs / 1000), n: r.n, max: r.max })),
+                    // a tool it asked for and the agent did not load: said in the research language
+                    onMissingTools: (tools) => out(ui(lang, "ui.run.missingtools", { tools: tools.join(", ") })),
                     // its use as it says it, per request where it can: the measure of the reading of scans (core/metrics.ts)
                     ...usageOpt(tree, session.id, {
                         agent: runnerId,
@@ -1413,11 +1420,11 @@ async function runGate(ctx, opts) {
 }
 /** Why the gate would not start, for the user: its own words, else what it answered. */
 /** What the gate answered, in one line of the run's output (the research language): its word, why, its exit status. */
-function gateSaid(lang, name, said) {
+function gateSaid(lang, name, said, how) {
     const word = said.verdict === "wait"
         ? ui(lang, "ui.gate.test.wait", { at: new Date(Date.now() + said.waitMs).toLocaleString(lang, { weekday: "short", hour: "2-digit", minute: "2-digit" }) })
         : ui(lang, said.verdict === "go" ? "ui.gate.test.go" : said.verdict === "stop" ? "ui.gate.test.stop" : "ui.run.gate.noanswer");
-    return ui(lang, "ui.run.gate.said", { name, word, reason: said.reason ? ` — ${said.reason}` : "", status: said.status === undefined || said.status === null ? "–" : String(said.status) });
+    return ui(lang, "ui.run.gate.said", { name, how: how ? ui(lang, `ui.run.gate.how.${how}`) : "", word, reason: said.reason ? ` — ${said.reason}` : "", status: said.status === undefined || said.status === null ? "–" : String(said.status) });
 }
 function gateReason(said, lang) {
     return said.reason ?? ui(lang, said.verdict === "error" ? "ui.run.gate.noanswer" : said.verdict === "wait" ? "ui.run.gate.later" : "ui.run.gate.no");

package/dist/core/live.js

@@ -12,7 +12,11 @@
 //                          Made once for a state of the research on a thread of its own (core/livestatus.ts) and
 //                          answered from it while the state lasts. ?parts=1 (feature status.parts): without the parts
 //                          that weigh (waiting; queue, queueMore, queueCounts; offLine; researches), with parts {name:
-//                          rev} instead — the same rev, the same part.
+//                          rev} instead — the same rev, the same part. Each of working (who is at work; the event
+//                          working too): the place record (L…) of the book the agent examines, when the research knows
+//                          it (place, core/workplace.ts; none: not known) — feature working.place; work on a family
+//                          (a couple's story): the family (family F…) and its husband, else wife, as the person —
+//                          feature working.family.
 //   GET <token>/status/<part>  one of those parts: {part, rev, head, …its fields as /status carries them}; 404
 //                          status.part for another name.
 //                          A queue item off the lines of a research with several (core/offline.ts) says offLine:
@@ -299,6 +303,7 @@
 // new secret. Nothing is replaced on a timer.
 import { browserState, treeBrowserArchives } from "./browserhelp.js";
 import { opsLogsOf } from "./opslog.js";
+import { placeOfWork } from "./workplace.js";
 import { notDownloaded } from "./integrity.js";
 import fs from "node:fs";
 import os from "node:os";
@@ -1122,7 +1127,7 @@ function idsOf(applied, known) {
     return Object.keys(ids.persons).length || Object.keys(ids.sources).length ? { ids } : {};
 }
 /** What the bridge does that an app may ask about (each added once, never taken away). */
-export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes", "hypothesis.links", "status.recent", "spend.readers", "hypothesis.intree", "archive.permission", "task.check", "waiting.groups", "waiting.sent", "waiting.note", "batch.kept", "live.end", "whats.new", "terminal.choice", "person.marriedSurname", "phone", "read.now", "read.sync", "excerpt.get", "log.sources", "material.assign", "material.thumb", "seal.foreign", "tree.state", "disk.full", "tree.notDownloaded", "sync.removed", "tree.kind", "experiments", "experiments.off", "experiments.link", "experiments.split", "history.events", "history.hide", "experiments.pace", "history.first", "history.regions", "history.hide.all", "history.skip", "history.map", "history.delete", "history.delete.restore", "stories.history", "history.place", "surnames.suggest", "surnames.read", "lineage.read", "duplicates.judge", "quality.dismiss", "quality.read", "person.primary", "fixes.list", "fixes.towns", "history.back", "places.identify", "places.answer", "places.undo", "tasks.offLine", "status.busy", "history.kinds", "history.align", "places.nameKinds", "directions.edit", "directions.order", "directions.found", "directions.people", "offLine.branches", "queue.own", "story.sources", "queue.page", "status.parts", "waiting.answer", "browser.state"];
+export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes", "hypothesis.links", "status.recent", "spend.readers", "hypothesis.intree", "archive.permission", "task.check", "waiting.groups", "waiting.sent", "waiting.note", "batch.kept", "live.end", "whats.new", "terminal.choice", "person.marriedSurname", "phone", "read.now", "read.sync", "excerpt.get", "log.sources", "material.assign", "material.thumb", "seal.foreign", "tree.state", "disk.full", "tree.notDownloaded", "sync.removed", "tree.kind", "experiments", "experiments.off", "experiments.link", "experiments.split", "history.events", "history.hide", "experiments.pace", "history.first", "history.regions", "history.hide.all", "history.skip", "history.map", "history.delete", "history.delete.restore", "stories.history", "history.place", "surnames.suggest", "surnames.read", "lineage.read", "duplicates.judge", "quality.dismiss", "quality.read", "person.primary", "fixes.list", "fixes.towns", "history.back", "places.identify", "places.answer", "places.undo", "tasks.offLine", "status.busy", "history.kinds", "history.align", "places.nameKinds", "directions.edit", "directions.order", "directions.found", "directions.people", "offLine.branches", "queue.own", "story.sources", "queue.page", "status.parts", "waiting.answer", "browser.state", "working.place", "working.family"];
 /** /status busy: how many sessions and runs work now. */
 function busyOf(tree) {
     const b = busyIn(tree);
@@ -1337,33 +1342,62 @@ export function whoAtWork(label, lang) {
 }
 /**
  * The person an agent works on, for the app to follow it in the tree: the first person its task is about (a marriage
- * names both, the one it asks about first), else the last one its session wrote about.
+ * names both, the one it asks about first), else the last one its session wrote about. Work on a family (a couple's
+ * story, its marriage — subject F…, or a record of it written last): its first partner as the person, the husband, else
+ * the wife (an app reading only `person` follows the couple so), and the family itself (feature working.family).
  */
-function workedOn(root, tree, s, task) {
-    const known = (id) => /^P\d{1,7}$/.test(id) && tree.get(id) !== undefined;
-    const first = (task?.subject ?? []).find(known);
-    if (first)
-        return { person: first };
+function workedOn(tree, ops, task) {
+    const of = (id) => {
+        if (/^P\d{1,7}$/.test(id))
+            return tree.get(id) !== undefined ? { person: id } : undefined;
+        if (!/^F\d{1,7}$/.test(id))
+            return undefined;
+        const fam = tree.get(id);
+        if (!fam)
+            return undefined;
+        const partners = fam.partners.filter((p) => tree.get(p) !== undefined);
+        const husband = partners.find((p) => tree.get(p)?.sex === "M") ?? partners.find((p) => p === fam.husb) ?? partners[0];
+        return { ...(husband ? { person: husband } : {}), family: id };
+    };
+    for (const id of task?.subject ?? []) {
+        const found = of(id);
+        if (found)
+            return found;
+    }
+    // a record written: its last person, else its family
+    for (let i = ops.length - 1; i >= 0; i--) {
+        const targets = ops[i].targets ?? [];
+        const person = targets.findLast((id) => /^P\d{1,7}$/.test(id) && tree.get(id) !== undefined);
+        if (person)
+            return { person };
+        for (const id of [...targets].reverse()) {
+            const found = of(id);
+            if (found)
+                return found;
+        }
+    }
+    return {};
+}
+/** What a session wrote, in its order (a line being written, or a log not readable: left out). */
+function sessionOps(root, s) {
     let lines = [];
     try {
         lines = opsLogsOf(path.join(root, "data"), s.id).flatMap((file) => fs.readFileSync(file, "utf8").split("\n"));
     }
     catch {
-        return {};
+        return [];
     }
-    for (let i = lines.length - 1; i >= 0; i--) {
-        let op;
+    const ops = [];
+    for (const line of lines) {
         try {
-            op = JSON.parse(lines[i]);
+            if (line.trim())
+                ops.push(JSON.parse(line));
         }
         catch {
-            continue; // empty, or a line being written
+            // a line being written
         }
-        const person = (op.targets ?? []).findLast(known);
-        if (person)
-            return { person };
     }
-    return {};
+    return ops;
 }
 /** Who is at work now, on which task (an agent strom started, and its open session). */
 function working(root, tree, all) {
@@ -1378,11 +1412,16 @@ function working(root, tree, all) {
             who: whoAtWork(w.label, tree.lang),
             since: w.since,
             ...(w.paused ? { paused: w.paused } : {}),
-            ...(s ? { session: s.id, ...(s.task ? { task: task ? taskTitle(tree, task) : s.task } : {}), ...workedOn(root, tree, s, task) } : {}),
+            ...(s ? { session: s.id, ...(s.task ? { task: task ? taskTitle(tree, task) : s.task } : {}), ...worked(tree, sessionOps(root, s), task) } : {}),
             ...(research ? { research } : {}),
         };
     });
 }
+/** The person and the place (L…, core/workplace.ts) an agent works on, from what its session wrote and its task. */
+function worked(tree, ops, task) {
+    const place = placeOfWork(tree, ops, task);
+    return { ...workedOn(tree, ops, task), ...(place ? { place } : {}) };
+}
 /** The direction a session worked on: its own, else its task's. */
 function sessionResearch(tree, s, all) {
     if (s.research)

package/dist/core/tree.js

@@ -31,7 +31,7 @@ export const TREE_FILE = "strom.json";
 export const SEAL_FOREIGN = "seal.foreign";
 // between releases the candidate being made (a bridge run from the sources says what it is: the Strom app goes by it);
 // at a release the release's own (package.json)
-export const VERSION = "1.28.0-beta.1";
+export const VERSION = "1.28.0-beta.3";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/dist/core/workplace.js

@@ -0,0 +1,69 @@
+// Where an agent works now, for the Strom app's map while it follows the work (the bridge's working[].place, feature
+// working.place): the place record (L…) of the book the agent examines — the parish or the village of its records,
+// never an archive. Only what the agent wrote through strom tells it, nothing guessed: the newest record of its work the
+// session wrote (an image fetched, a source, a search, a book) decides alone — its book's place, none when its book is
+// unsure (a search in several books of several places, a source of no book: the web); before any, the books its task
+// names. What it writes of people from a record (a fact, a citation) keeps the place of that record.
+// A book is a place's when the place lists it among its records (strom place jurisdiction --recordset), else when one
+// place record alone bears the name of the first place the book covers. Unsure (no such place, several of one name,
+// the task's books in several places): none — the app shows the person's places then.
+import { foldText } from "./text.js";
+/** The place record (L…) of the book the agent examines now, when the research knows it. */
+export function placeOfWork(tree, ops, task) {
+    // the newest record of its work the session wrote decides alone: its book's place, or none — never an older book's
+    for (let i = ops.length - 1; i >= 0; i--) {
+        const main = ops[i].targets?.[0];
+        if (main && /^[BMSQ]\d+$/.test(main))
+            return placeOfRecord(tree, main);
+    }
+    // nothing written yet: the books its task names, when they are all of one place
+    return placeOfBooks(tree, (task?.where ?? []).map((w) => w.trim()));
+}
+/** The place of the books named, when they are all of one known place. */
+function placeOfBooks(tree, ids) {
+    const books = ids.map((id) => tree.get(id)).filter((b) => b?.type === "recordset" && !b.retracted);
+    const places = new Set(books.map((b) => placeOfBook(tree, b)));
+    return places.size === 1 ? [...places][0] : undefined;
+}
+/** The place of a record of work: of its book, of the books of a search when all of one place; none when unsure. */
+function placeOfRecord(tree, id) {
+    if (/^Q\d+$/.test(id)) {
+        const q = tree.get(id);
+        return q && !q.retracted ? placeOfBooks(tree, q.recordsets) : undefined;
+    }
+    const book = bookOf(tree, id);
+    return book ? placeOfBook(tree, book) : undefined;
+}
+/** The book a record is of: a book itself, an image of it, a source from it. */
+function bookOf(tree, id) {
+    const book = (b) => {
+        const r = b ? tree.get(b) : undefined;
+        return r?.type === "recordset" && !r.retracted ? r : undefined;
+    };
+    if (/^B\d+$/.test(id))
+        return book(id);
+    if (/^M\d+$/.test(id)) {
+        const m = tree.get(id);
+        return m && !m.retracted ? book(m.recordset) : undefined;
+    }
+    if (/^S\d+$/.test(id)) {
+        const s = tree.get(id);
+        if (!s || s.retracted)
+            return undefined;
+        return book(s.recordset) ?? book((s.media ?? []).map((m) => tree.get(m)?.recordset).find(Boolean));
+    }
+    return undefined;
+}
+/** The place record of a book: the one listing it among its records, else the one alone of the name of its first place. */
+function placeOfBook(tree, book) {
+    const places = tree.list("place").filter((p) => !p.retracted);
+    const listing = places.filter((p) => p.jurisdictions.some((j) => (j.recordsets ?? []).includes(book.id)));
+    if (listing.length === 1)
+        return listing[0].id;
+    const first = book.places[0]?.trim();
+    if (!first)
+        return undefined;
+    const name = foldText(first);
+    const named = (listing.length ? listing : places).filter((p) => p.names.some((n) => foldText(n.name) === name));
+    return named.length === 1 ? named[0].id : undefined;
+}

package/dist/runners/claude.js

@@ -56,10 +56,17 @@ export function cleanTools(reader, platform = process.platform) {
 /**
  * The tools a clean session asked for that Claude Code did not load (its init event's list): a newer Claude Code may
  * have renamed one. The subagent tool is listed as Task; PowerShell only where it is on, Bash's place on Windows.
+ * WebFetch: a newer Claude Code (2.1.318, checked 2026-11-05) leaves it out of the session's own tools and reads a page
+ * through its web-fetch agent (init `agents`), whose WebFetch goes through the same permissions and hooks — no loss.
  */
-export function missingTools(asked, loaded) {
+export function missingTools(asked, loaded, agents = []) {
     const has = new Set(loaded);
-    return asked.filter((t) => t !== "PowerShell" && !has.has(t) && !(t === "Agent" && has.has("Task")) && !(t === "Bash" && has.has("PowerShell")));
+    const subagents = has.has("Agent") || has.has("Task");
+    return asked.filter((t) => t !== "PowerShell" &&
+        !has.has(t) &&
+        !(t === "Agent" && has.has("Task")) &&
+        !(t === "Bash" && has.has("PowerShell")) &&
+        !(t === "WebFetch" && subagents && agents.includes("web-fetch")));
 }
 const LIMIT_KINDS = ["five_hour", "seven_day"];
 /**
@@ -298,10 +305,13 @@ function attempt(opts, args, input, timeoutMs, sid) {
             }
             // a tool strom asked for and Claude Code did not load (renamed in a newer version?): said, the session goes on
             if (msg.type === "system" && msg.subtype === "init" && opts.clean && !opts.interactive && Array.isArray(msg.tools)) {
-                const missing = missingTools(cleanTools(opts.reader), msg.tools.map(String));
+                const missing = missingTools(cleanTools(opts.reader), msg.tools.map(String), Array.isArray(msg.agents) ? msg.agents.map(String) : []);
                 if (missing.length) {
                     const said = `Claude Code did not load ${missing.join(", ")} — the session may not manage without; strom config set agent.addons on runs it with everything, as before`;
-                    opts.onProgress?.(said);
+                    if (opts.onMissingTools)
+                        opts.onMissingTools(missing);
+                    else
+                        opts.onProgress?.(said);
                     log.note(`\n[strom] ${said}\n`);
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.28.0-beta.1",
+  "version": "1.28.0-beta.3",
   "stromDoc": "885249f43ea2f346c667b3f0ead9f8bba950f23f",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",