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

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.5. Oddíl bude úplný s vydáním.*
+*Připravuje se: bety do 1.22.0-beta.6. 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,
@@ -32,6 +32,8 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   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í.
+  Když jsou události regionu sebrané, roky, kdy v něm lidé stromu žili víc než 15 let po sobě bez jediné události,
+  se prohledají ještě jednou; prohledané roky se v žádném výzkumu znovu neotevřou, dokud se o region nepožádá znovu.
 
 ## 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.5. Der Abschnitt ist mit dem Release vollständig.*
+*In Vorbereitung: die Betas bis 1.22.0-beta.6. 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
@@ -37,6 +37,9 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   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.
+  Sind die Ereignisse einer Region gesammelt, werden die Jahre, in denen die Personen des Stammbaums dort mehr als
+  15 Jahre in Folge ohne ein Ereignis lebten, noch einmal durchsucht; durchsuchte Jahre werden in keiner Forschung
+  erneut aufgegriffen, bis die Region wieder angefragt wird.
 
 ## 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.5. The section is complete with the release.*
+*In preparation: the betas up to 1.22.0-beta.6. 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
@@ -36,6 +36,9 @@ The changes of each version in short. The full notes and the install lines are o
   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.
+  Once a region's events are gathered, the years the tree's people lived there for more than 15 in a row with no
+  event are looked through once more; years looked through are not raised again, in any research, until the region
+  is asked for again.
 
 ## 1.21.0
 

package/assets/lang/cs.json

@@ -731,6 +731,13 @@
   "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é",
+  "history.gaps.what": "Události dějin v regionu {region} pro roky, kdy katalog žádné nemá: {years}",
+  "history.gaps.why": "osoby stromu tam v těch letech žily a u jejich životů se z tehdejších dějin nic neukazuje",
+  "history.gaps.done": "zhruba jedna událost na 10–15 let každé mezery, každá ze stránky, kterou strom sám přečetl – nebo nic, když žádná událost hodná zápisu doložená není",
+  "history.gaps.filled": "v událostech regionu {region} už žádná mezera není",
+  "history.gaps.looked.none": "roky {years} v událostech regionu {region} už prohledal jiný výzkum: doložená událost v nich žádná",
+  "history.gaps.looked.some": "roky {years} v událostech regionu {region} už prohledal jiný výzkum: zapsaných událostí v nich: {n}",
+  "history.gaps.gone": "roky {years} už pro tento strom nejsou mezerou v událostech regionu {region}: údaje jeho osob v tom regionu se změnily",
   "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",
@@ -2692,6 +2699,7 @@
   "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.gaps": "{region}, roky bez událostí {years} (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é.",

package/assets/lang/de.json

@@ -731,6 +731,13 @@
   "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",
+  "history.gaps.what": "Ereignisse der Geschichte in {region} für die Jahre, in denen der Katalog keines hat: {years}",
+  "history.gaps.why": "Personen des Stammbaums lebten in diesen Jahren dort, und bei ihren Lebensläufen erscheint nichts von der damaligen Geschichte",
+  "history.gaps.done": "etwa ein Ereignis alle 10–15 Jahre jeder Lücke, jedes von einer Seite, die strom selbst gelesen hat – oder keines, wenn kein Ereignis, das einen Eintrag wert ist, belegt ist",
+  "history.gaps.filled": "in den Ereignissen von {region} ist keine Lücke mehr",
+  "history.gaps.looked.none": "die Jahre {years} in den Ereignissen von {region} hat schon eine andere Forschung durchsucht: kein Ereignis darin belegt",
+  "history.gaps.looked.some": "die Jahre {years} in den Ereignissen von {region} hat schon eine andere Forschung durchsucht: darin geschriebene Ereignisse: {n}",
+  "history.gaps.gone": "die Jahre {years} sind für diesen Stammbaum keine Lücke in den Ereignissen von {region} mehr: die Angaben seiner Personen dort haben sich geändert",
   "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",
@@ -2692,6 +2699,7 @@
   "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.gaps": "{region}, die Jahre ohne Ereignisse {years} (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.",

package/dist/brief/history.js

