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

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.22.0
 
-*Připravuje se: bety do 1.22.0-beta.3. Oddíl bude úplný s vydáním.*
+*Připravuje se: bety do 1.22.0-beta.5. 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,
@@ -26,6 +26,12 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   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í.
+- **Co předek zažil.** Události v místech stromu – dějiny kraje ze stránek, které strom sám stáhl a ověřil, místní
+  události z přečtených záznamů – ukáže aplikace Strom; úvodní nastavení ho nabízí zapnuté, instalace nastavená dřív
+  zůstává, jak je, samo se nic nezapne. Zapnout ho může jen člověk; dokud je vypnuté, nic se nehledá. Po zapnutí se místa zmapují hned v dalším sezení a regiony se
+  prohledávají průběžně mezi sezeními rodinného výzkumu: zhruba každé 5. sezení (výchozí), každé 10., nebo jen když
+  není co jiného (`strom config set experiments.historyPace`, úvodní nastavení, Nastavení); kdy, řekne `strom plan`.
+  Nejdřív regiony s nejvíc osobami, země před státem nad 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.3. Der Abschnitt ist mit dem Release vollständig.*
+*In Vorbereitung: die Betas bis 1.22.0-beta.5. 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
@@ -30,6 +30,13 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   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.
+- **Was die Vorfahren erlebten.** Die Ereignisse an den Orten des Stammbaums – die Geschichte einer Region aus Seiten,
+  die strom selbst geladen und geprüft hat, örtliche Ereignisse aus gelesenen Einträgen – zeigt die Strom-App. Die
+  Ersteinrichtung schlägt es eingeschaltet vor; eine früher eingerichtete Installation bleibt, wie sie ist, nichts
+  schaltet sich von selbst ein. Einschalten kann es nur ein Mensch; solange es aus ist, wird nichts gesucht. Eingeschaltet, werden die Orte in der nächsten Sitzung zugeordnet und die Regionen ab und zu zwischen den
+  Sitzungen der Familienforschung durchsucht: etwa jede 5. Sitzung (Standard), jede 10. oder nur, wenn nichts anderes
+  ansteht (`strom config set experiments.historyPace`, die Ersteinrichtung, die Einstellungen); wann, sagt `strom plan`.
+  Zuerst die Regionen mit den meisten Personen, ein Land vor dem Staat darüber.
 
 ## 1.21.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.22.0
 
-*In preparation: the betas up to 1.22.0-beta.3. The section is complete with the release.*
+*In preparation: the betas up to 1.22.0-beta.5. 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
@@ -28,6 +28,14 @@ The changes of each version in short. The full notes and the install lines are o
   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.
+- **What the ancestors lived through.** The events at the places of the tree — the history of a region from pages
+  strom downloaded and checked itself, local events from the records read — shown by the Strom app. The first setup
+  suggests it on; an installation set up before stays as it is, nothing turns on by itself. Only a person turns it
+  on; while it is off, nothing is looked for. Once on, the
+  places are mapped in the next session, and the regions are searched now and then between the family research's
+  sessions: about every 5th (the default), every 10th, or only when nothing else is left
+  (`strom config set experiments.historyPace`, the setup, the settings); `strom plan` says when. The regions
+  of the most people come first, a land before the state above it.
 
 ## 1.21.0
 

package/assets/lang/cs.json

@@ -721,6 +721,16 @@
   "archive.held": "odloženo: výzkum je Archiv Stromu (data přicházejí z aplikace Strom); do fronty se vrátí, až se zapne práce s agentem",
   "archive.removed": "odebráno v aplikaci Strom",
   "archive.wait": "Rozhodnutí o stahování z archivu {title}",
+  "history.why.archive": "Dokud je výzkum vedený jako archiv, nic se nehledá.",
+  "history.why.held": "Události regionu {region} hledá jiný výzkum na tomto počítači.",
+  "history.places.what": "Místa údajů pro dějiny předků ({n}): regiony, kam které patřilo, i s roky",
+  "history.places.why": "události dějin (války, epidemie, sčítání lidu, změny státu) se ukazují u míst údajů podle regionů, kam patřila",
+  "history.places.done": "každé místo přiřazené k regionům i s roky, nebo označené jako nedohledané",
+  "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ů",
+  "history.region.done": "důležité události období nalezené, každá ze stránky, kterou strom sám přečetl (nanejvýš asi 60); katalog regionu označený jako hotový",
+  "history.region.finished": "události regionu {region} jsou hotové",
   "review.reread.what": "Přečíst znovu modelem {model}, o co se opírají údaje osoby {name}: {list}{more}",
   "review.reread.why": "tyto zápisy četl jen jiný model; {model} je ten, kterým uživatel čte teď ({research})",
   "review.reread.done": "zápis každého údaje přečtený naslepo modelem {model} (strom read M… --blind): shoda → poznámka u údaje; rozdíl → rozpor s oběma čteními",
@@ -1155,6 +1165,11 @@
   "ui.recent.more": "… a další: {n}",
   "ui.recent.morechanges": "(a další změny: {n})",
   "ui.history.none": "historie je zatím prázdná",
+  "ui.history.past.hidden": "Skryto: {event} – {where}",
+  "ui.history.past.shown": "Znovu zobrazeno: {event} – {where}",
+  "ui.history.past.same": "Beze změny: {event} – {where}",
+  "ui.history.past.first": "Dějiny regionu {region} přijdou na řadu první z regionů, při nejbližším sezení dějin.",
+  "ui.history.past.redo": "Události regionu {region} se budou hledat znovu (nalezené zůstávají).",
   "ui.browse.plan": "Co agent udělá dál",
   "ui.review.new": "{name} — {n, plural, one {# nový úkol} few {# nové úkoly} other {# nových úkolů}}:",
   "ui.review.nothing": "{name} — nic nového k revizi",
@@ -1704,6 +1719,7 @@
   "ui.archives.agentbrowser.off": "Vrátit prohlížeč jen pro archivy přes prohlížeč?",
   "ui.consent.remote": "Spouštět sezení Claude Code, která strom otevírá, se vzdáleným ovládáním (Remote Control), aby je šlo sledovat a řídit z claude.ai nebo z aplikace Claude v telefonu?",
   "ui.consent.addons": "Dovolit agentovi při samostatné práci načíst osobní doplňky z jeho nastavení (skilly, pluginy, MCP servery – třeba i poštu nebo dokumenty) jako v chatu? Pracuje přitom bez dozoru.",
+  "ui.consent.history": "Hledat události dějin v místech všech výzkumů na tomto počítači – války, epidemie, sčítání, změny státu? Agent je hledá průběžně mezi sezeními rodinného výzkumu a stojí to jeho čas i čerpání předplatného.",
   "ui.consent.effort": "Nastavit sezením {agent}, která spouští strom, hloubku uvažování {effort}? Vyšší hloubka uvažování (high, xhigh) rychleji spotřebuje limity předplatného.",
   "ui.consent.webPerHost": "Dovolit vlastnímu webovému nástroji agenta až {n, plural, one {# požadavek} few {# požadavky} other {# požadavků}} na jeden web (jeho servery a zrcadla dohromady) v sezení (nyní {now})? Více požadavků víc zatěžuje web; více stránek jednoho webu je šetrnější stahovat přes konektor.",
   "ui.consent.effort.run": "Spustit samostatnou práci {agent} pro tento běh s hloubkou uvažování {effort}, vyšší než v nastavení ({now})? Vyšší hloubka uvažování (high, xhigh) rychleji spotřebuje limity předplatného.",
@@ -2654,6 +2670,36 @@
   "ui.archives.permissions.title": "Archivy stahovačů na tomto počítači – co platí pro jejich snímky:",
   "ui.archives.state.way": "{way}, rozhodnuto {date}",
   "ui.link.archive.none": "O tomto archivu tu není co rozhodnout. Nic se nestalo.",
+  "ui.experiments.link": "Hledání událostí dějin se zapíná jen v terminálu, který otevře odkaz.",
+  "ui.link.what.experiment.history": "hledat události dějin v místech tohoto stromu – války, epidemie, sčítání, změny státu",
+  "ui.link.experiment.note": "Hledá se průběžně mezi sezeními rodinného výzkumu (jak často, se vybere hned potom), sezení trvá nejvýš {minutes} minut.",
+  "ui.link.experiment.note.gate": "Hledá se průběžně mezi sezeními rodinného výzkumu (jak často, se vybere hned potom); zda sezení začne, rozhoduje brána běhů, sezení trvá nejvýš {minutes} minut.",
+  "ui.history.pace.ask": "Jak často hledat události dějin, když agent pracuje sám?",
+  "ui.history.pace.sometimes": "občas – zhruba každé 5. sezení",
+  "ui.history.pace.rare": "zřídka – zhruba každé 10. sezení",
+  "ui.history.pace.idle": "jen když rodinný výzkum nemá co dělat",
+  "ui.history.pace.default": " (výchozí)",
+  "ui.history.pace.later": "Jak často, jde později změnit: strom config set experiments.historyPace sometimes|rare|idle.",
+  "ui.history.pace.off": "vypnuto – dějiny se nehledají",
+  "ui.setup.history": "Hledat i události dějin v místech předků – války, epidemie, sčítání, změny státu (agent je hledá mezi sezeními rodinného výzkumu)? Jak často:",
+  "ui.alone.history": "Dějiny míst: {state}",
+  "ui.consent.history.pace": "Hledat události dějin častěji – {pace}? Stojí to víc času agenta i čerpání předplatného.",
+  "ui.plan.history": "Dějiny míst: {what} – {when}.",
+  "ui.plan.history.now": "v příštím sezení",
+  "ui.plan.history.places": "příští sezení – nejdřív zmapovat místa",
+  "ui.plan.history.in": "za ~{n} sezení",
+  "ui.plan.history.idle": "až rodinný výzkum nebude mít co dělat",
+  "ui.plan.history.asked": "; přednost: {region}, na přání",
+  "ui.plan.history.order": "Regiony na řadě, po jednom: {list}",
+  "ui.plan.history.weight": "{region} (osob: {n})",
+  "ui.plan.history.prefer": "; přednost: místo {place} z nedávného sezení",
+  "ui.link.experiment.all": "Zapíná se v nastavení tohoto počítače: platí pro všechny výzkumy na něm (každý jde vypnout zvlášť).",
+  "ui.link.experiment.on.done": "Hledání událostí dějin je pro tento výzkum zapnuté.",
+  "ui.link.experiment.on.already": "Hledání událostí dějin je pro tento výzkum zapnuté už. Nic se nestalo.",
+  "ui.link.experiment.off.done": "Hledání událostí dějin je pro tento výzkum vypnuté; co už bylo nalezeno, zůstává.",
+  "ui.link.experiment.off.already": "Hledání událostí dějin je pro tento výzkum vypnuté už. Nic se nestalo.",
+  "ui.link.experiment.archive": "Dokud je výzkum vedený jako archiv, události dějin se nehledají. Nic se nestalo.",
+  "ui.link.experiment.waiting": "Na tomto výzkumu se na tomto počítači nepracuje, a tak se události dějin nehledají. Nic se nestalo.",
   "ui.error.archive.permission": "stahování snímků z archivu {title} ({hosts}) čeká na rozhodnutí – podmínky archivu automatické stahování omezují; z archivu se nic nestahovalo",
   "ui.error.archive.permission.new": "stahování snímků z archivu {title} ({hosts}) čeká na rozhodnutí – čtení podmínek stahovačem zatím nikdo nepotvrdil; z archivu se nic nestahovalo",
   "ui.error.archive.permission.hint": "rozhodnout v menu strom (Co čeká), nebo v terminálu: strom allow archive {host} --way {ways}",

package/assets/lang/de.json

@@ -721,6 +721,16 @@
   "archive.held": "zurückgestellt: die Forschung ist ein Strom-Archiv (die Daten kommen aus der Strom-App); zurück in der Warteschlange, wenn die Arbeit mit einem Agenten eingeschaltet wird",
   "archive.removed": "in der Strom-App entfernt",
   "archive.wait": "Entscheidung über das Herunterladen aus dem Archiv {title}",
+  "history.why.archive": "Solange die Forschung als Archiv geführt wird, wird nichts gesucht.",
+  "history.why.held": "Die Ereignisse von {region} sucht eine andere Forschung auf diesem Computer.",
+  "history.places.what": "Die Orte der Angaben für die Geschichte der Vorfahren ({n}): zu welchen Regionen jeder gehörte, mit den Jahren",
+  "history.places.why": "die Ereignisse der Geschichte (Kriege, Epidemien, Volkszählungen, Wechsel des Staates) erscheinen an den Orten der Angaben nach den Regionen, zu denen sie gehörten",
+  "history.places.done": "jeder Ort seinen Regionen mit den Jahren zugeordnet oder als nicht auffindbar vermerkt",
+  "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",
+  "history.region.done": "die wichtigen Ereignisse des Zeitraums gefunden, jedes von einer Seite, die strom selbst gelesen hat (höchstens etwa 60); der Katalog der Region als fertig vermerkt",
+  "history.region.finished": "die Ereignisse von {region} sind fertig",
   "review.reread.what": "Mit {model} neu lesen, worauf die Angaben von {name} beruhen: {list}{more}",
   "review.reread.why": "diese Einträge hat nur ein anderes Modell gelesen; mit {model} liest der Nutzer jetzt ({research})",
   "review.reread.done": "der Eintrag jeder Angabe blind mit {model} gelesen (strom read M… --blind): übereinstimmend → Notiz an der Angabe; abweichend → ein Widerspruch mit beiden Lesungen",
@@ -1155,6 +1165,11 @@
   "ui.recent.more": "… und {n} weitere",
   "ui.recent.morechanges": "(und weitere Änderungen: {n})",
   "ui.history.none": "der Verlauf ist noch leer",
+  "ui.history.past.hidden": "Ausgeblendet: {event} – {where}",
+  "ui.history.past.shown": "Wieder angezeigt: {event} – {where}",
+  "ui.history.past.same": "Unverändert: {event} – {where}",
+  "ui.history.past.first": "Die Geschichte von {region} kommt als erste der Regionen an die Reihe, bei der nächsten Sitzung der Geschichte.",
+  "ui.history.past.redo": "Die Ereignisse von {region} werden erneut gesucht (die gefundenen bleiben).",
   "ui.browse.plan": "Was der Agent als Nächstes tut",
   "ui.review.new": "{name} — {n, plural, one {# neue Aufgabe} other {# neue Aufgaben}}:",
   "ui.review.nothing": "{name} — nichts Neues zu prüfen",
@@ -1704,6 +1719,7 @@
   "ui.archives.agentbrowser.off": "Zurück zum Browser nur für Archive über den Browser?",
   "ui.consent.remote": "Die Claude-Code-Sitzungen, die strom öffnet, mit Remote Control starten, damit sie sich auf claude.ai oder in der Claude-App auf dem Telefon verfolgen und steuern lassen?",
   "ui.consent.addons": "Dem allein arbeitenden Agenten erlauben, die persönlichen Erweiterungen aus seinen Einstellungen zu laden (Skills, Plugins, MCP-Server – auch E-Mail oder Dokumente), wie im Chat? Er arbeitet dabei unbeaufsichtigt.",
+  "ui.consent.history": "Die Ereignisse der Geschichte an den Orten aller Forschungen auf diesem Computer suchen – Kriege, Epidemien, Volkszählungen, Änderungen des Staates? Der Agent sucht sie ab und zu zwischen den Sitzungen der Familienforschung, und es kostet seine Zeit und die Nutzung des Abos.",
   "ui.consent.effort": "Den Sitzungen von {agent}, die strom startet, den Denkaufwand {effort} geben? Ein höherer Denkaufwand (high, xhigh) verbraucht die Limits des Abonnements schneller.",
   "ui.consent.webPerHost": "Dem eigenen Webabruf des Agenten bis zu {n, plural, one {# Anfrage} other {# Anfragen}} an eine Website (ihre Server und Spiegel zusammen) in einer Sitzung erlauben (jetzt {now})? Mehr Anfragen belasten die Website stärker; mehr Seiten einer Website gehen schonender über einen Connector.",
   "ui.consent.effort.run": "{agent} für diesen Lauf mit dem Denkaufwand {effort} allein arbeiten lassen, höher als in der Einstellung ({now})? Ein höherer Denkaufwand (high, xhigh) verbraucht die Limits des Abonnements schneller.",
@@ -2654,6 +2670,36 @@
   "ui.archives.permissions.title": "Die Archive der Downloader auf diesem Computer – was für ihre Bilder gilt:",
   "ui.archives.state.way": "{way}, entschieden am {date}",
   "ui.link.archive.none": "Über dieses Archiv gibt es hier nichts zu entscheiden. Es ist nichts geschehen.",
+  "ui.experiments.link": "Die Suche nach den Ereignissen der Geschichte wird nur im Terminal eingeschaltet, das der Link öffnet.",
+  "ui.link.what.experiment.history": "die Ereignisse der Geschichte an den Orten dieses Stammbaums suchen – Kriege, Epidemien, Volkszählungen, Änderungen des Staates",
+  "ui.link.experiment.note": "Gesucht wird ab und zu zwischen den Sitzungen der Familienforschung (wie oft, wird gleich danach gewählt), eine Sitzung dauert höchstens {minutes} Minuten.",
+  "ui.link.experiment.note.gate": "Gesucht wird ab und zu zwischen den Sitzungen der Familienforschung (wie oft, wird gleich danach gewählt); ob eine Sitzung beginnt, entscheidet das Tor der Läufe, eine Sitzung dauert höchstens {minutes} Minuten.",
+  "ui.history.pace.ask": "Wie oft nach den Ereignissen der Geschichte suchen, wenn der Agent allein arbeitet?",
+  "ui.history.pace.sometimes": "gelegentlich – etwa jede 5. Sitzung",
+  "ui.history.pace.rare": "selten – etwa jede 10. Sitzung",
+  "ui.history.pace.idle": "nur wenn die Familienforschung nichts zu tun hat",
+  "ui.history.pace.default": " (Standard)",
+  "ui.history.pace.later": "Wie oft, lässt sich später ändern: strom config set experiments.historyPace sometimes|rare|idle.",
+  "ui.history.pace.off": "aus – keine Geschichte gesucht",
+  "ui.setup.history": "Auch die Ereignisse der Geschichte an den Orten der Vorfahren suchen – Kriege, Epidemien, Volkszählungen, Änderungen des Staates (der Agent sucht sie zwischen den Sitzungen der Familienforschung)? Wie oft:",
+  "ui.alone.history": "Geschichte der Orte: {state}",
+  "ui.consent.history.pace": "Öfter nach den Ereignissen der Geschichte suchen – {pace}? Das kostet mehr Zeit des Agenten und mehr von der Nutzung des Abos.",
+  "ui.plan.history": "Geschichte der Orte: {what} – {when}.",
+  "ui.plan.history.now": "in der nächsten Sitzung",
+  "ui.plan.history.places": "nächste Sitzung – zuerst die Orte zuordnen",
+  "ui.plan.history.in": "in ~{n} Sitzungen",
+  "ui.plan.history.idle": "wenn die Familienforschung nichts zu tun hat",
+  "ui.plan.history.asked": "; zuerst: {region}, auf Bitte",
+  "ui.plan.history.order": "Regionen der Reihe nach, eine nach der anderen: {list}",
+  "ui.plan.history.weight": "{region} (Personen: {n})",
+  "ui.plan.history.prefer": "; zuerst: der Ort {place} aus einer kürzlichen Sitzung",
+  "ui.link.experiment.all": "Es wird in den Einstellungen dieses Computers eingeschaltet: für alle Forschungen darauf (jede lässt sich einzeln ausschalten).",
+  "ui.link.experiment.on.done": "Die Suche nach den Ereignissen der Geschichte ist für diese Forschung eingeschaltet.",
+  "ui.link.experiment.on.already": "Die Suche nach den Ereignissen der Geschichte ist für diese Forschung schon eingeschaltet. Es ist nichts geschehen.",
+  "ui.link.experiment.off.done": "Die Suche nach den Ereignissen der Geschichte ist für diese Forschung ausgeschaltet; was gefunden wurde, bleibt.",
+  "ui.link.experiment.off.already": "Die Suche nach den Ereignissen der Geschichte ist für diese Forschung schon ausgeschaltet. Es ist nichts geschehen.",
+  "ui.link.experiment.archive": "Solange die Forschung als Archiv geführt wird, wird nach Ereignissen der Geschichte nicht gesucht. Es ist nichts geschehen.",
+  "ui.link.experiment.waiting": "An dieser Forschung wird auf diesem Computer nicht gearbeitet, daher wird nach Ereignissen der Geschichte nicht gesucht. Es ist nichts geschehen.",
   "ui.error.archive.permission": "das Herunterladen von Bildern aus dem Archiv {title} ({hosts}) wartet auf eine Entscheidung – seine Bedingungen schränken das automatische Herunterladen ein; beim Archiv wurde nichts angefragt",
   "ui.error.archive.permission.new": "das Herunterladen von Bildern aus dem Archiv {title} ({hosts}) wartet auf eine Entscheidung – die Lesart der Bedingungen durch den Downloader hat noch niemand bestätigt; beim Archiv wurde nichts angefragt",
   "ui.error.archive.permission.hint": "im Menü von strom entscheiden (Was wartet) oder im Terminal: strom allow archive {host} --way {ways}",

package/dist/brief/brief.js

@@ -31,6 +31,8 @@ import { hypothesisPeople } from "../core/directions.js";
 import { imagesIndex, weakScans } from "../core/mediaindex.js";
 import { SHARPER_SCAN } from "../core/views.js";
 import { HYPOTHESIS_LINKS_ORIGIN, recordedLinks, recordedText } from "../core/hypolinks.js";
+import { forHistory, historyOn } from "../core/pastevents.js";
+import { HISTORY_WEB_RULE, historySections, localEventsSection } from "./history.js";
 export { DEFAULT_BUDGET } from "../core/config.js";
 import { DEFAULT_BUDGET, Settings } from "../core/config.js";
 import { bookTuned, hostTuned, readingOf, treeTuning, tuningOn } from "../core/tune.js";
@@ -873,7 +875,7 @@ export function buildBrief(tree, opts) {
                 ? `Working alone (strom run): nobody answers here, but the user may read this session afterwards (the run's output, its log) — every message of yours, the last one too, in ${langName(lang)}, about the work and never addressed to the user ("waits for a check", never "waits for you"); a step only the user can take goes into strom task wait.`
                 : "",
             STROM_ONLY,
-            webRule(new Settings(tree.env, {}).webPerHost(tree.config)),
+            task && forHistory(task) ? HISTORY_WEB_RULE : webRule(new Settings(tree.env, {}).webPerHost(tree.config)),
             opts.deadline !== undefined ? briefClock(opts.deadline) : "",
         ].filter(Boolean).join("\n"),
     });
@@ -904,6 +906,10 @@ export function buildBrief(tree, opts) {
                 ...filesCame(task),
             ].filter(Boolean).join("\n"),
         });
+        // a task of history (the experiment): its own sections, nothing of the records, the method or the queue
+        const history = forHistory(task) ? historySections(tree, task, opts.shared, alone) : undefined;
+        if (history)
+            return assemble([...sections, ...history], budget);
         // 2. a review: what each item of the task is, as the tree has it
         if (task.origin.startsWith("review:") && task.where.length)
             sections.push({ name: "review", required: true, pointer: `strom task show ${task.id}`, text: ["## To review", ...reviewItems(tree, task)].join("\n") });
@@ -1245,6 +1251,12 @@ export function buildBrief(tree, opts) {
     // a task that links hypotheses reads no records: the parts of the method and the commands it uses, whatever its level
     const kind = linking ? METHOD_LINKS : task?.level;
     sections.push({ name: "method", first: true, pointer: "strom guide", text: methodFor(kind, conditions) });
+    // 8'. the experiment of history on: a session that reads records may write a local event they tell of
+    if (task && ["link", "verify", "intake", "enrich"].includes(kind ?? "") && historyOn(tree)) {
+        const local = localEventsSection();
+        if (local)
+            sections.push(local);
+    }
     // 8 bis. the search beyond the registers: its budget of pages, printed pages for the user's model for print where the
     // agent hands work to another model, and what the research has written of the person's places already
     if (task?.origin === STORY_SOURCES_ORIGIN) {
@@ -1327,6 +1339,12 @@ export function buildBrief(tree, opts) {
             "- a command you need: strom help <command> (short, with examples) — the full guide: strom guide",
         ].filter(Boolean).join("\n"),
     });
+    return assemble(sections, budget);
+}
+/**
+ * The brief within its budget, from its sections in order.
+ */
+function assemble(sections, budget) {
     // Assemble within the budget: required sections always, then the first ones whole when they fit, then the others in
     // order — those in parts in short —, a first one that did not fit whole cut after them, and last the parts given in
     // short made whole while they fit (UPGRADES); each written where it stands. Everything written counts: the blank line

package/dist/brief/history.js

@@ -0,0 +1,234 @@
+// The brief of a session on the history of the places (the experiment experiments.history, core/pastevents.ts): a
+// region's events looked for on the web, or the places of the facts mapped to regions — and, in a session that reads
+// records, one line on the local events read in them. Only a brief of such a session speaks of it: the commands are
+// behind the experiment's gate (hidden), the guide, help and strom commands say nothing of them.
+import { langName } from "../core/lang.js";
+import { foldText } from "../core/text.js";
+import { match } from "../cli/registry.js";
+import { synopsis } from "./sheet.js";
+import { catalogIds, EVENT_KINDS, HISTORY_PLACES_ORIGIN, HOLD_DAYS, readCatalog, readHidden, readPlaces, coveredBy, regionName, regionOfTask, regionPeriod, REGION_LANGS, unmappedPlaces, } from "../core/pastevents.js";
+import { factPlaces } from "../gedcom/export.js";
+/** About so many events a region at most: rather fewer. */
+export const REGION_DENSITY = 60;
+/** So many events written already, listed in the brief (the rest: strom history status). */
+const EVENTS_SHOWN = 120;
+/** So many places waiting, listed. */
+const PLACES_SHOWN = 80;
+const TEXT_SHOWN = 90;
+/** One command line from the registry (every option and its value), or nothing when it is not registered. */
+function cmd(words) {
+    const m = match(words);
+    return m && m.used === words.length ? `  ${synopsis(m.def)}` : undefined;
+}
+function short(text, max = TEXT_SHOWN) {
+    const chars = [...text];
+    return chars.length > max ? `${chars.slice(0, max - 1).join("")}…` : text;
+}
+function years(from, to) {
+    return from === to ? String(from) : `${from}–${to}`;
+}
+/** The web's rule of the brief's head in a session of history (in place of brief.ts webRule: no connector here). */
+export const HISTORY_WEB_RULE = "Search the web freely; read each page through strom history page <url> (below), never the web fetch tool — no connector and no task in this session.";
+const NOTHING_ELSE = "Nothing of it goes into the tree's records or the GEDCOM: no person, fact, source or search is written in this session.";
+const ONLY_FROM_PAGES = [
+    "- the source of each event: a page strom reads itself — strom history add downloads it, finds the quote on it (word for word, a part left out as …, the year in it) and refuses otherwise; strom checks every page, the person is asked nothing",
+    "- find pages with your own web search; read each page with strom history page <url> (--find \"<words>\": only the passages with them; --page <n>: its next part) and quote the words it prints — never the web fetch tool (WebFetch) for a page: it gives a model's summary, its words are not the page's, and the page would be read twice; strom history add checks the quote on the same read, one request a page",
+    "- a period: --from and --to as the page says them; the page says its end apart: a second --quote with that year (each ≤ 300 characters) — never a period shortened to fit one quote",
+    "- prefer encyclopedias, state institutions, archives and the Wikipedia in the region's language with its references; a page strom cannot read (refused, a bot check, a PDF, a page made by a script, one that sends to a consent or login page of another site): another source, or the event left out — never ask the person, never strom allow, never a browser for it",
+    "- this session writes events of history alone: no task (strom task add is refused here), no connector, nothing for the family research — many pages of one site go through strom history page, never a connector",
+];
+/**
+ * The sections of a session on a task of history, after its header and its task: what it is for, what was found
+ * already, the commands and how to finish. Undefined for any other task.
+ */
+export function historySections(tree, task, shared, alone) {
+    const region = regionOfTask(task);
+    if (region)
+        return regionSections(tree, region, shared, alone);
+    if (task.origin === HISTORY_PLACES_ORIGIN)
+        return placesSections(tree, shared, alone);
+    return undefined;
+}
+function closing(alone, lang, lines) {
+    return {
+        name: "closing",
+        required: true,
+        pointer: "",
+        text: [
+            "## Finishing",
+            ...lines,
+            alone
+                ? `- the summary: plain words for the record (the menu, the Strom app), in ${langName(lang)}, never addressed to the user, no advice; after strom session close you are done: a last message of one line at most`
+                : "- the user reads the summary (the menu, the Strom app): plain words, never addressed to them",
+        ].join("\n"),
+    };
+}
+function regionSections(tree, region, shared, alone) {
+    const lang = tree.lang;
+    const c = shared ? readCatalog(shared, region) : undefined;
+    const name = regionName(c, lang, region);
+    const period = regionPeriod(tree, region);
+    const events = c?.events ?? [];
+    const live = events.filter((e) => !e.retracted);
+    // what the person hid in this tree: by event, and by kind (fewer of those kinds)
+    const hides = readHidden(tree);
+    const hiddenOf = new Map();
+    for (const h of hides)
+        hiddenOf.set(h.event, (hiddenOf.get(h.event) ?? 0) + 1);
+    const byKind = new Map();
+    for (const e of events)
+        if (hiddenOf.has(e.id))
+            byKind.set(e.kind, (byKind.get(e.kind) ?? 0) + hiddenOf.get(e.id));
+    const room = Math.max(0, REGION_DENSITY - live.length);
+    const out = [];
+    out.push({
+        name: "history",
+        required: true,
+        pointer: "strom history status",
+        text: [
+            `## The history of ${name} (${region}) — for the Strom app`,
+            "What the ancestors lived through: the events of this region's history, shown in the Strom app with the lives of the people of its places. " + NOTHING_ELSE,
+            `- period: ${period.from}–${period.to} — this tree's places only (the oldest year of their facts in the region, never before 1600, to this year); another tree sharing the region adds its own years when it takes it`,
+            period.places.length
+                ? `- this tree's places in it: ${period.places.map((p) => `${p.place}${p.from !== undefined || p.to !== undefined ? ` (${p.from ?? "…"}–${p.to ?? "…"})` : ""}${p.years.length ? ` facts ${years(Math.min(...p.years), Math.max(...p.years))}` : ""}`).join(" · ")}`
+                : "",
+            `- how many: at most about ${REGION_DENSITY} events for the region, rather fewer (${live.length} written${room ? `, room for about ${room} more` : ": enough — only what is missing badly"}) — those that shaped the lives of ordinary people there: wars and their levies, epidemics, famines, censuses, changes of the state and its borders, waves of emigration, laws on serfdom, land, schools, religion, great disasters; no lists of rulers, no battles far away, no happening of one village`,
+            `- kinds: ${EVENT_KINDS.join(", ")}`,
+            `- each event: its years (the day only when sure: --date); its texts in ${REGION_LANGS.join(", ")}, each ≤ 300 characters — factual and impersonal: what happened, where, how many; never addressed to anyone, never what to do, never speaking as yourself; --why-*: why it mattered for the people of the place; --tip-*: where a research may look because of it (a kind of record, an archive's series), impersonal too`,
+            "- a hard event (persecution, deportation, expulsion, famine, a pogrom): --sensitive; sober and factual, no judgement, no words of horror, and never a guess about the people of this tree — whom it touched is the reader's to see",
+            ...ONLY_FROM_PAGES,
+            "- the same event again (one more source): --same-as <event>; the same kind and years yet another event: --distinct \"<why>\"; a better one in the place of one written: --replaces <event> (what the person hid holds on it); one that was wrong: strom history retract <event> --why \"…\"",
+        ].filter(Boolean).join("\n"),
+    });
+    const kinds = [...byKind.entries()].sort((a, b) => b[1] - a[1]);
+    out.push({
+        name: "events",
+        first: true,
+        pointer: "strom history status --app --json",
+        text: [
+            `## Events of ${region} written already (${live.length}${events.length > live.length ? `, ${events.length - live.length} taken back` : ""}) — never one again; another source of one: --same-as`,
+            ...(events.length
+                ? events.slice(0, EVENTS_SHOWN).map((e) => {
+                    const marks = [e.retracted ? `taken back: ${short(e.retracted.why || "–", 60)}${e.retracted.replacedBy ? ` → ${e.retracted.replacedBy}` : ""}` : "", hiddenOf.has(e.id) ? `hidden here ${hiddenOf.get(e.id)}×` : "", e.sensitive ? "sensitive" : ""].filter(Boolean);
+                    return `  ${e.id} ${years(e.from, e.to)} ${e.kind} "${short(e.text[lang] ?? e.text.en ?? Object.values(e.text)[0] ?? "")}"${marks.length ? ` [${marks.join(" · ")}]` : ""}`;
+                })
+                : ["  none yet"]),
+            events.length > EVENTS_SHOWN ? `  … ${events.length - EVENTS_SHOWN} more: strom history status --app --json` : "",
+            kinds.length ? `Hidden by the person in this tree, by kind: ${kinds.map(([k, n]) => `${k} ${n}`).join(" · ")} — fewer events of those kinds` : "Hidden by the person in this tree: none",
+            c?.tried.length ? `Pages strom could not read (never tried again): ${c.tried.slice(-20).map((t) => `${t.url} (${short(t.why, 40)})`).join(" · ")}` : "",
+        ].filter(Boolean).join("\n"),
+    });
+    // a state whose lands are done: their catalogs hold its events for these places and years — only what they lack
+    const cover = coveredBy(tree, shared, region);
+    if (cover.length) {
+        const theirs = cover.flatMap((id) => (shared ? (readCatalog(shared, id)?.events ?? []) : []).filter((e) => !e.retracted && e.to >= period.from).map((e) => ({ id, e })));
+        out.push({
+            name: "covered",
+            first: true,
+            pointer: "strom history status --app --json",
+            text: [
+                `## Found already for the same places and years: ${cover.join(", ")} (finished, ${theirs.length} events) — the Strom app shows them at these places`,
+                "- write only what they lack: an event of the whole state they do not have; one of them again is never written (not even with --same-as)",
+                `- they lack nothing worth writing: strom history done ${region} at once, no page read`,
+                ...theirs.slice(0, EVENTS_SHOWN).map(({ e }) => `  ${e.id} ${years(e.from, e.to)} ${e.kind} "${short(e.text[lang] ?? e.text.en ?? Object.values(e.text)[0] ?? "")}"`),
+                theirs.length > EVENTS_SHOWN ? `  … ${theirs.length - EVENTS_SHOWN} more: strom history status --app --json` : "",
+            ].filter(Boolean).join("\n"),
+        });
+    }
+    const commands = [cmd(["history", "page"]), cmd(["history", "add"]), cmd(["history", "retract"]), cmd(["history", "status"]), cmd(["history", "done"])].filter(Boolean);
+    if (commands.length)
+        out.push({ name: "commands", first: true, pointer: "strom help history add", text: ["## Commands (each option as it is)", ...commands].join("\n") });
+    out.push(closing(alone, lang, [
+        `- the events of the period found (or nothing more worth writing): strom history done ${region}, then strom session close --done "how many events, of which kinds, from which sources" --next "…"`,
+        `- time up before: strom session close --continue --summary "…" --next "the kinds or years not looked at yet" (the region stays this tree's for ${HOLD_DAYS} days)`,
+        `- nothing could be found or read at all: strom session close --continue --summary "what was tried" --next "…"`,
+    ]));
+    return out;
+}
+function placesSections(tree, shared, alone) {
+    const lang = tree.lang;
+    const facts = factPlaces(tree);
+    const pending = unmappedPlaces(tree);
+    const records = tree.list("place").filter((p) => !p.retracted);
+    const byName = (key) => {
+        const f = foldText(key);
+        const first = foldText(key.split(",")[0].trim());
+        return records.find((p) => p.names.some((n) => foldText(n.name) === f)) ?? records.find((p) => p.names.some((n) => foldText(n.name) === first));
+    };
+    const placeLine = (key) => {
+        const ys = facts.get(key) ?? [];
+        const p = byName(key);
+        const parent = p?.parent ? tree.get(p.parent) : undefined;
+        const bits = [
+            ys.length ? `facts ${years(Math.min(...ys), Math.max(...ys))}` : "facts undated",
+            p ? `${p.id}${p.kind ? ` ${p.kind}` : ""}: ${p.names.map((n) => `${n.name}${n.lang ? ` (${n.lang})` : ""}${n.from || n.to ? ` ${n.from ?? "…"}–${n.to ?? "…"}` : ""}`).join(", ")}` : "",
+            parent ? `in ${parent.id} ${parent.names[0]?.name ?? ""}` : "",
+            p?.jurisdictions.length ? p.jurisdictions.map((j) => `${j.kind} ${j.name}`).join(", ") : "",
+            p?.coords ? `${p.coords.lat.toFixed(3)}, ${p.coords.lon.toFixed(3)}` : "",
+        ].filter(Boolean);
+        return `  "${key}" — ${bits.join(" · ")}`;
+    };
+    const maps = readPlaces(tree);
+    const mapped = Object.keys(maps).length;
+    const regions = shared ? catalogIds(shared).map((id) => readCatalog(shared, id)).filter((c) => !!c) : [];
+    const out = [
+        {
+            name: "history",
+            required: true,
+            pointer: "strom history status",
+            text: [
+                "## The places of the facts on the map of history — for the Strom app",
+                "Each place of the tree's facts gets the regions it belonged to, with the years: the historical land or province and the state whose history its people lived through (a land of a crown, then the state after it). The events are looked for later, region by region. " + NOTHING_ELSE,
+                "- a region's ID: a–z, 0–9 and hyphens, at most 24, the country's code first; a region that exists (below) is used again whenever it is the same unit; a new one gets its names in cs, en and de (strom history region)",
+                "- the years each place belonged to a region: --region <id>:<from>-<to> (an open end allowed); a place in two units at once (a land and its state): both",
+                "- a place that cannot be identified surely (several of that name, no parish or district to tell them apart): --unlocated --why \"…\" — a wrong region is worse than none",
+                "- other names of the place (another language, a historical name): --also",
+                "- what the tree knows of each place is below (the place records, their parents and jurisdictions); a reference work may be read on the web for it (strom history page <url>), nothing of it is written into the tree",
+            ].join("\n"),
+        },
+        {
+            name: "places",
+            first: true,
+            pointer: "strom history status",
+            text: [
+                `## Places waiting (${pending.length}; ${mapped} mapped already)`,
+                ...(pending.length ? pending.slice(0, PLACES_SHOWN).map(placeLine) : ["  none: every place is mapped"]),
+                pending.length > PLACES_SHOWN ? `  … ${pending.length - PLACES_SHOWN} more: strom history status` : "",
+            ].filter(Boolean).join("\n"),
+        },
+        {
+            name: "regions",
+            first: true,
+            pointer: "strom history status",
+            text: [
+                `## Regions that exist (${regions.length}) — the same unit: its ID again`,
+                ...(regions.length
+                    ? regions.map((c) => `  ${c.region.id} — ${REGION_LANGS.map((l) => c.region.name[l]).filter(Boolean).join(" / ") || regionName(c, lang)}${c.done ? " (finished)" : ""}`)
+                    : ["  none yet"]),
+            ].join("\n"),
+        },
+    ];
+    const commands = [cmd(["history", "map"]), cmd(["history", "region"]), cmd(["history", "page"]), cmd(["history", "status"])].filter(Boolean);
+    if (commands.length)
+        out.push({ name: "commands", first: true, pointer: "strom help history map", text: ["## Commands (each option as it is)", ...commands].join("\n") });
+    out.push(closing(alone, lang, [
+        `- every place mapped or marked not located: strom session close --done "how many places, to which regions, how many not located" --next "…"`,
+        `- time up before: strom session close --continue --summary "…" --next "the places left"`,
+    ]));
+    return out;
+}
+/** One short section for a session that reads records while the experiment is on: a local event read in them. */
+export function localEventsSection() {
+    const line = cmd(["history", "local"]);
+    if (!line)
+        return undefined;
+    return {
+        name: "local events",
+        pointer: "strom help history local",
+        text: [
+            "## Local events",
+            "- an event of the place a source read in this session tells of (a fire, a flood, an epidemic, soldiers quartered — the priest's note in a register): written once, as the source says it, never guessed",
+            line,
+        ].join("\n"),
+    };
+}

package/dist/cli/menu-links.js

@@ -12,6 +12,8 @@ import { lines, truncate } from "./format.js";
 import { isArchive } from "../core/mode.js";
 import { actsAsArchive, kindOf } from "../core/state.js";
 import { Tree } from "../core/tree.js";
+import { DEFAULT_RUN_MINUTES } from "../core/config.js";
+import { choosePace } from "../commands/setup.js";
 import { costPartial, monthSpend, sessionCost } from "../core/session.js";
 import { adoptAskedSince, adoptFailedSince, adoptedAt, adoptionNeverCame, awaitAdoption, nothingSince, removedByItsDecision, SYNC_INBOX, undoSync, withoutImages } from "../core/sync.js";
 import { moveToTrash } from "../core/trash.js";
@@ -180,6 +182,44 @@ export async function archiveAsked(ctx, run, lang, root, host) {
         return stop(ctx, t("ui.link.archive.none"));
     return decideArchive(ctx, run, lang, root, host, q, q?.archiveHosts);
 }
+/**
+ * An experiment of the research turned on or off from the Strom app (strom-research://experiment&name=history): on is
+ * asked once — what it does, how long, and that it is this computer's setting for every research on it when that
+ * changes — then this computer's setting on and the research's own off taken away; off is the research's at once.
+ */
+export async function experimentDo(ctx, run, lang, root, what) {
+    const t = translator(lang);
+    const tree = Tree.open(root, ctx.env);
+    const treeOff = tree.config.experimentsHistory === "off";
+    if (what === "off") {
+        if (treeOff)
+            return stop(ctx, t("ui.link.experiment.off.already"));
+        if ((await run(["config", "set", "experiments.history", "off", "--for-tree"], true)) !== 0)
+            return false;
+        out(ctx, t("ui.link.experiment.off.done"));
+        return true;
+    }
+    // this computer's setting (the user's config): on for every research here unless one turned it off
+    const userOn = ctx.settings.experimentsHistory(undefined);
+    if (userOn && !treeOff)
+        return stop(ctx, t("ui.link.experiment.on.already"));
+    const minutes = ctx.settings.number("run.minutes", tree.config, DEFAULT_RUN_MINUTES);
+    const note = lines(t(ctx.settings.runGate() ? "ui.link.experiment.note.gate" : "ui.link.experiment.note", { minutes }), userOn ? undefined : t("ui.link.experiment.all"));
+    if (!(await asks(ctx, lang, root, t("ui.link.what.experiment.history"), note, false)))
+        return false;
+    // how often, asked once it is on for this computer (the pace chosen before suggested): this computer's too
+    if (!userOn) {
+        const pace = (await choosePace(ctx, ctx.settings.historyPace(undefined))) ?? ctx.settings.historyPace(undefined);
+        if ((await run(["config", "set", "experiments.historyPace", pace], true)) !== 0)
+            return false;
+    }
+    if (!userOn && (await run(["config", "set", "experiments.history", "on"], true)) !== 0)
+        return false;
+    if (treeOff && (await run(["config", "unset", "experiments.history", "--for-tree"], true)) !== 0)
+        return false;
+    out(ctx, t("ui.link.experiment.on.done"));
+    return true;
+}
 /** A direction of the research paused, ended (each with the person's reason, if they give one) or taken up again. */
 export async function directionDo(ctx, run, lang, root, id, what) {
     const t = translator(lang);

package/dist/cli/menu-settings.js

@@ -11,6 +11,7 @@ import { Tree, VERSION } from "../core/tree.js";
 import { replacedOnDisk } from "../core/self.js";
 import { modelStep, shortcutName } from "./wizard.js";
 import { DEFAULT_RUN_MINUTES } from "../core/config.js";
+import { chooseHistory, historySuggested } from "../commands/setup.js";
 import { askGate, ensureGatesDir, listGates, loadGate } from "../core/gate.js";
 import { ensureHooksDir, hooksDir, listHooks } from "../core/hooks.js";
 import { byHandOnly, listConnectors, routeOf, routesOf } from "../core/connector.js";
@@ -365,6 +366,18 @@ async function alone(ctx, run, lang, root) {
                 },
             });
         }
+        // the experiment of history: how often between the family research's sessions, or off — the person's choice here
+        // (before the test of a gate, which shows only with one set: the numbers never move)
+        const history = ctx.settings.experimentsHistory(undefined);
+        items.push({
+            key: "5",
+            label: t("ui.alone.history", { state: history ? t(`ui.history.pace.${ctx.settings.historyPace(undefined)}`) : t("ui.settings.off") }),
+            act: async () => {
+                const h = await chooseHistory(ctx, t("ui.setup.history"), historySuggested(ctx), { back: t("ui.browse.back") });
+                if (h)
+                    await applyHistory(ctx, run, h);
+            },
+        });
         if (set && shared)
             items.push({
                 key: "3",
@@ -390,6 +403,22 @@ async function alone(ctx, run, lang, root) {
         return { title: t("ui.alone.title"), items };
     });
 }
+/**
+ * History on at the pace chosen, or off (the settings): through strom config set, as the person would type it — the
+ * pace first, so turning it on asks nothing more.
+ */
+async function applyHistory(ctx, run, choice) {
+    const on = ctx.settings.experimentsHistory(undefined);
+    if (choice === "off") {
+        if (on)
+            await run(["config", "set", "experiments.history", "off"], true);
+        return;
+    }
+    if (choice !== ctx.settings.historyPace(undefined) || ctx.settings.config.experimentsHistoryPace === undefined)
+        await run(["config", "set", "experiments.historyPace", choice], true);
+    if (!on)
+        await run(["config", "set", "experiments.history", "on"], true);
+}
 /** The gate's name in "claude-usage 10". */
 function loadGateName(spec) {
     return spec.trim().split(/\s+/u)[0] ?? "";