strom-research 1.24.0-beta.1 → 1.24.0

package/CHANGELOG.cs.md

@@ -7,31 +7,37 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 
 ## 1.24.0
 
-*Připravuje se: bety do 1.24.0-beta.1. Oddíl bude úplný s vydáním.*
+*31. 10. 2026 · patří k aplikaci Strom 3.19.0.*
 
 - **Místa zmapovaná jednou pro všechny výzkumy na tomto počítači.** Místo, které jiný výzkum tady už přiřadil k regionům
   dějin, se převezme, když jde jistě o totéž místo (stejný název a stejné souřadnice, farnost nebo okres) a všechny
   výzkumy ho přiřazují stejně; přechází jen přiřazení místa, nic z rodiny. Místo stejného jména, které jistě totéž
-  není, dostane agent jako návrh; sám přiřazuje jen zbytek. `strom history adopt --dry-run` řekne, co by se převzalo.
+  není, dostane agent jako návrh; sám přiřazuje jen zbytek. `strom history adopt --dry-run` řekne, co by se převzalo. Otázka na zapnutí nebo vypnutí událostí
+  dějin říká, že platí pro všechny výzkumy na tomto počítači, i jak to změnit jen pro jeden výzkum.
 - **Opravy výzkumu pro aplikaci Strom.** Most vypíše, co `strom fixes` ve výzkumu nabízí (název, co dělá, kolik
   položek, stav, jestli jde vrátit), zdarma a bez zápisu; odkaz `strom-research://fixes` otevře opravu v terminálu
   výzkumu, kde se oprava i její vrácení vždy nejdřív potvrzuje.
 - **Stránka každého skenu v aplikaci Strom.** Soubor pro Strom dává teď každému prameni stránku jeho skenu v online
   archivu: stránku jeho prvního obrázku, jinak vlastní adresu pramene. Aplikace Strom ji nabídne u výřezů, které soubor
   vynechává, a u pramenů bez výřezu. Jen veřejná webová stránka, nikdy adresa fondu; standardní soubor GEDCOM nechává
-  adresu v poznámce.
-- **Číslo domu a věk tak, jak byly zapsány.** Slovo pro číslo domu („No.“, „čp.“) se dává jen před samotné číslo;
+  adresu v poznámce. Datum verze výzkumu v souboru pro Strom nese i čas, takže aplikace ukáže den, kdy vznikla, i kolem
+  půlnoci.
+- **Vlastní rod osoby z aplikace Strom.** Když aplikace Strom u osoby označí, že zakládá vlastní rod nebo rod
+  rodiny nenese, `strom sync` to uloží do výzkumu a soubor pro Strom to vrací, takže další odeslání i jiné zařízení
+  ukážou stejné rody; sloučení dvou osob značku zachová. Standardní soubor GEDCOM o tom nic neříká. Potřebuje aplikaci
+  Strom 3.19.0.
+- **Číslo domu, věk a období tak, jak byly zapsány.** Slovo pro číslo domu („No.“, „čp.“) se dává jen před samotné číslo;
   ulice s číslem jde do souboru tak, jak je. Věk „05y“ se čte jako 5 let. Obojí se z aplikace Strom vrací stejné,
-  není to úprava uživatele.
-- **Otázka na dějiny říká, kde platí.** Zapnutí nebo vypnutí událostí dějin platí pro všechny výzkumy na tomto
-  počítači; otázka to říká, i jak to změnit jen pro jeden výzkum.
+  není to úprava uživatele. Období, které vede aplikace Strom („1871/1882“, nebo otevřené na jednom konci), přijde do
+  výzkumu jako od … do …, nikdy jako datum někde mezi nimi.
 - **Slabý nebo odmítnutý model agenta hlásí doctor.** Když výzkum nemá zvolený model a vlastní výchozí model agenta je
   ten, který výzkum shledal pro svou práci slabým nebo odmítnutým, `strom doctor` varuje a dá příkaz k volbě; sám
   nikdy nevolí.
 - **strom z npm drží svůj kanál.** strom nainstalovaný přes npm zůstává na kanálu, ze kterého byl nainstalován, i po
   vydání; kanál zvolený přes `strom update --channel` se pro něj také pamatuje.
 - **Příkaz, který selže, vrátí jen své.** Příkaz, který cestou uložil a pak selhal, vrátí jen to, co přišlo po jeho
-  uložení, takže výzkum nikdy nevypadá změněný mimo strom.
+  uložení, takže výzkum nikdy nevypadá změněný mimo strom. Když se zápis odmítne, protože se výzkum změnil mimo strom,
+  člověk to čte v jazyce výzkumu i s cestou, která sedí; agent to dál čte anglicky.
 
 ## 1.23.0
 

package/CHANGELOG.de.md

@@ -7,13 +7,14 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.24.0
 
-*In Vorbereitung: die Betas bis 1.24.0-beta.1. Der Abschnitt ist mit dem Release vollständig.*
+*31.10.2026 · gehört zur Strom-App 3.19.0.*
 
 - **Orte einmal zugeordnet für jede Forschung auf diesem Computer.** Ein Ort, den eine andere Forschung hier schon den
   Regionen der Geschichte zugeordnet hat, wird übernommen, wenn es sicher derselbe Ort ist (derselbe Name und dieselben
   Koordinaten, Pfarrei oder derselbe Bezirk) und jede Forschung ihn gleich zuordnet; nur die Zuordnung des Orts geht
   über, nichts von der Familie. Ein Ort gleichen Namens, der nicht sicher derselbe ist, geht als Vorschlag an den
-  Agenten; er ordnet nur den Rest zu. `strom history adopt --dry-run` sagt, was übernommen würde.
+  Agenten; er ordnet nur den Rest zu. `strom history adopt --dry-run` sagt, was übernommen würde. Die Frage, die Ereignisse der Geschichte ein- oder
+  auszuschalten, sagt, dass es für jede Forschung auf diesem Computer gilt, und wie es sich für eine allein ändern lässt.
 - **Die Korrekturen einer Forschung für die Strom-App.** Die Brücke listet, was `strom fixes` in der Forschung anbietet
   (Titel, was sie tut, wie viele Einträge, ihr Stand, ob sie sich zurücknehmen lässt), kostenlos und ohne etwas zu
   schreiben; der Link `strom-research://fixes` öffnet eine Korrektur im Terminal der Forschung, wo sie und ihre
@@ -21,12 +22,16 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 - **Die Seite jedes Scans in der Strom-App.** Die Strom-Datei gibt jetzt jeder Quelle die Seite ihres Scans im
   Online-Archiv: die Seite ihres ersten Bildes, sonst die eigene Adresse der Quelle. Die Strom-App verlinkt sie bei den
   Ausschnitten, die die Datei auslässt, und bei Quellen ohne Ausschnitt. Nur eine öffentliche Webseite, nie die Adresse
-  eines Bestands; die Standard-GEDCOM-Datei behält die Adresse in der Notiz.
-- **Hausnummer und Alter, wie sie geschrieben wurden.** Das Wort für eine Hausnummer („No.“, „čp.“) steht nur vor
+  eines Bestands; die Standard-GEDCOM-Datei behält die Adresse in der Notiz. Das Datum der Version der
+  Forschung in der Strom-Datei trägt auch die Uhrzeit, so zeigt die App den Tag ihrer Entstehung auch um Mitternacht.
+- **Die eigene Linie einer Person aus der Strom-App.** Markiert die Strom-App, dass eine Person eine eigene Linie
+  gründet oder die der Familie nicht trägt, behält `strom sync` das in der Forschung, und die Strom-Datei gibt es
+  zurück, so zeigen die nächste Sendung und ein anderes Gerät dieselben Linien; das Zusammenführen zweier Personen
+  behält die Markierung. Die Standard-GEDCOM-Datei sagt nichts davon. Es braucht die Strom-App 3.19.0.
+- **Hausnummer, Alter und Zeitraum, wie sie geschrieben wurden.** Das Wort für eine Hausnummer („No.“, „čp.“) steht nur vor
   einer Zahl allein; eine Straße mit Nummer geht so in die Datei, wie sie ist. Ein Alter „05y“ gilt als 5 Jahre.