@@ -6,7 +6,7 @@ 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 { catalogIds, EVENT_KINDS, forGaps, GAP_DENSITY, gapsOfTask, gapText, 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;
@@ -44,7 +44,7 @@ const ONLY_FROM_PAGES = [
 export function historySections(tree, task, shared, alone) {
     const region = regionOfTask(task);
     if (region)
-        return regionSections(tree, region, shared, alone);
+        return regionSections(tree, region, shared, alone, forGaps(task) ? gapsOfTask(task) : undefined);
     if (task.origin === HISTORY_PLACES_ORIGIN)
         return placesSections(tree, shared, alone);
     return undefined;
@@ -63,7 +63,10 @@ function closing(alone, lang, lines) {
         ].join("\n"),
     };
 }
-function regionSections(tree, region, shared, alone) {
+/** What events a region's catalog keeps: those that shaped the lives of ordinary people there. */
+const SHAPED = "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";
+/** A region's session — or, with its gaps, a session filling the gaps of its finished catalog (K2.6). */
+function regionSections(tree, region, shared, alone, gaps) {
     const lang = tree.lang;
     const c = shared ? readCatalog(shared, region) : undefined;
     const name = regionName(c, lang, region);
@@ -80,19 +83,26 @@ function regionSections(tree, region, shared, alone) {
         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 span = (g) => g.to - g.from + 1;
+    const wanted = gaps?.reduce((n, g) => n + Math.max(1, Math.round(span(g) / GAP_DENSITY)), 0) ?? 0;
     const out = [];
     out.push({
         name: "history",
         required: true,
         pointer: "strom history status",
         text: [
-            `## The history of ${name} (${region}) — for the Strom app`,
+            gaps ? `## The gaps in the history of ${name} (${region}) — for the Strom app` : `## 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`,
+            gaps
+                ? `- the region's catalog is finished, yet these years of this tree's people there have no event: ${gaps.map((g) => `${gapText(g)} (${span(g)} years)`).join(", ")} — look for events of these years alone (strom history add refuses others in this session); what the catalog has (below) is never looked for again`
+                : `- 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`,
+            gaps
+                ? `- how many: about one event every 10–15 years of each gap (about ${wanted} in all) — ${SHAPED}; none documented worth writing: nothing — a year is never filled for its own sake`
+                : `- 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"}) — ${SHAPED}`,
+            gaps ? "" : "- spread over the period: the people of every part of it lived through something — rather an event each 10–15 years of it than many of a few decades",
             `- 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",
@@ -129,20 +139,25 @@ function regionSections(tree, region, shared, alone) {
             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`,
+                gaps ? "- they lack nothing worth writing: strom session close --done at once, no page read" : `- 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);
+    const commands = [cmd(["history", "page"]), cmd(["history", "add"]), cmd(["history", "retract"]), cmd(["history", "status"]), ...(gaps ? [] : [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 "…"`,
-    ]));
+    out.push(closing(alone, lang, gaps
+        ? [
+            `- the gaps looked at — events found, or none documented: strom session close --done "how many events, of which years and kinds, from which sources — or what was looked at" --next "…" (these years are never looked for again)`,
+            `- time up before: strom session close --continue --summary "…" --next "the years not looked at yet" (the region stays this tree's for ${HOLD_DAYS} days)`,
+        ]
+        : [
+            `- 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) {

package/dist/cli/ui.js

@@ -2543,6 +2543,7 @@ export const UI = {
     "ui.plan.history.asked": "; first: {region}, as asked",
     "ui.plan.history.order": "Regions in turn, one at a time: {list}",
     "ui.plan.history.weight": "{region} (people: {n})",
+    "ui.plan.history.gaps": "{region}, the years without events {years} (people: {n})",
     "ui.plan.history.prefer": "; first: the place {place} from a recent session",
     "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.",

package/dist/commands/browse.js

@@ -16,7 +16,7 @@ export { humanTask };
 import { lacksImages, waitsForArchive } from "../core/queue.js";
 import { clockUp } from "../core/net.js";
 import { forStory } from "../core/stories.js";
-import { forHistory, HISTORY_PLACES_ORIGIN, historyOn, historyTurn, readCatalog, regionName, regionOfTask } from "../core/pastevents.js";
+import { forGaps, forHistory, gapsOfTask, gapText, HISTORY_PLACES_ORIGIN, historyOn, historyTurn, readCatalog, regionName, regionOfTask } from "../core/pastevents.js";
 import { isArchive } from "../core/mode.js";
 import { actsAsArchive, stateOf } from "../core/state.js";
 import { rankedQueue } from "./tasks.js";
@@ -244,7 +244,9 @@ register({
         if (history?.regions.length)
             out.push(ui(lang, "ui.plan.history.order", {
                 list: [
-                    ...history.regions.slice(0, HISTORY_REGIONS).map((r) => ui(lang, "ui.plan.history.weight", { region: r.name, n: r.persons })),
+                    ...history.regions
+                        .slice(0, HISTORY_REGIONS)
+                        .map((r) => (r.gaps ? ui(lang, "ui.plan.history.gaps", { region: r.name, years: r.gaps.join(", "), n: r.persons }) : ui(lang, "ui.plan.history.weight", { region: r.name, n: r.persons }))),
                     ...(history.regions.length > HISTORY_REGIONS ? [`… (+${history.regions.length - HISTORY_REGIONS})`] : []),
                 ].join(" · "),
             }));
@@ -321,11 +323,14 @@ function historyPlan(ctx, tree) {
     const prefer = !asked && turn.prefer?.task === task.id ? turn.prefer.place : undefined;
     const when = task.origin === HISTORY_PLACES_ORIGIN ? ui(lang, "ui.plan.history.places") : turn.now ? ui(lang, "ui.plan.history.now") : turn.in === undefined ? ui(lang, "ui.plan.history.idle") : ui(lang, "ui.plan.history.in", { n: Math.max(1, turn.in) });
     const weight = new Map((turn.order ?? []).map((w) => [w.id, w]));
-    // the regions as the queue ranks their tasks: asked for, a recent session's place, then by weight
-    const regions = ranked
-        .map((r) => regionOfTask(r.task))
-        .filter((id) => !!id)
-        .map((id) => ({ id, name: name(id), persons: weight.get(id)?.persons ?? 0 }));
+    // the regions as the queue ranks their tasks: asked for, a recent session's place, then by weight (the gaps of a
+    // finished one with their years)
+    const regions = ranked.flatMap((r) => {
+        const id = regionOfTask(r.task);
+        if (!id)
+            return [];
+        return [{ id, name: name(id), persons: weight.get(id)?.persons ?? 0, ...(forGaps(r.task) ? { gaps: gapsOfTask(r.task).map(gapText) } : {}) }];
+    });
     return {
         task,
         turn,

package/dist/commands/history.js

@@ -13,7 +13,7 @@ import { clipMark } from "../core/excerpt.js";
 import { resolvePerson } from "../core/people.js";
 import { checkQuotes, cleanText, findPassages, mainQuote, pageParts, PageError, quotesShape, readPage, PART_CHARS } from "../core/pagecheck.js";
 import { currentSession } from "../core/session.js";
-import { addLocalEvent, addRegionEvent, askFirst, checkKind, checkTexts, checkYears, ensureRegion, factPlaceKey, hideEvent, historyAnswer, historyStatus, forHistory, historyOrder, historyTurn, mapPlace, markDone, noteTried, readCatalog, redoRegion, refuseBeforePage, REGION_LANGS, regionIdOk, regionOfTask, requireHistoryOn, requireRegionId, retractEvent, EVENT_KINDS, } from "../core/pastevents.js";
+import { addLocalEvent, addRegionEvent, askFirst, checkKind, checkTexts, checkYears, ensureRegion, factPlaceKey, hideEvent, historyAnswer, historyStatus, forGaps, forHistory, gapsOfTask, gapText, historyOrder, historyTurn, mapPlace, markDone, noteTried, readCatalog, redoRegion, refuseBeforePage, REGION_LANGS, regionIdOk, regionOfTask, requireHistoryOn, requireRegionId, retractEvent, EVENT_KINDS, } from "../core/pastevents.js";
 function shared(ctx) {
     const s = ctx.settings.shared()?.value;
     if (!s)
@@ -124,12 +124,21 @@ register({
                 return "asked first";
             if (turn?.prefer?.task === t.id)
                 return `first: ${turn.prefer.place}`;
-            return w ? `${w.persons} people, ${w.facts} facts` : "";
+            const gaps = forGaps(t) ? `gaps ${gapsOfTask(t).map(gapText).join(", ")}` : "";
+            return [gaps, w ? `${w.persons} people, ${w.facts} facts` : ""].filter(Boolean).join(" · ");
         };
         const when = !turn ? undefined : turn.places ? `the next session, the places to map first (${turn.places})` : turn.pace === "idle" ? "when the family research has nothing to do" : turn.now ? "the next session" : `in ~${Math.max(1, turn.in ?? 0)} sessions`;
         return {
             text: lines(`history of the places: ${s.on ? "on" : "off (the user alone turns it on: strom config set experiments.history on)"} · search: ${state.search}${state.why ? ` (${state.why})` : ""}`, `places of the facts: ${s.places.total} · mapped ${s.places.mapped} · not located ${s.places.unlocated} · waiting ${s.places.pending.length}`, shown.length ? `waiting: ${shown.join(" · ")}${s.places.pending.length > shown.length ? ` … (+${s.places.pending.length - shown.length}, --limit)` : ""}` : undefined, s.regions.length
-                ? table(s.regions.map((r) => [r.id, r.name?.en ?? "(no catalog)", `${r.events} events`, r.retracted ? `${r.retracted} taken back` : "", r.done ? `done ${r.done.slice(0, 10)}` : r.heldBy ? `held by ${r.heldBy}` : "open", r.tried ? `${r.tried} pages not read` : ""]))
+                ? table(s.regions.map((r) => [
+                    r.id,
+                    r.name?.en ?? "(no catalog)",
+                    `${r.events} events`,
+                    r.retracted ? `${r.retracted} taken back` : "",
+                    r.done ? `done ${r.done.slice(0, 10)}` : r.heldBy ? `held by ${r.heldBy}` : "open",
+                    r.gaps?.length ? `gaps: ${r.gaps.map(gapText).join(", ")}` : "",
+                    r.tried ? `${r.tried} pages not read` : "",
+                ]))
                 : "no regions yet", `local events: ${s.local.events}${s.local.retracted ? ` (${s.local.retracted} taken back)` : ""} · hidden by the person: ${s.hidden.total}`, turn ? `pace: ${turn.pace} (strom config set experiments.historyPace sometimes|rare|idle) · ${turn.since} sessions since the last of history · strom run takes the next: ${when}${turn.asked ? ` · first: ${turn.asked.task} (asked for ${turn.asked.region})` : turn.prefer ? ` · first: ${turn.prefer.task} (a recent session worked at ${turn.prefer.place})` : ""}` : undefined, tasks.length
                 ? lines("tasks of history in the order strom run takes them, one a turn (strom run --task <T…> starts one now):", table(tasks.map((t, i) => [`  ${i + 1}.`, t.id, t.origin, t.state, why(t)])))
                 : s.on
@@ -265,6 +274,17 @@ register({
         if (shape)
             throw new UsageError(`--quote: ${shape}`, { code: "history.quote", params: { why: shape } });
         const s = sameness(opts);
+        // a session filling a finished catalog's gaps: an event of those years alone, before any request
+        const own = currentSession(tree, ctx.env, ctx.refs)?.task;
+        const ownTask = own ? tree.get(own) : undefined;
+        if (ownTask && forGaps(ownTask) && regionOfTask(ownTask) === region) {
+            const gaps = gapsOfTask(ownTask);
+            if (gaps.length && !gaps.some((g) => from <= g.to && g.from <= to))
+                throw new UsageError(`this session fills the gaps of ${region} only (${gaps.map(gapText).join(", ")}): ${from === to ? from : `${from}–${to}`} is outside them`, {
+                    code: "history.gaps.outside",
+                    params: { region },
+                });
+        }
         refuseBeforePage(sh, region, { kind, from, to }, s);
         let checked;
         try {

package/dist/core/pastevents.js

@@ -30,13 +30,23 @@ import { lineValue } from "../gedcom/lines.js";
 export const HISTORY_PLACES_ORIGIN = "history:places";
 /** The prefix of a region's task (`history:region:<id>`, one a region). */
 export const HISTORY_REGION_ORIGIN = "history:region:";
+/** The prefix of a task that fills the gaps of a region's finished catalog (`history:gaps:<id>`, one a region). */
+export const HISTORY_GAPS_ORIGIN = "history:gaps:";
 /** The level the tasks of history take (an existing one: a new value of the list would raise SCHEMA_VERSION). */
 export const HISTORY_LEVEL = "enrich";
 /** A region's task origin. */
 export function regionOrigin(region) {
     return `${HISTORY_REGION_ORIGIN}${region}`;
 }
-/** Is it a task of the history (history:places, history:region:<id>)? */
+/** A region's task to fill the gaps of its finished catalog. */
+export function gapsOrigin(region) {
+    return `${HISTORY_GAPS_ORIGIN}${region}`;
+}
+/** Is it a task that fills the gaps of a region's finished catalog (history:gaps:<id>)? */
+export function forGaps(t) {
+    return typeof t.origin === "string" && t.origin.startsWith(HISTORY_GAPS_ORIGIN);
+}
+/** Is it a task of the history (history:places, history:region:<id>, history:gaps:<id>)? */
 export function forHistory(t) {
     return typeof t.origin === "string" && t.origin.startsWith("history:");
 }
@@ -454,6 +464,7 @@ export function redoRegion(shared, region) {
             throw new UsageError(`there is no region ${region}`, { code: "history.region.missing", params: { region } });
         delete c.done;
         delete c.holder;
+        delete c.gaps;
         c.redo = new Date().toISOString();
         writeCatalog(shared, c);
         return c;
@@ -900,6 +911,7 @@ export function historyStatus(tree, shared, settings) {
             ...(c?.done ? { done: c.done.at } : {}),
             ...(c && heldElsewhere(c, tree.config.id) ? { heldBy: c.holder.tree } : {}),
             tried: c?.tried.length ?? 0,
+            ...(c?.done ? { gaps: regionGaps(tree, shared, id) } : {}),
         };
     });
     const kindOf = new Map();
@@ -946,8 +958,13 @@ export function mergeCatalog(shared, given) {
         }
         const ids = new Set(had.events.map((e) => e.id));
         const more = given.events.filter((e) => typeof e?.id === "string" && !ids.has(e.id));
-        if (!more.length)
+        // the gaps another computer's tree looked at: not looked at here again
+        const seen = new Set((had.gaps ?? []).map((g) => `${g.from}-${g.to}-${g.tree}`));
+        const gaps = (Array.isArray(given.gaps) ? given.gaps : []).filter((g) => Number.isInteger(g?.from) && Number.isInteger(g?.to) && !seen.has(`${g.from}-${g.to}-${g.tree}`));
+        if (!more.length && !gaps.length)
             return { added: 0 };
+        if (gaps.length)
+            had.gaps = [...(had.gaps ?? []), ...gaps];
         had.events.push(...more);
         had.events.sort((a, b) => a.id.localeCompare(b.id));
         const top = Math.max(0, ...had.events.map((e) => Number(/-(\d+)$/.exec(e.id)?.[1] ?? 0)));
@@ -970,9 +987,14 @@ export function unmappedPlaces(tree) {
 export function regionName(c, lang, id = c?.region.id ?? "") {
     return c?.region.name[lang] ?? c?.region.name.en ?? id;
 }
-/** The region of a task of history (history:region:<id>), else undefined. */
+/** The region of a task of history (history:region:<id>, its gaps history:gaps:<id>), else undefined. */
 export function regionOfTask(t) {
-    return typeof t.origin === "string" && t.origin.startsWith(HISTORY_REGION_ORIGIN) ? t.origin.slice(HISTORY_REGION_ORIGIN.length) || undefined : undefined;
+    if (typeof t.origin !== "string")
+        return undefined;
+    for (const prefix of [HISTORY_REGION_ORIGIN, HISTORY_GAPS_ORIGIN])
+        if (t.origin.startsWith(prefix))
+            return t.origin.slice(prefix.length) || undefined;
+    return undefined;
 }
 /** History is looked for from this year at the earliest. */
 const EARLIEST_YEAR = 1600;
@@ -998,16 +1020,208 @@ export function regionPeriod(tree, region) {
     const from = Number.isFinite(oldest) ? Math.min(to, Math.max(EARLIEST_YEAR, oldest)) : EARLIEST_YEAR;
     return { from, to, places: places.sort((a, b) => a.place.localeCompare(b.place)) };
 }
+// ── the gaps of a finished catalog (K2.6) ──────────────────────────────────
+/** A gap: more years than so many in a row the tree's people lived in a region with no event of its catalog. */
+export const GAP_YEARS = 15;
+/** A person lived in a region so many years before the first fact there and after the last. */
+export const LIVED_MARGIN = 5;
+/** An event of so many years or more (a state, a period of rule) marks only its beginning and its end, not the years between. */
+const LONG_EVENT = GAP_YEARS;
+/** About one event in so many years of a gap: what a session filling it looks for. */
+export const GAP_DENSITY = 12;
+/** A gap's years as a task and the brief write them: 1870–1913. */
+export function gapText(g) {
+    return g.from === g.to ? String(g.from) : `${g.from}–${g.to}`;
+}
+/** The gaps a task of them was raised for (its `where`: 1870–1913 each). */
+export function gapsOfTask(t) {
+    const out = [];
+    for (const w of t.where ?? []) {
+        const m = /^(\d{3,4})(?:\s*[–-]\s*(\d{3,4}))?$/u.exec(w.trim());
+        if (m)
+            out.push({ from: Number(m[1]), to: Number(m[2] ?? m[1]) });
+    }
+    return out;
+}
+/** Merged spans, both ends in: touching or overlapping ones joined. */
+function union(spans) {
+    const out = [];
+    for (const s of [...spans].sort((a, b) => a.from - b.from)) {
+        const last = out.at(-1);
+        if (last && s.from <= last.to + 1)
+            last.to = Math.max(last.to, s.to);
+        else
+            out.push({ ...s });
+    }
+    return out;
+}
+/**
+ * The years the tree's people lived in a region: each person from the first year of a fact at its places (in the years
+ * each place belonged to it) to the last, LIVED_MARGIN before and after, within the years of those places' links and
+ * never before 1600 or after this year — the spans of all of them joined. A family's fact counts for its partners;
+ * a fact without a year counts for nothing.
+ */
+export function livedSpans(tree, region) {
+    const r = reading(tree, undefined);
+    const now = new Date().getFullYear();
+    const of = new Map();
+    const count = (who, e) => {
+        if (!factWritten(e) || !e.place || !e.date)
+            return;
+        const key = lineValue(e.place);
+        const m = key ? r.mapOf(key) : undefined;
+        if (!m)
+            return;
+        const years = dateYears(e.date);
+        for (const g of m.regions) {
+            if (g.id !== region)
+                continue;
+            const inside = years.filter((y) => inRegion({ from: y, to: y }, g));
+            if (!inside.length)
+                continue;
+            for (const p of who) {
+                const w = of.get(p) ?? { years: [], lo: Infinity, hi: -Infinity };
+                of.set(p, w);
+                w.years.push(...inside);
+                w.lo = Math.min(w.lo, g.from ?? -Infinity);
+                w.hi = Math.max(w.hi, g.to ?? Infinity);
+            }
+        }
+    };
+    const persons = tree.list("person").filter((p) => !p.retracted);
+    const alive = new Set(persons.map((p) => p.id));
+    for (const p of persons)
+        for (const e of p.events)
+            count([p.id], e);
+    for (const f of tree.list("family")) {
+        const who = f.partners.filter((p) => alive.has(p));
+        if (who.length)
+            for (const e of f.events)
+                count(who, e);
+    }
+    const spans = [];
+    for (const w of of.values()) {
+        const from = Math.max(EARLIEST_YEAR, w.lo, Math.min(...w.years) - LIVED_MARGIN);
+        const to = Math.min(now, w.hi, Math.max(...w.years) + LIVED_MARGIN);
+        if (from <= to)
+            spans.push({ from, to });
+    }
+    return union(spans);
+}
 /**
- * A region taken by this tree for a session on its task: the holder written into the shared catalog (refreshed when it
+ * The gaps of a region's finished catalog for this tree (K2.6, Milan 28 Oct 2026 — a land's catalog with nothing
+ * between 1869 and 1914 while the tree's people lived there): the runs of more than GAP_YEARS years the tree's people
+ * lived there (livedSpans) with no event of the catalog — nor of the finished catalogs that hold its places and years
+ * (coverOf: a state after its lands) — and not looked at before: the gaps a session of any tree looked at (the
+ * catalog's `gaps`, noteGaps: a task of them done writes them there), this tree's tasks of them dropped (since the
+ * person last asked for the region again). A task strom closed itself (raiseHistoryTasks: filled, looked at elsewhere)
+ * is no look: events taken back later, its years are a gap again. An event of LONG_EVENT years or more marks its two
+ * ends only. None for a catalog not finished (its own task looks for all), nor without people there. Nothing written.
+ */
+export function regionGaps(tree, shared, region) {
+    if (!shared)
+        return [];
+    const r = reading(tree, shared);
+    const c = r.catalog(region);
+    if (!c?.done)
+        return [];
+    const lived = livedSpans(tree, region);
+    if (!lived.length)
+        return [];
+    const covered = eventYears(r, region);
+    const mark = (g) => {
+        for (let y = g.from; y <= g.to; y++)
+            covered.add(y);
+    };
+    for (const g of c.gaps ?? [])
+        mark(g);
+    for (const t of tree.list("task"))
+        if (t.origin === gapsOrigin(region) && t.state === "dropped" && t.updated >= (c.redo ?? ""))
+            for (const g of gapsOfTask(t))
+                mark(g);
+    return openRuns(lived, covered);
+}
+/** The years the events of a region's catalog (and of the finished catalogs that hold it) mark: a long one its ends. */
+function eventYears(r, region) {
+    const covered = new Set();
+    for (const id of [region, ...coverOf(r, region)])
+        for (const e of r.catalog(id)?.events ?? []) {
+            if (e.retracted)
+                continue;
+            if (e.to - e.from + 1 >= LONG_EVENT) {
+                covered.add(e.from);
+                covered.add(e.to);
+            }
+            else
+                for (let y = e.from; y <= e.to; y++)
+                    covered.add(y);
+        }
+    return covered;
+}
+/** The runs of more than GAP_YEARS years of these spans no year of `covered` falls in. */
+function openRuns(spans, covered) {
+    const out = [];
+    for (const span of spans) {
+        let start;
+        for (let y = span.from; y <= span.to + 1; y++) {
+            const open = y <= span.to && !covered.has(y);
+            if (open && start === undefined)
+                start = y;
+            if (!open && start !== undefined) {
+                if (y - start > GAP_YEARS)
+                    out.push({ from: start, to: y - 1 });
+                start = undefined;
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Why a gaps' task has nothing left to do (regionGaps none of its years): its years filled by the events of the
+ * catalog ("filled"); else looked at by another tree's session (the catalog's `gaps`: "looked", with the events it
+ * wrote in them); else no gap for this tree any more — its people's facts there changed ("gone").
+ */
+export function gapsClosed(tree, shared, region, t) {
+    const r = reading(tree, shared);
+    const mine = gapsOfTask(t);
+    if (!openRuns(mine, eventYears(r, region)).length)
+        return { why: "filled", added: 0 };
+    const looked = (r.catalog(region)?.gaps ?? []).filter((g) => g.tree !== tree.config.id && mine.some((m) => g.from <= m.to && m.from <= g.to));
+    if (looked.length)
+        return { why: "looked", added: looked.reduce((n, g) => n + (g.added || 0), 0) };
+    return { why: "gone", added: 0 };
+}
+/**
+ * A gaps' task finished (strom session close --done): its gaps written into the shared catalog as looked at — with the
+ * events this tree wrote in them since the task was made, none too — and the region let go when this tree held it.
+ */
+export function noteGaps(shared, region, t, treeId) {
+    const gaps = gapsOfTask(t);
+    if (!regionIdOk(region) || !gaps.length)
+        return;
+    withCatalogs(shared, () => {
+        const c = readCatalog(shared, region);
+        if (!c)
+            return;
+        const at = new Date().toISOString();
+        const mine = c.events.filter((e) => !e.retracted && e.by === treeId && e.at >= t.created);
+        c.gaps = [...(c.gaps ?? []), ...gaps.map((g) => ({ ...g, at, tree: treeId, added: mine.filter((e) => overlap(e, g)).length }))];
+        if (c.holder?.tree === treeId)
+            delete c.holder;
+        writeCatalog(shared, c);
+    });
+}
+/**
+ * A region taken by this tree for a session on its task (or on its gaps): the holder written into the shared catalog (refreshed when it
  * is this tree's already). Another tree's hold within HOLD_DAYS stays: its ID is returned (nothing written).
  */
-export function takeRegion(shared, region, treeId) {
+export function takeRegion(shared, region, treeId, gaps = false) {
     if (!regionIdOk(region))
         return undefined;
     return withCatalogs(shared, () => {
         const c = readCatalog(shared, region);
-        if (!c || c.done)
+        // a finished catalog is held only while its gaps are filled
+        if (!c || (c.done && !gaps))
             return undefined;
         if (heldElsewhere(c, treeId))
             return c.holder.tree;
@@ -1275,7 +1489,8 @@ export function historyHeld(tree, shared, settings = new Settings(tree.env, {}))
 /**
  * The tasks of history raised while the experiment is on in a research (never in an archive, nor one waiting for its
  * agent, never in a dry run): one to map the places of the facts while any is not mapped, one for each region of the
- * tree's places whose catalog is not finished — level enrich, priority 1, after all the research in the queue. Never a
+ * tree's places whose catalog is not finished, one for the gaps of a finished one (regionGaps) — level enrich,
+ * priority 1, after all the research in the queue. Never a
  * second one of the same origin open; a places' task again only for a place the last one did not name; a region's task
  * dropped is the answer until the person asks for the region again (redo); one whose catalog was finished meanwhile
  * (another tree, strom history done) is done. Inside the tree's lock, committed by the caller. Returns what it made.
@@ -1288,6 +1503,36 @@ export function raiseHistoryTasks(tree, shared, settings = new Settings(tree.env
         const tasks = tree.list("task").filter(forHistory);
         const made = [];
         const add = (fields) => made.push(create(tree, "task", { level: HISTORY_LEVEL, priority: 1, subject: [], state: "open", ...fields }, (id) => `+${id} task "${fields.what.slice(0, 60)}" (history)`).id);
+        // a finished catalog with gaps in the years of the tree's people there: one task to fill them (K2.6), paced as a
+        // region's; none left (filled meanwhile, by another tree too): its waiting task is done — one at work closes itself
+        const raiseGaps = (id, c) => {
+            const origin = gapsOrigin(id);
+            const live = tasks.filter((t) => t.origin === origin && LIVE_STATES.has(t.state));
+            const gaps = regionGaps(tree, shared, id);
+            if (!gaps.length) {
+                // its result says why, truly: filled, looked at by another research (found or not), or no gap here any more
+                for (const t of live.filter((x) => x.state === "open" || x.state === "parked")) {
+                    const { why, added } = gapsClosed(tree, shared, id, t);
+                    const key = why === "looked" ? (added ? "history.gaps.looked.some" : "history.gaps.looked.none") : why === "gone" ? "history.gaps.gone" : "history.gaps.filled";
+                    const result = phrase(lang, key, { region: regionName(c, lang, id), years: t.where.join(", "), n: added });
+                    update(tree, t.id, "task", (x) => ({ ...x, state: "done", result }), {
+                        op: "task.done",
+                        summary: `${t.id} done: no gap left in the catalog of ${id} (${why})`,
+                    });
+                }
+                return;
+            }
+            if (live.length)
+                return;
+            const years = gaps.map(gapText);
+            add({
+                what: phrase(lang, "history.gaps.what", { region: regionName(c, lang, id), years: years.join(", ") }),
+                where: years,
+                why: phrase(lang, "history.gaps.why"),
+                doneWhen: phrase(lang, "history.gaps.done"),
+                origin,
+            });
+        };
         // the places of the facts
         const unmapped = unmappedPlaces(tree);
         const ofPlaces = tasks.filter((t) => t.origin === HISTORY_PLACES_ORIGIN);
@@ -1317,6 +1562,7 @@ export function raiseHistoryTasks(tree, shared, settings = new Settings(tree.env
                         op: "task.done",
                         summary: `${t.id} done: the catalog of ${id} is finished`,
                     });
+                raiseGaps(id, c);
                 continue;
             }
             if (mine.some((t) => LIVE_STATES.has(t.state)))
@@ -1336,11 +1582,16 @@ export function raiseHistoryTasks(tree, shared, settings = new Settings(tree.env
         return made;
     });
 }
-/** A region's task finished (strom session close --done): its catalog finished too, when it is not yet. */
+/**
+ * A region's task finished (strom session close --done): its catalog finished too, when it is not yet; a task of its
+ * gaps: those gaps looked at (noteGaps).
+ */
 export function finishRegionOf(tree, shared, t) {
     const region = regionOfTask(t);
     if (!region || !shared || tree.dryRun)
         return;
+    if (forGaps(t))
+        return noteGaps(shared, region, t, tree.config.id);
     const c = readCatalog(shared, region);
     if (c && !c.done)
         markDone(shared, region, tree.config.id);

package/dist/core/phrases.js

@@ -83,6 +83,13 @@ export const PHRASES = {
     "history.region.why": "what the ancestors lived through, shown with their lives",
     "history.region.done": "the important events of the period found, each from a page strom read itself (about 60 at most); the region's catalog marked finished",
     "history.region.finished": "the events of {region} are finished",
+    "history.gaps.what": "Events of history in {region} for the years its catalog has none: {years}",
+    "history.gaps.why": "the people of the tree lived there in those years, and their lives show nothing of the history then",
+    "history.gaps.done": "about one event every 10–15 years of each gap, each from a page strom read itself — or nothing, when no event worth writing is documented",
+    "history.gaps.filled": "no gap left in the events of {region}",
+    "history.gaps.looked.none": "the years {years} of the events of {region} were looked through by another research: no event documented in them",
+    "history.gaps.looked.some": "the years {years} of the events of {region} were looked through by another research: events written in them: {n}",
+    "history.gaps.gone": "the years {years} are no gap in the events of {region} for this tree any more: the facts of its people there changed",
     "review.reread.what": "Read again with {model} what the facts of {name} rest on: {list}{more}",
     "review.reread.why": "only another model read these entries; {model} is the one the user reads with now ({research})",
     "review.reread.done": "each fact's entry read blind with {model} (strom read M… --blind): agreed → noted on the fact; differs → a conflict with both readings",

package/dist/core/session.js

@@ -20,7 +20,7 @@ import { readCodexConfig } from "../agents/effort.js";
 import { clearSessionWait, permissionWait, waitingForDecision } from "./archivewait.js";
 import { forgetLeftAlone } from "./leftalone.js";
 import { Settings } from "./config.js";
-import { regionOfTask, takeRegion } from "./pastevents.js";
+import { forGaps, regionOfTask, takeRegion } from "./pastevents.js";
 function currentFile(tree, env = tree.env) {
     const w = env.STROM_WORKER;
     return path.join(tree.root, ".strom", isWorkerId(w) ? `session-${w}.json` : "session.json");
@@ -190,11 +190,12 @@ export function startSession(tree, opts) {
             const doing = { ...rest, state: "doing", updated: now() };
             tree.put(doing, { op: "task.start", targets: [doing.id, s.id], summary: `${doing.id} start` });
         }
-        // a region's task of history: this tree holds the region while it builds its catalog (another tree's task waits)
+        // a region's task of history: this tree holds the region while it builds its catalog, or fills its gaps (another
+        // tree's task waits)
         const region = task ? regionOfTask(task) : undefined;
         const shared = region && !tree.dryRun ? new Settings(tree.env, {}).shared()?.value : undefined;
         if (region && shared)
-            takeRegion(shared, region, tree.config.id);
+            takeRegion(shared, region, tree.config.id, forGaps(task));
         setCurrent(tree, s.id);
         return s;
     });

package/dist/core/tree.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.22.0-beta.5",
+  "version": "1.22.0-beta.6",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {