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

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.4. 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,9 @@ 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í.
+- **Experiment: co předek zažil.** Pokusné a ve výchozím stavu vypnuté: 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. Zapnout ho
+  může jen člověk; dokud je vypnuté, nic se nehledá.
 
 ## 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.4. 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,10 @@ 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.
+- **Ein Experiment: was die Vorfahren erlebten.** Experimentell und standardmäßig aus: 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. Einschalten kann es nur ein Mensch; solange es aus ist, wird nichts
+  gesucht.
 
 ## 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.4. 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,9 @@ 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.
+- **An experiment: what the ancestors lived through.** Experimental and off by default: 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. Only a person turns it on; while it is off, nothing is looked for.
 
 ## 1.21.0
 

package/assets/lang/cs.json

@@ -544,6 +544,7 @@
   "ui.run.stop.user": "zastaveno ručně",
   "ui.run.stop.time": "časový limit",
   "ui.run.stop.empty": "žádné otevřené úkoly",
+  "ui.run.stop.history": "dějiny míst počkají do zítřka: bez podmínky (run.gate) jedno sezení denně, nic jiného k práci",
   "ui.run.stop.asleep": "do {at} není co dělat – zbylé úkoly potřebují {host}, který teď neodpovídá",
   "ui.run.stop.problems": "doklady mají problém – strom check",
   "ui.run.stop.denied": "agent nesměl spouštět strom – nepustila ho jeho oprávnění nebo sandbox; nic dalšího se nespustilo",
@@ -721,6 +722,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 – pokus",
+  "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ů – pokus",
+  "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 +1166,10 @@
   "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.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? Experiment: agent je hledá, jen když rodinný výzkum nemá co dělat, 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,17 @@
   "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": "Experiment: hledá se jen tehdy, když rodinný výzkum nemá co dělat, nejvýš jedno sezení denně do {minutes} minut.",
+  "ui.link.experiment.note.gate": "Experiment: hledá se jen tehdy, když rodinný výzkum nemá co dělat; kdy, rozhoduje brána běhů, sezení trvá nejvýš {minutes} minut.",
+  "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

@@ -544,6 +544,7 @@
   "ui.run.stop.user": "von Hand angehalten",
   "ui.run.stop.time": "Zeitlimit",
   "ui.run.stop.empty": "keine offenen Aufgaben",
+  "ui.run.stop.history": "die Geschichte der Orte wartet bis morgen: ohne Bedingung (run.gate) eine Sitzung am Tag, sonst nichts zu tun",
   "ui.run.stop.asleep": "bis {at} nichts zu tun – die übrigen Aufgaben brauchen {host}, der gerade nicht antwortet",
   "ui.run.stop.problems": "die Belege haben Probleme – strom check",
   "ui.run.stop.denied": "der Agent durfte strom nicht starten – seine Berechtigungen oder seine Sandbox ließen es nicht zu; nichts weiter wurde gestartet",
@@ -721,6 +722,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 – ein Experiment",
+  "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 – ein Experiment",
+  "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 +1166,10 @@
   "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.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? Ein Experiment: der Agent sucht sie nur, wenn die Familienforschung nichts zu tun hat, 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,17 @@
   "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": "Ein Experiment: gesucht wird nur, wenn die Familienforschung nichts zu tun hat, höchstens eine Sitzung am Tag bis {minutes} Minuten.",
+  "ui.link.experiment.note.gate": "Ein Experiment: gesucht wird nur, wenn die Familienforschung nichts zu tun hat; wann, entscheidet das Tor der Läufe, eine Sitzung dauert höchstens {minutes} Minuten.",
+  "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,217 @@
+// 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, 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}) — an experiment, 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"),
+    });
+    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 — an experiment, 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 experiment)",
+            "- 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,7 @@ 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 { 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 +181,38 @@ 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;
+    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/registry.js

@@ -49,8 +49,9 @@ export function register(...defs) {
         registry.push(def);
     }
 }
+/** The commands help, strom commands, the guide and the brief show: every one but those behind a gate (hidden). */
 export function commands() {
-    return registry;
+    return registry.filter((c) => !c.hidden);
 }
 export function optionsOf(def) {
     // a command's own option of a global's name is its own (strom help --agent: the catalog, not an agent's name)
@@ -74,7 +75,7 @@ export function match(words) {
 }
 /** Command groups ("person") that have subcommands but no command of their own. */
 export function subcommandsOf(prefix) {
-    return registry.filter((c) => c.path.length > prefix.length && prefix.every((w, i) => c.path[i] === w));
+    return registry.filter((c) => !c.hidden && c.path.length > prefix.length && prefix.every((w, i) => c.path[i] === w));
 }
 /** An alias's words that begin with these (a group of aliases only: "lesson" has "lesson show" among them). */
 export function aliasExtends(prefix) {

package/dist/cli/ui.js

@@ -521,6 +521,7 @@ export const UI = {
     "ui.run.stop.user": "by hand",
     "ui.run.stop.time": "time limit",
     "ui.run.stop.empty": "no open tasks",
+    "ui.run.stop.history": "the history of the places waits until tomorrow: one session a day without a gate (run.gate), nothing else to do",
     "ui.run.stop.asleep": "nothing to do until {at} — the tasks left need {host}, which is not answering now",
     "ui.run.stop.problems": "the evidence has problems — strom check",
     "ui.run.stop.denied": "the agent was not allowed to run strom — its permissions or its sandbox kept it away; nothing more was started",
@@ -1135,6 +1136,10 @@ export const UI = {
     "ui.recent.more": "… and {n} more",
     "ui.recent.morechanges": "(and {n, plural, one {# more change} other {# more changes}})",
     "ui.history.none": "nothing in the history yet",
+    "ui.history.past.hidden": "Hidden: {event} at {where}",
+    "ui.history.past.shown": "Shown again: {event} at {where}",
+    "ui.history.past.same": "Nothing changed: {event} at {where}",
+    "ui.history.past.redo": "The events of {region} will be looked for again (those found stay).",
     "ui.browse.plan": "What the agent will do next",
     "ui.review.new": "{name} — {n, plural, one {# new task} other {# new tasks}}:",
     "ui.review.nothing": "{name} — nothing new to review",
@@ -1694,6 +1699,7 @@ export const UI = {
     "ui.archives.agentbrowser.off": "Back to the browser only for archives through the browser?",
     "ui.consent.remote": "Start the Claude Code sessions strom opens with Remote Control, so that they can be followed and steered from claude.ai or the Claude app on a phone?",
     "ui.consent.addons": "Let the agent working alone load the personal add-ons of its own settings (skills, plugins, MCP servers — mail or documents among them), as in a conversation? It works with nobody watching.",
+    "ui.consent.history": "Look for the events of history at the places of every research on this computer — wars, epidemics, censuses, changes of the state? An experiment: the agent looks for them only when the family research has nothing to do, and it takes its time and the plan's usage.",
     "ui.consent.effort": "Let the {agent} sessions strom starts reason with the effort {effort}? A higher reasoning effort (high, xhigh) uses up the subscription's limits sooner.",
     "ui.consent.webPerHost": "Let the agent's own web fetch make up to {n, plural, one {# request} other {# requests}} to one site (its servers and mirrors together) in a session (now {now})? More requests to one site put more load on it; more pages of one site go more gently through a connector.",
     "ui.consent.effort.run": "Start {agent} working alone with the reasoning effort {effort} for this run, above the setting ({now})? A higher reasoning effort (high, xhigh) uses up the subscription's limits sooner.",
@@ -2515,6 +2521,17 @@ export const UI = {
     "ui.archives.permissions.title": "The archives of the downloaders here \u2013 what holds for their images:",
     "ui.archives.state.way": "{way}, decided {date}",
     "ui.link.archive.none": "There is nothing to decide about this archive here. Nothing was done.",
+    "ui.experiments.link": "The search for the events of history is turned on only in the terminal the link opens.",
+    "ui.link.what.experiment.history": "look for the events of history at the places of this tree — wars, epidemics, censuses, changes of the state",
+    "ui.link.experiment.note": "An experiment: looked for only when the family research has nothing to do, at most one session a day of up to {minutes} minutes.",
+    "ui.link.experiment.note.gate": "An experiment: looked for only when the family research has nothing to do; when, the gate of the runs decides, a session of up to {minutes} minutes.",
+    "ui.link.experiment.all": "It is turned on in this computer's settings: for every research on it (each can be turned off on its own).",
+    "ui.link.experiment.on.done": "The search for the events of history is on for this research.",
+    "ui.link.experiment.on.already": "The search for the events of history is on for this research already. Nothing was done.",
+    "ui.link.experiment.off.done": "The search for the events of history is off for this research; what was found stays.",
+    "ui.link.experiment.off.already": "The search for the events of history is off for this research already. Nothing was done.",
+    "ui.link.experiment.archive": "Nothing of history is looked for while the research is kept as an archive. Nothing was done.",
+    "ui.link.experiment.waiting": "Nobody works on this research on this computer, so nothing of history is looked for. Nothing was done.",
     "ui.error.archive.permission": "downloading images from {title} ({hosts}) waits for a decision \u2013 its terms restrict automated downloading; nothing was asked of the archive",
     "ui.error.archive.permission.new": "downloading images from {title} ({hosts}) waits for a decision \u2013 nobody has confirmed its downloader's reading of the terms yet; nothing was asked of the archive",
     "ui.error.archive.permission.hint": "to be decided in strom's menu (What waits), or in a terminal: strom allow archive {host} --way {ways}",

package/dist/commands/checks.js

@@ -8,7 +8,7 @@ import { counted, lines, table } from "../cli/format.js";
 import { check, SHARED_MISSING, sharedMissing } from "../core/check.js";
 import { guard } from "../core/guard.js";
 import { unprovenPeople } from "../core/review.js";
-import { NOT_DOWNLOADED, notDownloaded, notDownloadedError, verifyFast, verifyFull } from "../core/integrity.js";
+import { NOT_DOWNLOADED, SEALED_PATHS, notDownloaded, notDownloadedError, verifyFast, verifyFull } from "../core/integrity.js";
 import { verifyCommitSeal } from "../core/seal.js";
 import { adoptSeal } from "../cli/seal.js";
 import { NeedsConsentError, StromError } from "../core/errors.js";
@@ -150,10 +150,10 @@ function repair(tree) {
     const headSealed = head !== undefined && verifyCommitSeal(key, head.tree, head.message);
     // Paths to compare: whatever differs between the sealed commit and the working tree.
     const candidates = new Set();
-    for (const c of git.changes(tree.root, ["data", "strom.json"]))
+    for (const c of git.changes(tree.root, SEALED_PATHS))
         candidates.add(c.path);
     if (!headSealed) {
-        const r = git.runGit(tree.root, ["diff", "--name-only", "-z", sealed, "HEAD", "--", "data", "strom.json"]);
+        const r = git.runGit(tree.root, ["diff", "--name-only", "-z", sealed, "HEAD", "--", ...SEALED_PATHS]);
         for (const p of r.stdout.split("\0").filter(Boolean))
             candidates.add(p);
     }
@@ -178,7 +178,7 @@ function repair(tree) {
         }
     }
     if (!headSealed)
-        tree.commit(`Repair: restore the sealed state of ${sealed.slice(0, 8)}\n\nCommits made outside strom were undone for data/ and strom.json.`, ["data", "strom.json"]);
+        tree.commit(`Repair: restore the sealed state of ${sealed.slice(0, 8)}\n\nCommits made outside strom were undone for data/, strom.json and history/.`, SEALED_PATHS);
     return { restored, quarantined, from: sealed };
 }
 register({