-  Beides kommt aus der Strom-App gleich zurück, keine Änderung des Benutzers.
-- **Die Frage nach der Geschichte sagt, wo sie gilt.** Die Ereignisse der Geschichte ein- oder auszuschalten gilt für
-  jede Forschung auf diesem Computer; die Frage sagt es, und wie es sich für eine Forschung allein ändern lässt.
+  Beides kommt aus der Strom-App gleich zurück, keine Änderung des Benutzers. Ein Zeitraum der Strom-App
+  („1871/1882“ oder an einem Ende offen) kommt als von … bis … in die Forschung, nie als ein Datum irgendwo dazwischen.
 - **Ein schwaches oder abgelehntes Modell des Agenten meldet der Doctor.** Ist für die Forschung kein Modell gewählt und
   das eigene Standardmodell des Agenten eines, das die Forschung für ihre Arbeit schwach oder abgelehnt fand, warnt
   `strom doctor` und nennt den Befehl zur Wahl; selbst wählt er nie.
@@ -34,7 +39,9 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   wurde, auch nach einer Veröffentlichung; ein mit `strom update --channel` gewählter Kanal bleibt dafür ebenfalls
   gemerkt.
 - **Ein gescheiterter Befehl nimmt nur das Seine zurück.** Ein Befehl, der unterwegs gespeichert hat und dann scheitert,
-  nimmt nur zurück, was nach dieser Speicherung kam, so wirkt die Forschung nie außerhalb von strom geändert.
+  nimmt nur zurück, was nach dieser Speicherung kam, so wirkt die Forschung nie außerhalb von strom geändert. Wird das
+  Schreiben abgelehnt, weil die Forschung außerhalb von strom geändert wurde, liest die Person das in der Sprache der
+  Forschung, mit dem passenden Weg; ein Agent liest es weiter auf Englisch.
 
 ## 1.23.0
 

package/CHANGELOG.md

@@ -7,13 +7,14 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 1.24.0
 
-*In preparation: the betas up to 1.24.0-beta.1. The section is complete with the release.*
+*2026-10-31 · goes with the Strom app 3.19.0.*
 
 - **Places mapped once for every research on this computer.** A place another research here has mapped to its
   regions of history is taken over when it is surely the same place (the same name and the same coordinates, parish
   or district) and every research maps it alike; only the place's map crosses, nothing of the family. A place of the
   same name that is not surely the same is offered to the agent as a suggestion; the agent maps only the rest.
-  `strom history adopt --dry-run` says what would be taken.
+  `strom history adopt --dry-run` says what would be taken. The question about turning the events of history on or off
+  says it holds for every research on this computer, and how to change it for one research alone.
 - **The fixes of a research for the Strom app.** The bridge lists what `strom fixes` offers in the research (title,
   what it does, how many items, its state, whether it can be put back), free and without writing anything; the link
   `strom-research://fixes` opens a fix in the research's terminal, where setting it right or putting it back is
@@ -21,19 +22,25 @@ The changes of each version in short. The full notes and the install lines are o
 - **The page of each scan in the Strom app.** The Strom file now gives each source the page of its scan in the online
   archive: the page of its first image, else the source's own address. The Strom app links it for the excerpts the
   file leaves out and for the sources without an excerpt. Only a public web page, never a recordset's address; the
-  standard GEDCOM file keeps the address in the note.
-- **A house number and an age as they were written.** The word for a house number ("No.", "čp.") is put only before
+  standard GEDCOM file keeps the address in the note. The date of the research's version in the Strom file carries its
+  time too, so the app shows the day it was made also around midnight.
+- **A person's own lineage from the Strom app.** Where the Strom app marks that a person founds a lineage of their
+  own or carries none of the family's, `strom sync` keeps it in the research and the Strom file gives it back, so the
+  next send and another device show the same lineages; a merge of two people keeps the mark. The standard GEDCOM file
+  says nothing of it. It needs the Strom app 3.19.0.
+- **A house number, an age and a period as they were written.** The word for a house number ("No.", "čp.") is put only before
   a number standing alone; a street with its number goes into the file as it is. An age of "05y" is read as 5 years.
-  Both come back from the Strom app the same, no edit of the user's.
-- **The question about history says where it holds.** Turning the events of history on or off holds for every
-  research on this computer; the question says so, and how to change it for one research alone.
+  Both come back from the Strom app the same, no edit of the user's. A period the Strom app keeps ("1871/1882", or
+  open at one end) comes into the research as from … to …, never as a date somewhere between.
 - **A weak or refused model of the agent said by the doctor.** When no model is chosen for the research and the
   agent's own default is one the research found weak or refused for its work, `strom doctor` warns and gives the
   command to choose one; it never chooses itself.
 - **strom from npm keeps its channel.** strom installed with npm stays on the channel it was installed from, also
   after a release; a channel chosen with `strom update --channel` is kept for it too.
 - **A failed command takes back only its own.** A command that saved on the way and then failed takes back only what
-  came after its save, so the research never looks changed outside strom.
+  came after its save, so the research never looks changed outside strom. Where writing is refused because the
+  research was changed outside strom, the person reads it in the research's language, with the way out that fits; an
+  agent still reads it in English.
 
 ## 1.23.0
 

package/assets/lang/cs.json

@@ -756,6 +756,10 @@
   "log.surname.reject": "Tvary příjmení nejsou jedné rodiny: {forms}",
   "log.surname.unreject": "Tvary příjmení se smějí znovu navrhnout: {forms}",
   "log.surname.undo": "Tvary příjmení vráceny, jak byly",
+  "log.lineage.founder": "Zakládá vlastní rod: {who}",
+  "log.lineage.nocarry": "Rod nenese: {who}",
+  "log.lineage.none": "Rod zase podle výpočtu: {who}",
+  "log.lineage.undo": "Rod vrácen, jak byl: {who}",
   "log.participant.fix": "Jména kmotrů a svědků oddělena od poznámek: {n}",
   "log.participant.unfix": "Jména kmotrů a svědků vrácena, jak byla: {n}",
   "fix.appshape.resolution": "Platí údaj výzkumu: {value}",
@@ -1398,6 +1402,10 @@
   "ui.sync.do.surname": "zapíše se, jak bylo rozhodnuto v aplikaci",
   "ui.sync.do.surname.kept": "zůstává, jak je ve výzkumu",
   "ui.sync.do.surname.report": "nic se nemění",
+  "ui.sync.lineage.founder": "{n}. Rod: {name} zakládá vlastní rod",
+  "ui.sync.lineage.nocarry": "{n}. Rod: {name} rod nenese",
+  "ui.sync.lineage.none": "{n}. Rod: {name} zase podle výpočtu",
+  "ui.sync.do.lineage": "zapíše se, jak bylo nastaveno v aplikaci",
   "ui.sync.do.part": "doplní se k údaji s odkazem na strom z aplikace",
   "ui.sync.do.part.user": "platí úprava z aplikace (verze výzkumu zůstane v historii)",
   "ui.sync.do.person.cite": "bude ho citovat jméno osoby (vodítko, dokud výzkum záznam nepřečte)",
@@ -1757,6 +1765,10 @@
   "ui.check.streetplaces": "{n, plural, one {# údaj má} few {# údaje mají} other {# údajů má}} v místě ulici nebo číslo domu",
   "ui.error.tree.not-downloaded": "z iCloudu ještě nestaženo: {n, plural, one {# soubor} few {# soubory} other {# souborů}} výzkumu (první: {first}) – nic se nezapsalo",
   "ui.error.tree.not-downloaded.hint": "otevřít složku výzkumu ve Finderu a soubory stáhnout (nebo složku z iCloud Drive vyjmout), pak spustit znovu – ne strom repair",
+  "ui.error.tree.changed-outside": "data výzkumu se změnila mimo strom ({n, plural, one {# problém} few {# problémy} other {# problémů}}): nic se nezapsalo",
+  "ui.error.tree.changed-outside.hint": "strom verify   (podrobnosti)\nstrom repair   (vrátí poslední zapečetěný stav)",
+  "ui.error.tree.changed-outside.keys.hint": "strom verify   (podrobnosti)\nstrom repair, pak strom seal adopt   (vrátí jen to, co se udělalo mimo strom – práce obou klíčů tohoto počítače zůstane)",
+  "ui.error.tree.changed-outside.terminal.hint": "strom verify   (podrobnosti)\nve vlastním terminálu: strom repair, pak strom seal adopt – ten vidí oba klíče a vrátí jen to, co se udělalo mimo strom",
   "ui.export.file": "{file} ({for}) — {persons, plural, one {# osoba} few {# osoby} other {# osob}} · {families, plural, one {# rodina} few {# rodiny} other {# rodin}} · {facts, plural, one {# údaj} few {# údaje} other {# údajů}} · {sources, plural, one {# pramen} few {# prameny} other {# pramenů}}{skipped}",
   "ui.export.for.strom": "pro aplikaci Strom",
   "ui.export.for.strom.images": "pro aplikaci Strom, s obrázky",

package/assets/lang/de.json

@@ -756,6 +756,10 @@
   "log.surname.reject": "Namensformen keiner gemeinsamen Familie: {forms}",
   "log.surname.unreject": "Namensformen dürfen wieder vorgeschlagen werden: {forms}",
   "log.surname.undo": "Namensformen wiederhergestellt, wie sie waren",
+  "log.lineage.founder": "Begründet einen eigenen Stamm: {who}",
+  "log.lineage.nocarry": "Trägt keinen Stamm: {who}",
+  "log.lineage.none": "Stamm wieder wie berechnet: {who}",
+  "log.lineage.undo": "Stamm zurückgesetzt, wie er war: {who}",
   "log.participant.fix": "Namen von Paten und Zeugen von ihren Notizen getrennt: {n}",
   "log.participant.unfix": "Namen von Paten und Zeugen wiederhergestellt, wie sie waren: {n}",
   "fix.appshape.resolution": "Der Wert der Forschung bleibt: {value}",
@@ -1398,6 +1402,10 @@
   "ui.sync.do.surname": "übernommen, wie in der App entschieden",
   "ui.sync.do.surname.kept": "bleibt, wie die Forschung es hat",
   "ui.sync.do.surname.report": "nichts ändert sich",
+  "ui.sync.lineage.founder": "{n}. Stamm: {name} begründet einen eigenen Stamm",
+  "ui.sync.lineage.nocarry": "{n}. Stamm: {name} trägt keinen Stamm",
+  "ui.sync.lineage.none": "{n}. Stamm: {name} wieder wie berechnet",
+  "ui.sync.do.lineage": "übernommen, wie in der App festgelegt",
   "ui.sync.do.part": "wird der Angabe hinzugefügt, mit Verweis auf den eigenen Stammbaum",
   "ui.sync.do.part.user": "Die eigene Änderung gilt (die der Forschung bleibt in ihrer Geschichte)",
   "ui.sync.do.person.cite": "der Name der Person zitiert sie (ein Hinweis, bis die Forschung den Eintrag liest)",
@@ -1757,6 +1765,10 @@
   "ui.check.streetplaces": "{n, plural, one {# Angabe hat} other {# Angaben haben}} eine Straße oder eine Nummer im Ort",
   "ui.error.tree.not-downloaded": "noch nicht aus iCloud geladen: {n, plural, one {# Datei} other {# Dateien}} der Forschung (die erste: {first}) – nichts wurde geschrieben",
   "ui.error.tree.not-downloaded.hint": "den Ordner der Forschung im Finder öffnen und die Dateien laden (oder den Ordner aus iCloud Drive herausnehmen), dann erneut ausführen – nicht strom repair",
+  "ui.error.tree.changed-outside": "die Daten der Forschung wurden außerhalb von strom geändert ({n, plural, one {# Problem} other {# Probleme}}): nichts wurde geschrieben",
+  "ui.error.tree.changed-outside.hint": "strom verify   (Einzelheiten)\nstrom repair   (stellt den letzten versiegelten Stand wieder her)",
+  "ui.error.tree.changed-outside.keys.hint": "strom verify   (Einzelheiten)\nstrom repair, dann strom seal adopt   (macht nur rückgängig, was außerhalb von strom geschah – die Arbeit beider Schlüssel dieses Computers bleibt)",
+  "ui.error.tree.changed-outside.terminal.hint": "strom verify   (Einzelheiten)\nin einem eigenen Terminal: strom repair, dann strom seal adopt – es sieht beide Schlüssel und macht nur rückgängig, was außerhalb von strom geschah",
   "ui.export.file": "{file} ({for}) — {persons, plural, one {# Person} other {# Personen}} · {families, plural, one {# Familie} other {# Familien}} · {facts, plural, one {# Angabe} other {# Angaben}} · {sources, plural, one {# Quelle} other {# Quellen}}{skipped}",
   "ui.export.for.strom": "für die Strom-App",
   "ui.export.for.strom.images": "für die Strom-App, mit Bildern",

package/dist/cli/ui.js

@@ -1357,6 +1357,10 @@ export const UI = {
     "ui.sync.do.surname": "written as decided in the app",
     "ui.sync.do.surname.kept": "stays as the research has it",
     "ui.sync.do.surname.report": "nothing changes",
+    "ui.sync.lineage.founder": "{n}. Lineage: {name} begins a lineage of their own",
+    "ui.sync.lineage.nocarry": "{n}. Lineage: {name} carries no lineage",
+    "ui.sync.lineage.none": "{n}. Lineage: {name} as computed again",
+    "ui.sync.do.lineage": "written as set in the app",
     "ui.sync.do.part": "added to the fact, citing the tree sent",
     "ui.sync.do.part.user": "the edit wins (the research's in its history)",
     "ui.sync.do.person.cite": "their name cites it (a lead until the research reads the record)",
@@ -1725,6 +1729,10 @@ export const UI = {
     "ui.check.streetplaces": "{n, plural, one {# fact holds} other {# facts hold}} a street or a house number in the place",
     "ui.error.tree.not-downloaded": "{n, plural, one {# file} other {# files}} of the research not downloaded from iCloud yet (the first: {first}) — nothing written",
     "ui.error.tree.not-downloaded.hint": "open the research's folder in Finder and download them (or take the folder out of iCloud Drive), then run it again — not strom repair",
+    "ui.error.tree.changed-outside": "the research's data was changed outside strom ({n, plural, one {# problem} other {# problems}}): nothing written",
+    "ui.error.tree.changed-outside.hint": "strom verify   (details)\nstrom repair   (restores the last sealed state)",
+    "ui.error.tree.changed-outside.keys.hint": "strom verify   (details)\nstrom repair, then strom seal adopt   (undoes only what was done outside strom — the work of both keys of this computer stays)",
+    "ui.error.tree.changed-outside.terminal.hint": "strom verify   (details)\nin a terminal of its own: strom repair, then strom seal adopt — it sees both keys and undoes only what was done outside strom",
     "ui.export.file": "{file} ({for}) — {persons, plural, one {# person} other {# persons}} · {families, plural, one {# family} other {# families}} · {facts, plural, one {# fact} other {# facts}} · {sources, plural, one {# source} other {# sources}}{skipped}",
     "ui.export.for.strom": "for the Strom app",
     "ui.export.for.strom.images": "for the Strom app, with images",

package/dist/commands/output.js

@@ -13,8 +13,9 @@ import { UsageError } from "../core/errors.js";
 import { excerptSettings, planExcerpts } from "../core/excerpt.js";
 import { runGit, tracked } from "../core/git.js";
 import { Settings } from "../core/config.js";
-import { appKnowsArchive, appKnowsNoCouple, appShowsHypothesisLinks, appShowsReadings, appShowsOmittedImages, appDecidesConflicts, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsSourceReads, appShowsFactStatus, appShowsStoryDrafts, appTurnsExcerpts, appReadsSurnameGroups } from "../core/stromapp.js";
+import { appKnowsArchive, appKnowsNoCouple, appShowsHypothesisLinks, appShowsReadings, appShowsOmittedImages, appDecidesConflicts, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsSourceReads, appShowsFactStatus, appShowsStoryDrafts, appTurnsExcerpts, appReadsSurnameGroups, appReadsLines } from "../core/stromapp.js";
 import { surnamesForExport } from "../core/surnames.js";
+import { lineMarks } from "../core/lineages.js";
 import { EXCERPT_QUALITIES, EXCERPT_SCOPES } from "../core/model.js";
 import { ui } from "../cli/ui.js";
 import { isAgent } from "../core/which.js";
@@ -98,7 +99,9 @@ export function writeTreeGed(tree, opts) {
     const omitted = !!images && appShowsOmittedImages(new Settings(tree.env, {}), opts.stromVersion);
     // …and the groups of surname forms the user made one family and the suggestions rejected, for an app that reads them
     const surnameGroups = opts.for === "strom" && appReadsSurnameGroups(new Settings(tree.env, {}), opts.stromVersion) ? surnamesForExport(tree) : undefined;
-    const result = exportGedcom(tree, { for: opts.for, ...(surnameGroups ? { surnameGroups } : {}), stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}), ...(clips ? { clips } : {}), ...(research ? { research } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}), ...(hypothesisLinks ? { hypothesisLinks } : {}), ...(conflictSides ? { conflictSides } : {}), ...(readings ? { readings } : {}), ...(omitted ? { omitted: images.omitted } : {}) });
+    // …and the bounds of a lineage the person set, for an app that keeps them
+    const lines = opts.for === "strom" && appReadsLines(new Settings(tree.env, {}), opts.stromVersion) ? lineMarks(tree) : undefined;
+    const result = exportGedcom(tree, { for: opts.for, ...(surnameGroups ? { surnameGroups } : {}), ...(lines ? { lines } : {}), stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}), ...(clips ? { clips } : {}), ...(research ? { research } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}), ...(hypothesisLinks ? { hypothesisLinks } : {}), ...(conflictSides ? { conflictSides } : {}), ...(readings ? { readings } : {}), ...(omitted ? { omitted: images.omitted } : {}) });
     const findings = validateGedcom(result.text, opts.for === "standard" ? { strict: true } : {});
     const file = opts.out ?? gedFile(tree, opts.for, opts.research);
     if (!hasGedErrors(findings) && !tree.dryRun) {

package/dist/commands/sync.js

@@ -94,6 +94,12 @@ function changeLine(tree, c, incoming, lang, readings) {
         const p = tree.get(key);
         return p ? `${(p.names[0] ? `${p.names[0].given} ${p.names[0].surname}` : key).trim()} [${key}]` : key;
     };
+    // a person's bound of a lineage the user set in the app (core/lineages.ts)
+    if (c.line) {
+        const key = c.line.mark === "FOUNDER" ? "ui.sync.lineage.founder" : c.line.mark === "NOCARRY" ? "ui.sync.lineage.nocarry" : "ui.sync.lineage.none";
+        const does = c.takenBack ? "ui.sync.do.taken" : c.action === "report" ? "ui.sync.do.surname.report" : "ui.sync.do.lineage";
+        return `${ui(lang, key, { n: c.n, name: name(c.person) })} → ${ui(lang, does)}`;
+    }
     const who = c.partners ? c.partners.map(name).join(" & ") || c.family || "?" : name(c.person);
     // a partner in their age: the given name
     const short = (key) => (key.startsWith("x:") ? name(key) : (tree.get(key)?.names[0]?.given ?? key));

package/dist/core/changelog.js

@@ -432,6 +432,19 @@ export function changeLines(tree, ops, subject, lang, was, tasks) {
             say(kind === "undo" ? phrase(lang, "log.surname.undo") : kind in { group: 1, ungroup: 1, reject: 1, unreject: 1 } ? phrase(lang, k, { forms: short(forms, 120) }) : changed(o));
             continue;
         }
+        // the bound of a lineage the person set in the Strom app (quality/lineages.json): the person by name, never the summary
+        if (o.op === "lineage.set" || o.op === "lineage.undo") {
+            const m = /^(\S+) (begins a lineage|carries no lineage|lineage as computed)/u.exec(o.summary);
+            const person = who(o.targets[0] ?? m?.[1]);
+            say(o.op === "lineage.undo"
+                ? phrase(lang, "log.lineage.undo", { who: person })
+                : m?.[2] === "begins a lineage"
+                    ? phrase(lang, "log.lineage.founder", { who: person })
+                    : m?.[2] === "carries no lineage"
+                        ? phrase(lang, "log.lineage.nocarry", { who: person })
+                        : phrase(lang, "log.lineage.none", { who: person }));
+            continue;
+        }
         // the names of participants set apart from their notes by strom's fix, or put back (quality/participant-names.json)
         if (o.op === "participant.fix" || o.op === "participant.unfix") {
             const n = /: (\d+) in /u.exec(o.summary)?.[1] ?? String(o.targets.length);

package/dist/core/import.js

@@ -672,17 +672,26 @@ function importLabel(lang) {
 export function isStromJson(data) {
     return !!data && typeof data === "object" && "persons" in data && "partnerships" in data;
 }
-/** Strom flexible date ("~1900", "<1900-05", "1900-05-03") → GEDCOM. */
+/** Strom flexible date ("~1900", "<1900-05", "1900-05-03", a range "1785..1804", a period "1871/1882") → GEDCOM. */
 export function fromFlexDate(flex) {
     if (!flex)
         return undefined;
+    // a period ("1871/1882", "1871/", "/1882"): from the one to the other, each side a plain date
+    const period = /^([^/]*)\/([^/]*)$/.exec(flex.trim());
+    if (period) {
+        const plain = (s) => (/^\d{3,4}(?:-\d{1,2}(?:-\d{1,2})?)?$/.test(s) ? fromFlexDate(s) : undefined);
+        const [a, b] = [period[1] ? plain(period[1]) : "", period[2] ? plain(period[2]) : ""];
+        if (a === undefined || b === undefined || (!a && !b))
+            return undefined;
+        return normalizeDate(a && b ? `FROM ${a} TO ${b}` : a ? `FROM ${a}` : `TO ${b}`);
+    }
     // a range ("1785..1804"): between the two
     const range = /^(.+?)\.\.(.+)$/.exec(flex.trim());
     if (range) {
         const [a, b] = [fromFlexDate(range[1]), fromFlexDate(range[2])];
         return a && b && !/^(ABT|BEF|AFT|BET|FROM|TO) /.test(a) && !/^(ABT|BEF|AFT|BET|FROM|TO) /.test(b) ? normalizeDate(`BET ${a} AND ${b}`) : undefined;
     }
-    const m = /^([~<>])?(\d{3,4})(?:-(\d{2}))?(?:-(\d{2}))?$/.exec(flex.trim());
+    const m = /^([~<>])?(\d{3,4})(?:-(\d{1,2}))?(?:-(\d{1,2}))?$/.exec(flex.trim());
     if (!m)
         return importDate(flex);
     const months = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"];

package/dist/core/integrity.js

@@ -518,9 +518,14 @@ export function assertIntact(tree) {
         : tree.key && errors.some((f) => f.code === "foreign-commit") && lastSealed(tree, tree.key).inTerminal
             ? REPAIR_IN_TERMINAL_HINT
             : undefined;
+    // a person reads it in the research's language (ui.error.tree.changed-outside), the way said as one of three hints
+    const inTerminal = way !== undefined && (way === REPAIR_IN_TERMINAL_HINT || way.startsWith("the user runs in their terminal"));
     throw new StromError(`data was changed outside strom (${counted(errors.length, "problem")}) — refusing to write`, {
         hint: `strom verify   (details)\n${way ?? "strom repair   (restore the last sealed state)"}`,
         details: errors,
+        code: "tree.changed-outside",
+        params: { n: String(errors.length) },
+        ...(way ? { hintCode: inTerminal ? "tree.changed-outside.terminal" : "tree.changed-outside.keys" } : {}),
     });
 }
 /**

package/dist/core/lineages.js

@@ -0,0 +1,147 @@
+// The bounds of a lineage the person set in the Strom app (spec 028; the app's ZADANI_VYZKUM_rody.md): the app computes a
+// lineage (the male line from the oldest bearer of the name) and the person may correct it in two ways — a person who
+// begins a lineage of their own (a founder: their tie to their father does not count for it), a person who carries
+// none (their sons begin lineages). <tree>/quality/lineages.json keeps both lists of people (P…), written whole as a
+// sealed operation of the tree like quality/surnames.json (core/integrity.ts): a change outside strom is an error of
+// strom guard; strom sync undo and the history take it back.
+// Only the person sets them, in the Strom app: strom sync takes them from the app's file (1 _STROM_LINE on a person,
+// 1 _STROM_LINES Y in the header), the Strom file gives them back (gate APP_READS_LINES). No evidence and no fact of a
+// person: they change no name, no parents, no status — a locked person may have one.
+// A person merged since is read as the one merged into (a founder before one who carries none); one taken back has none.
+import path from "node:path";
+import { readJsonIfExists, stringifyCanonical } from "./json.js";
+import { personNow } from "./quality.js";
+import * as git from "./git.js";
+export const LINEAGES_FILE = "quality/lineages.json";
+const PERSON_ID = /^P\d{1,9}$/u;
+/** A person's ID as the research writes it (P12 → P0012); undefined when it is none. */
+function idOf(raw) {
+    if (typeof raw !== "string")
+        return undefined;
+    const id = raw.trim().toUpperCase();
+    if (!PERSON_ID.test(id))
+        return undefined;
+    return id.length < 5 ? `P${id.slice(1).padStart(4, "0")}` : id;
+}
+/** A mark as the Strom file writes it; anything else (a value of a later app) is none. */
+export function lineMarkOf(raw) {
+    const v = raw?.trim().toUpperCase();
+    return v === "FOUNDER" || v === "NOCARRY" ? v : undefined;
+}
+const sorted = (ids) => [...new Set(ids)].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+function listOf(raw) {
+    return Array.isArray(raw) ? sorted(raw.map(idOf).filter((x) => !!x)) : [];
+}
+/** The lists as a file (or a commit's copy of it) holds them; empty when there is none. */
+export function lineagesOf(text) {
+    if (!text)
+        return { lineFounders: [], lineNotCarriers: [] };
+    try {
+        const f = JSON.parse(text);
+        return { lineFounders: listOf(f?.lineFounders), lineNotCarriers: listOf(f?.lineNotCarriers) };
+    }
+    catch {
+        return { lineFounders: [], lineNotCarriers: [] };
+    }
+}
+export function readLineages(tree) {
+    try {
+        const f = readJsonIfExists(path.join(tree.root, ...LINEAGES_FILE.split("/")));
+        return { lineFounders: listOf(f?.lineFounders), lineNotCarriers: listOf(f?.lineNotCarriers) };
+    }
+    catch {
+        return { lineFounders: [], lineNotCarriers: [] };
+    }
+}
+/** The lists at a commit (what the export at it gave the Strom app); undefined when the history has no such commit. */
+export function lineagesAt(tree, head) {
+    if (!/^[0-9a-f]{7,40}$/u.test(head))
+        return undefined;
+    if (git.runGit(tree.root, ["cat-file", "-e", `${head}^{commit}`]).status !== 0)
+        return undefined;
+    return lineagesOf(git.showFile(tree.root, head, LINEAGES_FILE));
+}
+/**
+ * Each person's mark as the research reads it now: by who they are now (merged: the one merged into), a person taken
+ * back (or not in the research) none, a founder before one who carries none.
+ */
+export function lineMarks(tree, file = readLineages(tree)) {
+    const out = new Map();
+    const live = (id) => {
+        const now = personNow(tree, id);
+        const p = tree.get(now);
+        return p && p.type === "person" && !p.retracted ? now : undefined;
+    };
+    for (const id of file.lineFounders) {
+        const p = live(id);
+        if (p)
+            out.set(p, "FOUNDER");
+    }
+    for (const id of file.lineNotCarriers) {
+        const p = live(id);
+        if (p && !out.has(p))
+            out.set(p, "NOCARRY");
+    }
+    return out;
+}
+/** Written whole as a sealed operation of the tree, inside its lock. */
+function writeLineages(tree, next, op) {
+    const founders = sorted(next.lineFounders);
+    const notCarriers = sorted(next.lineNotCarriers).filter((id) => !founders.includes(id));
+    tree.withTreeLock(() => tree.putFile(LINEAGES_FILE, stringifyCanonical({ lineFounders: founders, lineNotCarriers: notCarriers }), { ...op, summary: op.summary.normalize("NFC") }));
+}
+/** A mark as the history says it. */
+export const markSaid = (m) => (m === "FOUNDER" ? "begins a lineage" : m === "NOCARRY" ? "carries no lineage" : "lineage as computed");
+/**
+ * One person's mark set (null: none — the lineage as the app computes it): every ID of the file that is this person now
+ * (one merged into them) taken out of both lists, the person put in the one of the mark. Undefined when nothing changes;
+ * else the mark before, for an undo.
+ */
+export function setLineMark(tree, person, mark, why, op = "lineage.set") {
+    const file = readLineages(tree);
+    const was = lineMarks(tree, file).get(person) ?? null;
+    const theirs = (id) => id === person || personNow(tree, id) === person;
+    const founders = file.lineFounders.filter((id) => !theirs(id));
+    const notCarriers = file.lineNotCarriers.filter((id) => !theirs(id));
+    if (mark === "FOUNDER")
+        founders.push(person);
+    if (mark === "NOCARRY")
+        notCarriers.push(person);
+    const next = { lineFounders: sorted(founders), lineNotCarriers: sorted(notCarriers) };
+    if (JSON.stringify(next) === JSON.stringify({ lineFounders: file.lineFounders, lineNotCarriers: file.lineNotCarriers }))
+        return undefined;
+    writeLineages(tree, next, { op, targets: [person], summary: `${person} ${markSaid(mark)} (${why})` });
+    return { was };
+}
+/**
+ * What the Strom app's marks change in the research. `theirs`: the file's marks by the research's ID (or the file's key
+ * of a new person), undefined where the file says nothing of them (no header mark: an older app); `present`: the people
+ * the file has (a mark is taken away only from one of them); `base`: the marks the research gave the app at
+ * _STROM_HEAD, when it gave them — only what the user changed since counts (a mark they kept as given leaves the
+ * research's word); without one the file's list is the truth, an empty one too.
+ */
+export function planLines(now, theirs, present, base) {
+    if (!theirs)
+        return [];
+    const out = [];
+    const people = sorted([...theirs.keys(), ...now.keys(), ...(base?.keys() ?? [])]);
+    for (const id of people) {
+        const t = theirs.get(id) ?? null;
+        const n = now.get(id) ?? null;
+        if (t === n)
+            continue;
+        // taken away only from someone the file has (one it lacks says nothing of them)
+        if (!t && !present(id))
+            continue;
+        if (base && t === (base.get(id) ?? null))
+            continue;
+        out.push({ person: id, mark: t, was: n });
+    }
+    return out;
+}
+/** A change of a sync taken back: the person's mark before it again — unless it changed since (the newer word stands). */
+export function undoLineMark(tree, person, mark, was, why) {
+    if ((lineMarks(tree).get(person) ?? null) !== mark)
+        return false;
+    return !!setLineMark(tree, person, was, why, "lineage.undo");
+}

package/dist/core/live.js

@@ -9,7 +9,9 @@
 //
 //   GET <token>/status     the tree, its researches, who is at work, what waits; what the research takes from
 //                          the app (accepts). ?poll=1: the app asking now and then — the bridge's idle time goes on
-//   GET <token>/tree.ged   the tree for the Strom app, as it is now, each entry with its image (the settings excerpts.*)
+//   GET <token>/tree.ged   the tree for the Strom app, as it is now, each entry with its image (the settings excerpts.*);
+//                          for an app that keeps them the bounds of a lineage the person set (_STROM_LINE, _STROM_LINES;
+//                          feature lineage.read: strom sync takes them back)
 //   GET <token>/images.ged the same (the address an older strom gave)
 //   GET <token>/log        what the research saved, newest first (each commit: when, what, for which task;
 //                          text: its lines as the user reads them, kinds: what each is about, sources: the S… each
@@ -215,8 +217,9 @@ import { knownNewerVersion, updateChannel } from "./update.js";
 import { whatsNew } from "./whatsnew.js";
 import { gitProgram, runGit } from "./git.js";
 import { RECENT_HOURS, recentChanges, recentNow } from "./recent.js";
-import { appKnowsArchive, appKnowsNoCouple, appShowsHypothesisLinks, appShowsOmittedImages, appShowsReadings, appDecidesConflicts, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsFactStatus, appShowsSourceReads, appShowsStoryDrafts, appTurnsExcerpts, appReadsSurnameGroups, appUrlSetting, isAppVersion, isStromAppOrigin, stromAppState } from "./stromapp.js";
+import { appKnowsArchive, appKnowsNoCouple, appShowsHypothesisLinks, appShowsOmittedImages, appShowsReadings, appDecidesConflicts, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsFactStatus, appShowsSourceReads, appShowsStoryDrafts, appTurnsExcerpts, appReadsSurnameGroups, appReadsLines, appUrlSetting, isAppVersion, isStromAppOrigin, stromAppState } from "./stromapp.js";
 import { suggestSurnames, surnamesForExport } from "./surnames.js";
+import { lineMarks } from "./lineages.js";
 import { judgePairs, pairsOf, PAIRS_MAX } from "./duplicates.js";
 import { askOf, qualityRev, readDismissed } from "./quality.js";
 import { Settings } from "./config.js";
@@ -925,7 +928,7 @@ function idsOf(applied, known) {
     return Object.keys(ids.persons).length || Object.keys(ids.sources).length ? { ids } : {};
 }
 /** What the bridge does that an app may ask about (each added once, never taken away). */
-export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes", "hypothesis.links", "status.recent", "spend.readers", "hypothesis.intree", "archive.permission", "task.check", "waiting.groups", "waiting.sent", "waiting.note", "batch.kept", "live.end", "whats.new", "terminal.choice", "person.marriedSurname", "phone", "read.now", "read.sync", "excerpt.get", "log.sources", "material.assign", "material.thumb", "seal.foreign", "tree.state", "disk.full", "tree.notDownloaded", "sync.removed", "tree.kind", "experiments", "experiments.off", "experiments.link", "experiments.split", "history.events", "history.hide", "experiments.pace", "history.first", "history.regions", "history.hide.all", "history.skip", "history.map", "history.delete", "history.delete.restore", "stories.history", "history.place", "surnames.suggest", "surnames.read", "duplicates.judge", "quality.dismiss", "quality.read", "person.primary", "fixes.list"];
+export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes", "hypothesis.links", "status.recent", "spend.readers", "hypothesis.intree", "archive.permission", "task.check", "waiting.groups", "waiting.sent", "waiting.note", "batch.kept", "live.end", "whats.new", "terminal.choice", "person.marriedSurname", "phone", "read.now", "read.sync", "excerpt.get", "log.sources", "material.assign", "material.thumb", "seal.foreign", "tree.state", "disk.full", "tree.notDownloaded", "sync.removed", "tree.kind", "experiments", "experiments.off", "experiments.link", "experiments.split", "history.events", "history.hide", "experiments.pace", "history.first", "history.regions", "history.hide.all", "history.skip", "history.map", "history.delete", "history.delete.restore", "stories.history", "history.place", "surnames.suggest", "surnames.read", "lineage.read", "duplicates.judge", "quality.dismiss", "quality.read", "person.primary", "fixes.list"];
 /** /status recent, when it is ready. */
 function recentOf(root, env, head) {
     const recent = head ? recentNow(root, env, head) : undefined;
@@ -1664,6 +1667,8 @@ export function serveLive(root, env) {
             const omitted = !!images && appShowsOmittedImages(new Settings(env, {}), version);
             // …and the groups of surname forms and the suggestions rejected, for an app that reads them (strom sync takes them back)
             const surnameGroups = appReadsSurnameGroups(new Settings(env, {}), version) ? surnamesForExport(tree) : undefined;
+            // …and the bounds of a lineage the person set, for an app that keeps them (strom sync takes them back)
+            const lines = appReadsLines(new Settings(env, {}), version) ? lineMarks(tree) : undefined;
             left = {
                 head: h,
                 level: set?.quality ?? LEVELS[1].name,
@@ -1674,7 +1679,7 @@ export function serveLive(root, env) {
                 head: h,
                 links: offered.join(" "),
                 version: version ?? "",
-                text: exportGedcom(tree, { for: "strom", ...(h ? { head: h } : {}), ...(surnameGroups ? { surnameGroups } : {}), ...(images ? { excerpts: images.of } : {}), ...(opens ? { clips: true, research: true } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}), ...(hypothesisLinks ? { hypothesisLinks } : {}), ...(conflictSides ? { conflictSides } : {}), ...(readings ? { readings } : {}), ...(omitted ? { omitted: images.omitted } : {}), ...(offered.length ? { links: offered, ...(linkScheme(env) !== LINK_SCHEME ? { linkScheme: linkScheme(env) } : {}) } : {}) }).text,
+                text: exportGedcom(tree, { for: "strom", ...(h ? { head: h } : {}), ...(surnameGroups ? { surnameGroups } : {}), ...(lines ? { lines } : {}), ...(images ? { excerpts: images.of } : {}), ...(opens ? { clips: true, research: true } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}), ...(hypothesisLinks ? { hypothesisLinks } : {}), ...(conflictSides ? { conflictSides } : {}), ...(readings ? { readings } : {}), ...(omitted ? { omitted: images.omitted } : {}), ...(offered.length ? { links: offered, ...(linkScheme(env) !== LINK_SCHEME ? { linkScheme: linkScheme(env) } : {}) } : {}) }).text,
             };
         }
         return h;
@@ -3903,7 +3908,8 @@ export function serveLive(root, env) {
                         const tree = Tree.open(root, env);
                         const settings = new Settings(env, {});
                         const rev = historyShown(tree, settings) ? historyRevNow(tree, settings, h, historyRev(tree, settings.shared()?.value, settings)) : undefined;
-                        if (rev && historySeen && historySeen.head === h && historySeen.rev !== rev)
+                        // (a commit made since the head was read changes the rev too: its change says it, never a history of its own)
+                        if (rev && historySeen && historySeen.head === h && historySeen.rev !== rev && tip(root).head === h)
                             send("history", { rev });
                         historySeen = rev ? { rev, head: h } : undefined;
                     }

package/dist/core/phrases.js

@@ -318,6 +318,10 @@ export const PHRASES = {
     "log.surname.reject": "Surname forms of no one family: {forms}",
     "log.surname.unreject": "Surname forms may be suggested again: {forms}",
     "log.surname.undo": "Surname forms put back as they were",
+    "log.lineage.founder": "Begins a lineage of their own: {who}",
+    "log.lineage.nocarry": "Carries no lineage: {who}",
+    "log.lineage.none": "Lineage as computed again: {who}",
+    "log.lineage.undo": "Lineage put back as it was: {who}",
     "log.participant.fix": "Names of godparents and witnesses set apart from their notes: {n}",
     "log.participant.unfix": "Names of godparents and witnesses put back as they were: {n}",
     "fix.appshape.resolution": "The research's value stays: {value}",

package/dist/core/stromapp.js

@@ -558,6 +558,26 @@ export function appKnowsPrimaryName(settings, version) {
         return compareVersions(v, APP_PRIMARY_NAME_BETA) >= 0;
     return !!APP_KNOWS_PRIMARY_NAME && compareVersions(v, APP_KNOWS_PRIMARY_NAME) >= 0;
 }
+/**
+ * The first Strom app that keeps the person's own bounds of a lineage (spec 028; the app's ZADANI_VYZKUM_rody.md):
+ * it reads 1 _STROM_LINE FOUNDER|NOCARRY on a person and 1 _STROM_LINES Y in the header of the Strom file, keeps them
+ * as its lineageOverrides and sends them back. An older app skips the tags and sends none back (a send of it says
+ * nothing of them: no header mark). Released with the app 3.19.0; an app of unknown version (strom app from a
+ * terminal) stays off, as the groups of a surname's forms; another copy of the app (its beta, its development) gets
+ * them from APP_READS_LINES_BETA.
+ */
+export const APP_READS_LINES = "3.19.0";
+/** The first beta of the app that reads and writes the bounds of a lineage (another copy of the app gets them from it). */
+export const APP_READS_LINES_BETA = "3.19.0-beta.4";
+/** Does the Strom app of this version keep the bounds of a lineage the person set (_STROM_LINE, _STROM_LINES)? */
+export function appReadsLines(settings, version, gate = APP_READS_LINES) {
+    const v = version?.trim();
+    if (!v || !isAppVersion(v))
+        return false;
+    if (anotherCopy(settings) && APP_READS_LINES_BETA)
+        return compareVersions(v, APP_READS_LINES_BETA) >= 0;
+    return !!gate && compareVersions(v, gate) >= 0;
+}
 /** The address that opens the Strom app to send the user's edited tree to the bridge. */
 export function sendAppUrl(bridge, settings) {
     return `${stromAppUrl(settings)}?send=${encodeURIComponent(bridge)}`;

package/dist/core/sync.js

@@ -42,7 +42,8 @@ import * as git from "./git.js";
 import { now, Tree, typeOfId } from "./tree.js";
 import { actsAsArchive } from "./state.js";
 import { appSides } from "./conflicts.js";
-import { APP_DATA_SEX_UNKNOWN, appKeepsPeriods, appKnowsPrimaryName, appReadsSurnameGroups, isAppVersion } from "./stromapp.js";
+import { APP_DATA_SEX_UNKNOWN, appKeepsPeriods, appKnowsPrimaryName, appReadsLines, appReadsSurnameGroups, isAppVersion } from "./stromapp.js";
+import { lineMarkOf, lineMarks, lineagesAt, planLines, setLineMark, undoLineMark } from "./lineages.js";
 import { Settings } from "./config.js";
 import { applySurnameChange, formsSaid, planSurnames, readMarkLines, readSurnames, surnamesAt, undoSurnameChange } from "./surnames.js";
 import { SURNAME_GROUPS_MARK, SURNAME_REJECTIONS_MARK } from "../gedcom/export.js";
@@ -585,6 +586,8 @@ export function readGedcom(text) {
         }
         // the sources of the person: the Strom app's (1 SOUR), the research's of their names
         const cites = [...children(r, "SOUR"), ...children(r, "NAME").flatMap((n) => children(n, "SOUR"))].map(cite).filter((x) => !!x);
+        // their bound of a lineage (a value of a later app: none)
+        const line = children(r, "_STROM_LINE").map((n) => lineMarkOf(n.value)).reduce((a, m) => (a === "FOUNDER" || m === "FOUNDER" ? "FOUNDER" : (a ?? m)), undefined);
         persons.set(key, {
             key,
             names,
@@ -596,6 +599,7 @@ export function readGedcom(text) {
             ...(titles ? { titles } : {}),
             ...(married.length ? { married } : {}),
             ...(primary ? { primary } : {}),
+            ...(line ? { line } : {}),
         });
     }
     // how a child belongs to a family (the child's FAMC + PEDI: adopted, foster, step): none said is birth
@@ -664,10 +668,12 @@ export function readGedcom(text) {
     const again = val(head, "_STROM_AGAIN")?.trim();
     const appVersion = fromApp.app ? val(children(head, "SOUR")[0], "VERS")?.trim() : undefined;
     const surnames = head ? surnameMarksOf(head) : undefined;
+    const lines = /^y(es)?$/i.test(val(head, "_STROM_LINES")?.trim() ?? "");
     return {
         format: "gedcom",
         ...(appVersion ? { appVersion } : {}),
         ...(surnames ? { surnames } : {}),
+        ...(lines ? { lines: true } : {}),
         ...(treeId ? { treeId } : {}),
         ...(at ? { head: at } : {}),
         persons,
@@ -2623,6 +2629,25 @@ export function planSync(tree, incoming, edits, opts = {}) {
         const action = !here || (given && samePoint(given, here)) || mirror ? "set" : "pick";
         push({ kind: "place.coords", action, place: { ...p, ...(mine ? { id: mine.id } : {}), ...(here ? { was: here } : {}) } });
     }
+    // the bounds of a lineage the user set in the app: where the file says them (_STROM_LINES), against what the research
+    // gave the app at _STROM_HEAD when it gave them (an app that keeps them: APP_READS_LINES) — else the file's are the truth
+    if (incoming.lines) {
+        const theirs = new Map();
+        const present = new Set();
+        for (const [key, p] of incoming.persons) {
+            const id = key.startsWith("x:") ? key : resolve(tree, key)?.id;
+            if (!id)
+                continue;
+            present.add(id);
+            if (p.line && theirs.get(id) !== "FOUNDER")
+                theirs.set(id, p.line);
+        }
+        const given = incoming.head && appReadsLines(new Settings(tree.env, {}), incoming.appVersion) ? lineagesAt(tree, incoming.head) : undefined;
+        for (const c of planLines(lineMarks(tree), theirs, (id) => !partial && present.has(id), given ? lineMarks(tree, given) : undefined)) {
+            const p = incoming.persons.get(c.person);
+            push({ kind: "lineage.mark", action: "set", person: c.person, ...(p?.names[0] ? { name: p.names[0] } : {}), text: c.mark ?? "", line: c });
+        }
+    }
     if (incoming.head && opts.takenBack !== false && !sentAgain)
         takenBack(tree, incoming, edits, changes);
     // a send of the app (`sent`: it came through the bridge) with nothing to stand on (no _STROM_HEAD, no _STROM_SINCE the research still has —
@@ -4273,6 +4298,18 @@ export function applySync(tree, plan, incoming, source, only) {
         if (r)
             applied.push({ do: "surname.set", id: r.list, before: JSON.stringify({ added: r.added ?? null, removed: r.removed }) });
     }
+    // the bounds of a lineage the user set in the app (quality/lineages.json): a new person's by the ID they got
+    for (const c of plan.changes.filter((x) => x.line && taken(x))) {
+        const id = who(c.line.person);
+        const p = id ? resolve(tree, id) : undefined;
+        if (!p) {
+            skipped.push({ n: c.n, kind: c.kind, why: `${c.line.person} is not in the research`, code: "person.no-match", params: { person: c.line.person } });
+            continue;
+        }
+        const r = setLineMark(tree, p.id, c.line.mark, reason);
+        if (r)
+            applied.push({ do: "lineage.set", id: p.id, before: JSON.stringify({ was: r.was, mark: c.line.mark }) });
+    }
     return { applied, changes: changes - skipped.length, skipped, ...(asked.length ? { asked } : {}) };
 }
 /** Where a task to check a reading of a document confirmed in the app comes from (one per person and its sources). */
@@ -4971,6 +5008,11 @@ export function undoSync(tree, input) {
                 undoSurnameChange(tree, a.id === "rejected" ? "rejected" : "groups", b.added ?? undefined, b.removed ?? [], reason);
                 break;
             }
+            case "lineage.set": {
+                const b = JSON.parse(String(a.before ?? "{}"));
+                undoLineMark(tree, a.id, b.mark ?? null, b.was ?? null, reason);
+                break;
+            }
         }
         n++;
     }

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.24.0-beta.1";
+export const VERSION = "1.24.0";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/dist/gedcom/export.js

@@ -226,11 +226,16 @@ export function exportGedcom(tree, opts = {}) {
             if (opts.linkScheme)
                 w.line(2, "_SCHEME", opts.linkScheme);
         }
+        // when the research wrote it, to the second in UTC (the app shows the local day; DATE stays the day): every app takes
+        // its first ten characters as the day before (N23)
         if (opts.research)
-            w.line(1, "_STROM_ASOF", new Date().toISOString().slice(0, 10));
+            w.line(1, "_STROM_ASOF", asOfNow());
         // an archive (no agent; the app's data written as they come): for an app that knows it (APP_KNOWS_ARCHIVE)
         if (opts.archive && tree.config.mode === "archive")
             w.line(1, "_STROM_MODE", "archive");
+        // the file says the bounds of a lineage the person set, all of them (none: none), for an app that keeps them
+        if (opts.lines)
+            w.line(1, "_STROM_LINES", "Y");
     }
     w.line(1, "SUBM", "@U1@");
     w.line(1, "GEDC");
@@ -301,6 +306,10 @@ export function exportGedcom(tree, opts = {}) {
             }
         }
         w.line(1, "SEX", p.sex);
+        // the person's bound of a lineage (the Strom profile, an app that keeps it)
+        const line = opts.for === "strom" ? opts.lines?.get(p.id) : undefined;
+        if (line)
+            w.line(1, "_STROM_LINE", line);
         w.line(1, "REFN", p.id);
         w.line(2, "TYPE", REFN_TYPE);
         const deferred = [];
@@ -953,3 +962,7 @@ function gedDate(d) {
     const m = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"][d.getUTCMonth()];
     return `${d.getUTCDate()} ${m} ${d.getUTCFullYear()}`;
 }
+/** When the research wrote the file (1 _STROM_ASOF): ISO 8601 to the second in UTC ("2026-10-31T06:12:05Z"). */
+export function asOfNow(d = new Date()) {
+    return `${d.toISOString().slice(0, 19)}Z`;
+}

package/dist/gedcom/validate.js

@@ -14,12 +14,12 @@ const INDI_EVENTS = [
 const FAM_EVENTS = ["MARR", "DIV", "MARB", "MARC", "MARL", "MARS", "ANUL", "DIVF", "ENGA", "CENS", "RESI", "EVEN", "NCHI"];
 /** Allowed child tags by parent context ("INDI", "INDI.BIRT", …). CONC/CONT are allowed under anything with text. */
 const CHILDREN = {
-    HEAD: ["SOUR", "DEST", "DATE", "SUBM", "SUBN", "FILE", "COPR", "GEDC", "CHAR", "LANG", "PLAC", "NOTE", "_STROM_TREE", "_STROM_HEAD", "_STROM_LINKS", "_STROM_ASOF", "_STROM_MODE"],
+    HEAD: ["SOUR", "DEST", "DATE", "SUBM", "SUBN", "FILE", "COPR", "GEDC", "CHAR", "LANG", "PLAC", "NOTE", "_STROM_TREE", "_STROM_HEAD", "_STROM_LINKS", "_STROM_ASOF", "_STROM_MODE", "_STROM_LINES"],
     "HEAD.SOUR": ["VERS", "NAME", "CORP", "DATA"],
     "HEAD._STROM_LINKS": ["_SCHEME"],
     "HEAD.GEDC": ["VERS", "FORM"],
     "HEAD.DATE": ["TIME"],
-    INDI: ["NAME", "SEX", "FAMC", "FAMS", "NOTE", "SOUR", "REFN", "ASSO", "ALIA", "OBJE", "RESN", "RIN", "CHAN", "_STORY", "_STROM_CONFLICT", "_STROM_HYPO", "_STROM_SEARCHED", "_STROM_EDGE", "_STROM_ISLAND", ...INDI_EVENTS],
+    INDI: ["NAME", "SEX", "FAMC", "FAMS", "NOTE", "SOUR", "REFN", "ASSO", "ALIA", "OBJE", "RESN", "RIN", "CHAN", "_STORY", "_STROM_CONFLICT", "_STROM_HYPO", "_STROM_SEARCHED", "_STROM_EDGE", "_STROM_ISLAND", "_STROM_LINE", ...INDI_EVENTS],
     "INDI._STROM_CONFLICT": ["TYPE", "TITL", "STAT", "_STROM_TAKE", "VAL", "DECI"],
     "INDI._STROM_HYPO": ["TITL", "STAT", "_CHOSEN", "NOTE", "_VAR"],
     // what a variant of a hypothesis would connect (the Strom profile)
@@ -82,6 +82,8 @@ const EXTENSIONS = new Set([
     "_STROM_READ", "_STROM_VERIFIED", "_STROM_READING", "_STROM_ENTRY", "_STROM_STATUS",
     // an excerpt's original by its content, and how its picture lies
     "_STROM_SHA", "_STROM_ORIENT",
+    // the bounds of a lineage the person set (on a person), and the header's mark that the file says them
+    "_STROM_LINE", "_STROM_LINES",
 ]);
 /** Context of the children of the last tag in `anc` (the ancestors of a line). */
 function contextOf(anc) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.24.0-beta.1",
+  "version": "1.24.0",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
     "runtime": {
       "name": "node",
       "version": ">=24",
-      "onFail": "error"
+      "onFail": "warn"
     }
   },
   "scripts": {
@@ -57,8 +57,5 @@
   "devDependencies": {
     "@types/node": "^22.20.4",
     "typescript": "^7.0.2"
-  },
-  "publishConfig": {
-    "tag": "beta"
   }
 }