strom-research 1.19.0-beta.5 → 1.19.0-beta.7

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.19.0
 
-*Připravuje se: bety do 1.19.0-beta.5. Oddíl bude úplný s vydáním.*
+*Připravuje se: bety do 1.19.0-beta.7. Oddíl bude úplný s vydáním.*
 
 - **Na archiv, který zmlkl, se čeká, místo opakovaných dotazů.** Když archiv přestane odpovídat, strom ho nechá na
   pokoji hodinu — a když týž den mlčí dál, dvě a pak čtyři hodiny — a agent se dozví, do kdy: mezitím dělá
@@ -25,20 +25,26 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 - **Dokument se přečte spolehlivěji.** Čtenář zapisuje čtení do své zprávy průběžně, a čtení dvou čtenářů, kde četl
   jen jeden, to tak řekne — nikdy, že se shodují.
 - **Propojení s telefonem čeká na výzkum, neříká se jako chyba.** Než se po spuštění počítače spustí výzkum, `strom
-  phone` i nastavení řeknou, že propojení je zapnuté a jeho server se znovu spustí se spuštěním výzkumu.
+  phone` i nastavení řeknou, že propojení je zapnuté a jeho server se znovu spustí se spuštěním výzkumu. Na iPhonu
+  zůstane list fotek při psaní osoby nebo poznámky nad klávesnicí a nabízené osoby na očích; server telefonu se spustí
+  jednou, i když ho spouští několik naráz.
 - **Opravy vlastních chyb stromu k rozhodnutí.** Když strom zjistí, že některá jeho dřívější verze ve výzkumu něco
   udělala špatně, `strom fixes` a Nastavení → Údržba → Opravy řeknou, o co jde, co se našlo a co by napravení udělalo,
   i jak je náročné; bez souhlasu se nestane nic a odmítnutí platí. První: slepá čtení ze zmenšeného snímku tam, kde
   byla ostřejší část — přečtou se znovu vedle starých, nejdřív na několika, nic se nepřepíše, rozdíl se stane úkolem.
-  Druhá: po změně modelu nebo agenta pro čtení dřívější čtení, která stojí za nové přečtení — s otevřenými místy,
-  s neshodou čtenářů, s otevřeným rozporem, nepotvrzená u pramene; řečeno jako „četl model X, teď se čte modelem Y“,
-  nabídnuto jednou na agenta a model, každé se přečte znovu tak, jak se četlo (snímky jednoho čtení spolu, zkouška
-  i část vždy z celých čtení). Počítá se v čteních s jejich místy a náročnost ve voláních čtenáře; nabízí se po
-  stupních — jen sporná (rozchod čtenářů, otevřený rozpor, nepotvrzené u pramene), s přímou linií, nebo všechna —
-  každý s tím, co stojí, nejužší první; data a svědci jen řadí. Napravit může i jiný připravený agent nebo model
-  (`strom fixes run <id> --agent <a> --model <m>`), s tím, kdo četl dřív; ten, kdo tu číst nemůže, se odmítne hned
-  i s těmi, kdo mohou. Čas napravení se zaokrouhluje nahoru a po zkoušce se přepočítá podle čtení, jak běžela
-  souběžně.
+  Čtení se porovnají podle přečteného — jmen, dat a čísel přepisu, ne slov komentáře čtenáře (i v němčině, kde má
+  velké písmeno každé podstatné jméno) — a úkol jednou větou řekne, který údaj se liší; kde jméno může jen začínat
+  větu, čtení se za shodná nevydávají. Když není co číst znovu, `strom fixes run` to řekne. Druhá: po změně modelu nebo agenta pro čtení dřívější čtení, která stojí za nové přečtení
+  — s otevřenými místy, s neshodou čtenářů, s otevřeným rozporem, nepotvrzená u pramene; řečeno jako „četl model X,
+  teď se čte modelem Y“, nabídnuto jednou na agenta a model, každé se přečte znovu tak, jak se četlo (snímky jednoho
+  čtení spolu, zkouška i část vždy z celých čtení). Počítá se v čteních s jejich místy a náročnost ve voláních
+  čtenáře; nabízí se po stupních — jen sporná (rozchod čtenářů, otevřený rozpor, nepotvrzené u pramene), s přímou
+  linií, nebo všechna — každý s tím, co stojí, nejužší první; data a svědci jen řadí. Napravit může i jiný připravený
+  agent nebo model (`strom fixes run <id> --agent <a> --model <m>`), s tím, kdo četl dřív; ten, kdo tu číst nemůže, se
+  odmítne hned i s těmi, kdo mohou. Čas napravení se zaokrouhluje nahoru a po zkoušce se přepočítá podle čtení, jak
+  běžela souběžně.
+- **Velikosti tak, jak je píše jazyk výzkumu.** `strom pack`, odebrání rodokmenu i menu uvádějí velikost balíku,
+  zálohy nebo snímků jako všude jinde (1,5 MB, u malých 24 kB), nikdy „0.0 MB“.
 
 ## 1.18.0
 
@@ -98,7 +104,8 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   poznámky: výzkum si nechá svůj text. Místo nebo jiný údaj delší než řádek souboru GEDCOM (255 bajtů) už nezastaví
   jeho zápis a žádné emoji se nerozdělí tam, kde dlouhý řádek pokračuje. S `excerpts.for all` dostane v aplikaci Strom
   výřez i pramen, který zatím nikdo necituje, pokud se vedle citovaných vejde do limitu – citované se kvůli němu
-  nezmenší; co se nevešlo, se řekne.
+  nezmenší; co se nevešlo, se řekne. Aplikace Strom se dozví, které obrazy pramene výzkum má, ale soubor je vynechal,
+  a na vyžádání si je z výzkumu načte — pramen po prameni, nebo všechny najednou i s tím, kolik jich je a jak asi velké.
 
 ## 1.17.0
 

package/CHANGELOG.de.md

@@ -7,7 +7,7 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.19.0
 
-*In Vorbereitung: die Betas bis 1.19.0-beta.5. Der Abschnitt ist mit dem Release vollständig.*
+*In Vorbereitung: die Betas bis 1.19.0-beta.7. Der Abschnitt ist mit dem Release vollständig.*
 
 - **Auf ein verstummtes Archiv wird gewartet, statt es immer wieder zu fragen.** Antwortet ein Archiv nicht mehr,
   lässt strom es eine Stunde in Ruhe — zwei, dann vier, wenn es am selben Tag still bleibt — und der Agent erfährt, bis
@@ -29,22 +29,30 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   Lesung zweier Leser, bei der nur einer las, sagt das so — nie, dass sie übereinstimmen.
 - **Die Verbindung mit dem Telefon wartet auf die Forschung, nicht als Fehler genannt.** Bevor die Forschung nach dem
   Neustart des Computers startet, sagen `strom phone` und die Einstellungen, dass die Verbindung an ist und ihr Server
-  mit der Forschung wieder startet.
+  mit der Forschung wieder startet. Auf einem iPhone bleibt das Blatt der Fotos beim Tippen einer Person oder Notiz über
+  der Tastatur, die angebotenen Personen im Blick; der Server des Telefons startet einmal, auch wenn ihn mehrere
+  zugleich starten.
 - **Korrekturen eigener Fehler von strom zur Entscheidung.** Findet strom, dass eine frühere Version von ihm in einer
-  Forschung etwas falsch gemacht hat, sagen `strom fixes` und Einstellungen → Wartung → Korrekturen, worum es geht, was
-  gefunden wurde und was eine Behebung täte, auch wie aufwendig sie ist; ohne Ja geschieht nichts, ein Nein bleibt.
-  Die erste: blinde Lesungen aus dem verkleinerten Scan, wo es einen schärferen Teil gab — neben den alten noch einmal
-  gelesen, zuerst an einigen, nichts überschrieben, ein Unterschied wird zur Aufgabe. Die zweite: nach einem Wechsel
-  des Lesemodells oder Agenten die früheren Lesungen, die ein neues Lesen lohnen — mit offenen Stellen, uneinigen
-  Lesern, einem offenen Widerspruch, an der Quelle nicht bestätigt; gesagt als „gelesen von Modell X, jetzt liest
-  Modell Y“, einmal je Agent und Modell gefragt, jede so neu gelesen, wie sie gelesen wurde (die Bilder einer Lesung
-  zusammen, ein Versuch oder ein Teil immer aus ganzen Lesungen). Gezählt in Lesungen mit ihren Stellen, der Aufwand
-  in Leseaufrufen; angeboten nach Stufen — nur die strittigen (uneinige Leser, ein offener Widerspruch, an der Quelle
-  nicht bestätigt), mit der direkten Linie oder alle —, jede mit dem, was sie kostet, die engste zuerst; Daten und
-  Zeugen ordnen nur. Beheben kann auch ein anderer bereiter Agent oder ein anderes Modell
-  (`strom fixes run <id> --agent <a> --model <m>`), mit dem, der vorher las; einer, der hier nicht lesen kann, wird
-  sofort abgelehnt, mit denen, die es können. Die Zeit einer Behebung wird aufgerundet und nach dem Versuch nach den
-  nebeneinander gelaufenen Lesungen neu gemessen.
+  Forschung etwas falsch gemacht hat, sagen `strom fixes` und Einstellungen → Wartung → Korrekturen, worum es geht,
+  was gefunden wurde und was eine Behebung täte, auch wie aufwendig sie ist; ohne Ja geschieht nichts, ein Nein
+  bleibt. Die erste: blinde Lesungen aus dem verkleinerten Scan, wo es einen schärferen Teil gab — neben den alten
+  noch einmal gelesen, zuerst an einigen, nichts überschrieben, ein Unterschied wird zur Aufgabe. Verglichen wird, was
+  gelesen wurde — die Namen, Daten und Zahlen der Abschrift, nicht die Worte des Kommentars (auch auf Deutsch, wo
+  jedes Substantiv groß geschrieben wird) —, und die Aufgabe sagt in einem Satz, welche Angabe abweicht; wo ein Name
+  nur einen Satz beginnen kann, gelten die Lesungen nicht als gleich. Gibt es nichts neu zu lesen, sagt `strom fixes
+  run` das. Die zweite: nach einem Wechsel des Lesemodells oder Agenten die früheren
+  Lesungen, die ein neues Lesen lohnen — mit offenen Stellen, uneinigen Lesern, einem offenen Widerspruch, an der
+  Quelle nicht bestätigt; gesagt als „gelesen von Modell X, jetzt liest Modell Y“, einmal je Agent und Modell gefragt,
+  jede so neu gelesen, wie sie gelesen wurde (die Bilder einer Lesung zusammen, ein Versuch oder ein Teil immer aus
+  ganzen Lesungen). Gezählt in Lesungen mit ihren Stellen, der Aufwand in Leseaufrufen; angeboten nach Stufen — nur
+  die strittigen (uneinige Leser, ein offener Widerspruch, an der Quelle nicht bestätigt), mit der direkten Linie oder
+  alle —, jede mit dem, was sie kostet, die engste zuerst; Daten und Zeugen ordnen nur. Beheben kann auch ein anderer
+  bereiter Agent oder ein anderes Modell (`strom fixes run <id> --agent <a> --model <m>`), mit dem, der vorher las;
+  einer, der hier nicht lesen kann, wird sofort abgelehnt, mit denen, die es können. Die Zeit einer Behebung wird
+  aufgerundet und nach dem Versuch nach den nebeneinander gelaufenen Lesungen neu gemessen.
+- **Größen, wie die Sprache der Forschung sie schreibt.** `strom pack`, das Entfernen eines Stammbaums und das Menü
+  nennen die Größe eines Pakets, einer Sicherung oder der Bilder wie überall sonst (1,5 MB, bei kleinen 24 kB), nie
+  „0.0 MB“.
 
 ## 1.18.0
 
@@ -116,7 +124,9 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   GEDCOM-Datei (255 Bytes), hält das Schreiben der Datei nicht mehr auf, und kein Emoji wird dort geteilt, wo eine
   lange Zeile weitergeht. Mit `excerpts.for all` bekommt auch eine Quelle, die noch niemand zitiert, in der Strom-App
   ihren Ausschnitt, soweit er neben den zitierten unter die Grenze passt – die zitierten werden dafür nie kleiner; was
-  nicht passte, wird gesagt.
+  nicht passte, wird gesagt. Die Strom-App erfährt, welche Bilder einer Quelle die Forschung hat, ihre Datei aber
+  wegließ, und lädt sie bei Bedarf aus der Forschung — Quelle für Quelle oder alle auf einmal, mit Anzahl und etwa
+  ihrer Größe.
 
 ## 1.17.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.19.0
 
-*In preparation: the betas up to 1.19.0-beta.5. The section is complete with the release.*
+*In preparation: the betas up to 1.19.0-beta.7. The section is complete with the release.*
 
 - **An archive that went silent is waited for, not asked again and again.** When an archive stops answering, strom
   leaves it alone for an hour — two, then four when it stays silent the same day — and the agent hears until when:
@@ -28,20 +28,26 @@ The changes of each version in short. The full notes and the install lines are o
   only one read says so, never that they agree.
 - **The phone connection waits for the research, not said as an error.** Before the research starts after the computer
   started again, `strom phone` and the settings say the connection is on and its server starts again with the research.
+  On an iPhone the sheet of photos stays above the keyboard while a person or a note is typed, the persons offered in
+  sight; the phone's server starts once, also when several start it at the same moment.
 - **Fixes of strom's own mistakes, offered to decide.** When strom finds that an earlier version of its own did
   something wrong in a research, `strom fixes` and Settings → Maintenance → Fixes say what it is about, what was found
   and what a remedy would do, with how demanding it is; nothing happens without a yes, and a no is kept. The first:
   blind readings made from the reduced scan where a sharper part existed — read again beside the old ones, first on a
-  few, nothing overwritten, a difference becomes a task. The second: after the reading model or agent changed, the
-  earlier readings worth reading again — with open places, readers who disagreed, an open conflict, a reading not
-  confirmed at the source; said as "read by model X, now read by model Y", asked once per agent and model, each read
-  again as it was read (the images of one reading together, a trial or a part always of whole readings). Counted in
-  readings with their places and what a remedy takes in reader calls; offered by stage — the disputed alone (readers
-  who differed, an open conflict, not confirmed at the source), with the direct line, or all — each with what it
-  takes, the narrowest first, dates and witnesses only ordering them. The remedy may be read by another agent or model
-  ready here (`strom fixes run <id> --agent <a> --model <m>`), with which one read before said; one that cannot read
-  here is refused at once, with those that can. The time of a remedy is rounded up and, after the trial, measured
-  again by the readings as they ran side by side.
+  few, nothing overwritten, a difference becomes a task. Held against each other by what was read — the names, dates
+  and numbers of the transcript, not the words of the reader's comment (in German too, where every noun has a
+  capital) — the task says in one sentence which of them differs; where a name may only begin a sentence, the readings
+  are not said to agree. With nothing to read again, `strom fixes run` says so. The second: after the reading model or agent changed, the earlier readings worth reading again — with open
+  places, readers who disagreed, an open conflict, a reading not confirmed at the source; said as "read by model X,
+  now read by model Y", asked once per agent and model, each read again as it was read (the images of one reading
+  together, a trial or a part always of whole readings). Counted in readings with their places and what a remedy takes
+  in reader calls; offered by stage — the disputed alone (readers who differed, an open conflict, not confirmed at the
+  source), with the direct line, or all — each with what it takes, the narrowest first, dates and witnesses only
+  ordering them. The remedy may be read by another agent or model ready here (`strom fixes run <id> --agent <a>
+  --model <m>`), with which one read before said; one that cannot read here is refused at once, with those that can.
+  The time of a remedy is rounded up and, after the trial, measured again by the readings as they ran side by side.
+- **Sizes as the research's language writes them.** `strom pack`, removing a family tree and the menu say how big a
+  package, a backup or the images are as everywhere else (1,5 MB in Czech, 24 kB for a small one), never "0.0 MB".
 
 ## 1.18.0
 
@@ -107,7 +113,8 @@ The changes of each version in short. The full notes and the install lines are o
   value longer than a line of the GEDCOM file (255 bytes) no longer stops the file from being written, and no emoji is
   split where a long line goes on. With `excerpts.for all` a source nobody cites yet gets its excerpt in the Strom app
   too, wherever it fits under the limit beside the cited ones, which never get smaller for it; what did not fit is
-  said.
+  said. The Strom app is told which images of a source the research has but its file left out, and loads them from
+  the research on demand — a source at a time, or all at once with how many and about how big.
 
 ## 1.17.0
 

package/assets/lang/cs.json

@@ -2114,13 +2114,13 @@
   "ui.trees.pack": "zabalit „{name}“ a poslat někomu (soubor ZIP)",
   "ui.trees.unpack": "rodokmen, který někdo poslal (soubor ZIP)",
   "ui.pack.which": "Které snímky přibalit?",
-  "ui.pack.opt.records": "jen se zápisy – {mb} MB (prohledané stránky dá archiv znovu)",
-  "ui.pack.opt.all": "všechny – {mb} MB",
-  "ui.pack.done": "Zabaleno „{name}“: {file} ({mb} MB)",
+  "ui.pack.opt.records": "jen se zápisy – {size} (prohledané stránky dá archiv znovu)",
+  "ui.pack.opt.all": "všechny – {size}",
+  "ui.pack.done": "Zabaleno „{name}“: {file} ({size})",
   "ui.pack.saved": "  rodokmen, jak byl naposledy uložený, i s historií",
-  "ui.pack.images": "  snímky: {n} ({mb} MB) – se zápisy a ostatní, které nikdo znovu nestáhne",
-  "ui.pack.images.all": "  snímky: všech {n} ({mb} MB)",
-  "ui.pack.left": "  vynechané snímky: {n} ({mb} MB) – prohledané stránky; až budou potřeba, strom je z archivu stáhne znovu",
+  "ui.pack.images": "  snímky: {n} ({size}) – se zápisy a ostatní, které nikdo znovu nestáhne",
+  "ui.pack.images.all": "  snímky: všech {n} ({size})",
+  "ui.pack.left": "  vynechané: {n, plural, one {# snímek} few {# snímky} other {# snímků}} ({size}) – prohledané stránky; až budou potřeba, strom je z archivu stáhne znovu",
   "ui.pack.connectors": "  konektory: {list}",
   "ui.pack.noconnector": "⚠ některé vynechané snímky přišly konektorem, který na tomto počítači není – nikdo by je znovu nestáhl: strom pack --all-images",
   "ui.pack.missing": "⚠ snímky, které rodokmen uvádí, ale na tomto počítači nejsou: {n} – v balíčku chybí",
@@ -2151,14 +2151,14 @@
   "ui.remove.person": "rodokmen z počítače odebírá jen člověk u počítače",
   "ui.remove.busy": "na rodokmenu „{name}“ se právě pracuje – odebrat ho jde, až práce skončí",
   "ui.remove.what": "„{name}“ ({root}) · osoby: {persons}",
-  "ui.remove.backup": "Nejdřív ho zabalit jako zálohu, se všemi snímky ({mb} MB)? Kdykoli se vrátí přes strom unpack.",
+  "ui.remove.backup": "Nejdřív ho zabalit jako zálohu, se všemi snímky ({size})? Kdykoli se vrátí přes strom unpack.",
   "ui.remove.backup.done": "  záloha: {file}",
-  "ui.remove.images": "Poslat do koše i snímky, které žádný jiný rodokmen nepoužívá (snímky: {n}, {mb} MB)?",
+  "ui.remove.images": "Poslat do koše i snímky, které žádný jiný rodokmen nepoužívá (snímky: {n}, {size})?",
   "ui.remove.type": "Pro potvrzení napsat název rodokmenu ({name}) – cokoli jiného nic neodebere:",
   "ui.remove.cancelled": "Nic se neodebralo.",
   "ui.remove.done": "„{name}“ je v koši.",
   "ui.remove.live": "  aplikace Strom ho už živě nesleduje",
-  "ui.remove.images.done": "  jeho snímky v koši: {n} ({mb} MB)",
+  "ui.remove.images.done": "  jeho snímky v koši: {n} ({size})",
   "ui.remove.images.folder": "{name} – snímky",
   "ui.remove.backup.back": "  vrátí se ze zálohy: strom unpack „{file}“",
   "ui.remove.trash.alone": "  vrátí se z koše systému, dokud se koš nevysype",
@@ -2656,6 +2656,8 @@
   "fix.model.why.differ": "Přečteno znovu modelem {now} (dříve: {before}) tam, kde něco zůstalo otevřené, a čtení se liší.",
   "fix.model.why.refined": "Přečteno znovu modelem {now} (dříve: {before}) tam, kde něco zůstalo otevřené, a nové čtení přečetlo víc nebo jistěji.",
   "fix.model.done": "obě čtení porovnaná mezi sebou ({show} {old} · {show} {now}) a s {sources}: co platí, zapsané u pramene, údaje na něm ověřené; nic odebrané bez důvodu",
+  "fix.differs": "Liší se: dříve {before}, nově {now}.",
+  "fix.more": "Nově přečteno navíc: {now}.",
   "fix.model.unknown": "nezaznamenaný model",
   "fix.model.own": "vlastní model"
 }

package/assets/lang/de.json

@@ -2114,13 +2114,13 @@
   "ui.trees.pack": "„{name}“ einpacken und jemandem schicken (eine ZIP-Datei)",
   "ui.trees.unpack": "ein zugeschickter Stammbaum (eine ZIP-Datei)",
   "ui.pack.which": "Welche Bilder kommen mit?",
-  "ui.pack.opt.records": "die, auf denen die Einträge stehen – {mb} MB (die durchgesehenen Seiten gibt das Archiv wieder)",
-  "ui.pack.opt.all": "alle – {mb} MB",
-  "ui.pack.done": "„{name}“ eingepackt: {file} ({mb} MB)",
+  "ui.pack.opt.records": "die, auf denen die Einträge stehen – {size} (die durchgesehenen Seiten gibt das Archiv wieder)",
+  "ui.pack.opt.all": "alle – {size}",
+  "ui.pack.done": "„{name}“ eingepackt: {file} ({size})",
   "ui.pack.saved": "  der Stammbaum, wie er zuletzt gespeichert wurde, mit seiner Geschichte",
-  "ui.pack.images": "  Bilder: {n} ({mb} MB) – die, auf denen die Einträge stehen, und die, die niemand wieder laden kann",
-  "ui.pack.images.all": "  Bilder: alle {n} ({mb} MB)",
-  "ui.pack.left": "  weggelassen: {n, plural, one {# Bild} other {# Bilder}} ({mb} MB) – durchgesehene Seiten; strom lädt sie aus dem Archiv wieder, wenn sie gebraucht werden",
+  "ui.pack.images": "  Bilder: {n} ({size}) – die, auf denen die Einträge stehen, und die, die niemand wieder laden kann",
+  "ui.pack.images.all": "  Bilder: alle {n} ({size})",
+  "ui.pack.left": "  weggelassen: {n, plural, one {# Bild} other {# Bilder}} ({size}) – durchgesehene Seiten; strom lädt sie aus dem Archiv wieder, wenn sie gebraucht werden",
   "ui.pack.connectors": "  Konnektoren: {list}",
   "ui.pack.noconnector": "⚠ einige weggelassene Bilder kamen über einen Konnektor, der auf diesem Computer fehlt – niemand könnte sie wieder laden: strom pack --all-images",
   "ui.pack.missing": "⚠ {n, plural, one {# Bild, das der Stammbaum nennt, ist} other {# Bilder, die der Stammbaum nennt, sind}} nicht auf diesem Computer – nicht im Paket",
@@ -2151,14 +2151,14 @@
   "ui.remove.person": "einen Stammbaum nimmt nur die Person am Computer herunter",
   "ui.remove.busy": "an „{name}“ wird gerade gearbeitet – er kann weg, wenn die Arbeit vorbei ist",
   "ui.remove.what": "„{name}“ ({root}) · Personen: {persons}",
-  "ui.remove.backup": "Zuerst als Sicherung einpacken, mit allen Bildern ({mb} MB)? Er kommt jederzeit mit strom unpack zurück.",
+  "ui.remove.backup": "Zuerst als Sicherung einpacken, mit allen Bildern ({size})? Er kommt jederzeit mit strom unpack zurück.",
   "ui.remove.backup.done": "  Sicherung: {file}",
-  "ui.remove.images": "Auch die Bilder, die kein anderer Stammbaum nutzt, in den Papierkorb ({n}, {mb} MB)?",
+  "ui.remove.images": "Auch die Bilder, die kein anderer Stammbaum nutzt, in den Papierkorb ({n}, {size})?",
   "ui.remove.type": "Zur Bestätigung den Namen des Stammbaums ({name}) tippen – alles andere nimmt nichts weg:",
   "ui.remove.cancelled": "Nichts wurde weggenommen.",
   "ui.remove.done": "„{name}“ ist im Papierkorb.",
   "ui.remove.live": "  die Strom-App verfolgt ihn nicht mehr live",
-  "ui.remove.images.done": "  seine Bilder im Papierkorb: {n} ({mb} MB)",
+  "ui.remove.images.done": "  seine Bilder im Papierkorb: {n} ({size})",
   "ui.remove.images.folder": "{name} – Bilder",
   "ui.remove.backup.back": "  er kommt aus der Sicherung zurück: strom unpack „{file}“",
   "ui.remove.trash.alone": "  er kommt aus dem Papierkorb des Systems zurück, bis er geleert wird",
@@ -2656,6 +2656,8 @@
   "fix.model.why.differ": "Von {now} erneut gelesen (zuvor: {before}), wo etwas offen blieb, und die Lesungen weichen ab.",
   "fix.model.why.refined": "Von {now} erneut gelesen (zuvor: {before}), wo etwas offen blieb, und die neue Lesung liest mehr oder sicherer.",
   "fix.model.done": "beide Lesungen miteinander verglichen ({show} {old} · {show} {now}) und mit {sources}: was gilt, an der Quelle vermerkt, die Angaben darauf geprüft; nichts ohne Grund entfernt",
+  "fix.differs": "Abweichend: früher {before}, jetzt {now}.",
+  "fix.more": "Jetzt zusätzlich gelesen: {now}.",
   "fix.model.unknown": "ein nicht vermerktes Modell",
   "fix.model.own": "eigenes Modell"
 }

package/assets/phone/phone.css

@@ -122,7 +122,7 @@ button{font:inherit;color:inherit}
 .strip.warn{color:var(--warning-text)}
 
 /* the sheet of the photos to send */
-.sheet{position:fixed;left:0;right:0;top:0;height:var(--vvh,100%);z-index:10;background:var(--bg);display:flex;flex-direction:column;max-width:560px;margin:0 auto}
+.sheet{position:fixed;left:0;right:0;top:var(--vvt,0px);height:var(--vvh,100%);z-index:10;background:var(--bg);display:flex;flex-direction:column;max-width:560px;margin:0 auto}
 .sheet-head{display:flex;align-items:flex-start;gap:8px;padding:max(12px,env(safe-area-inset-top)) 8px 10px 16px;background:var(--surface);border-bottom:1px solid var(--divider)}
 .sheet-head>div{flex:1;min-width:0}
 .sheet-head h2{margin:2px 0 2px}

package/assets/phone/phone.js

@@ -1158,16 +1158,17 @@
     $("doneBox").hidden = !handed;
     if (handed) $("doneText").textContent = t("commit.done", { n: b.done });
     // the foot: the camera's photos only here, handing over
-    $("captureNote").hidden = !items.some((i) => i.capture && i.blob);
+    // while typing, only what ends the typing: the rest of the foot would take what the keyboard leaves of the sheet
+    $("captureNote").hidden = !!S.typing || !items.some((i) => i.capture && i.blob);
     $("photoRow").hidden = !!S.typing;
     $("typingRow").hidden = !S.typing;
     $("noPersonBtn").hidden = S.typing !== "person";
     const committing = !!(b && b.commit);
-    $("commitBtn").hidden = !items.length;
+    $("commitBtn").hidden = !items.length || !!S.typing;
     $("commitBtn").disabled = committing || !items.some((i) => !FINAL(i));
     $("commitBtn").textContent = committing ? t("commit.wait") : t("commit");
     $("commitCancel").hidden = !committing;
-    $("commitLater").hidden = !items.length || committing;
+    $("commitLater").hidden = !items.length || committing || !!S.typing;
   };
 
   const renderUnpaired = () => {
@@ -1275,6 +1276,17 @@
     render();
   };
 
+  // the field typed in at the top of the sheet's body, what it offers under it (the keyboard leaves little of the sheet)
+  const keepTyped = () => {
+    const f = document.activeElement;
+    if (!f || (f.id !== "person" && f.id !== "note") || $("sheet").hidden) return;
+    const body = $("sheet").querySelector(".sheet-body");
+    const field = (f.closest && f.closest(".field")) || f;
+    if (!body) return;
+    const off = field.getBoundingClientRect().top - body.getBoundingClientRect().top - 8;
+    if (Math.abs(off) > 1) body.scrollTop += off;
+  };
+
   let lookFor = 0;
   let asked = "";
   const findPeople = () => {
@@ -1317,6 +1329,7 @@
         ul.append(li);
       }
       ul.hidden = !people.length;
+      if (people.length) keepTyped();
     }, 250);
   };
 
@@ -1469,12 +1482,22 @@
     renderPill();
   };
   window.addEventListener("scroll", () => S.newCount && window.scrollY <= 4 && renderPill(), { passive: true });
-  // the keyboard: the sheet as high as what is seen of the page, its foot above the keyboard
+  // the keyboard: the sheet as high as what is seen of the page and where it is seen (iOS Safari keeps the page as tall
+  // and moves what is seen of it up above the keyboard: a sheet fixed at the page's top would end under the field), its
+  // foot above the keyboard, the field typed in kept in sight; without visualViewport the sheet is the whole window
   const vv = window.visualViewport;
   if (vv) {
-    const fit = () => document.documentElement.style.setProperty("--vvh", `${vv.height}px`);
-    vv.addEventListener("resize", fit);
-    fit();
+    const place = () => {
+      const root = document.documentElement.style;
+      root.setProperty("--vvh", `${Math.round(vv.height)}px`);
+      root.setProperty("--vvt", `${Math.max(0, Math.round(vv.offsetTop || 0))}px`);
+    };
+    vv.addEventListener("resize", () => {
+      place();
+      keepTyped();
+    });
+    vv.addEventListener("scroll", place);
+    place();
   }
 
   // looked at again: asked at once; every 10 s while open

package/dist/cli/main.js

@@ -372,12 +372,14 @@ export async function main(argv, io, env, cwd) {
                 }
             }
             // …and the phone's server, when the connection is on (it starts again with this version by itself; one the
-            // installer ended to replace the program back)
-            try {
-                revivePhone(env);
-            }
-            catch {
-                // its next bridge brings it back
+            // installer ended to replace the program back) — not by the server itself, which would start a second one beside it
+            if (def.path.join(" ") !== "phone serve") {
+                try {
+                    revivePhone(env);
+                }
+                catch {
+                    // its next bridge brings it back
+                }
             }
         }
         // the folder of the program that runs with these settings (from a strom that ran here before it was kept, once):

package/dist/cli/menu.js

@@ -611,8 +611,8 @@ async function pickTree(ctx, run, lang) {
     if (i === packAt) {
         const tree = Tree.open(known[at].root, ctx.env);
         const shared = ctx.settings.shared().value;
-        const size = (all) => (packPlan(tree, shared, all).media.reduce((s, m) => s + m.size, 0) / 1e6).toFixed(0);
-        const which = await ctx.choose(ui(lang, "ui.pack.which"), [{ label: ui(lang, "ui.pack.opt.records", { mb: size(false) }) }, { label: ui(lang, "ui.pack.opt.all", { mb: size(true) }) }], 0, { back: ui(lang, "ui.browse.back") });
+        const size = (all) => mb(packPlan(tree, shared, all).media.reduce((s, m) => s + m.size, 0), lang);
+        const which = await ctx.choose(ui(lang, "ui.pack.which"), [{ label: ui(lang, "ui.pack.opt.records", { size: size(false) }) }, { label: ui(lang, "ui.pack.opt.all", { size: size(true) }) }], 0, { back: ui(lang, "ui.browse.back") });
         if (which === undefined)
             return;
         await run(["pack", "--tree", tree.root, ...(which === 1 ? ["--all-images"] : [])]);

package/dist/cli/ui.js

@@ -1982,13 +1982,13 @@ export const UI = {
     "ui.trees.pack": "pack \"{name}\" to send to someone (a ZIP file)",
     "ui.trees.unpack": "a family tree from someone else (a ZIP file)",
     "ui.pack.which": "Which images go along?",
-    "ui.pack.opt.records": "the ones its records stand on — {mb} MB (the pages searched through the archive gives again)",
-    "ui.pack.opt.all": "all of them — {mb} MB",
-    "ui.pack.done": "Packed \"{name}\": {file} ({mb} MB)",
+    "ui.pack.opt.records": "the ones its records stand on — {size} (the pages searched through the archive gives again)",
+    "ui.pack.opt.all": "all of them — {size}",
+    "ui.pack.done": "Packed \"{name}\": {file} ({size})",
     "ui.pack.saved": "  the family tree as last saved, with its history",
-    "ui.pack.images": "  images: {n} ({mb} MB) — the ones its records stand on and the ones nobody can fetch again",
-    "ui.pack.images.all": "  images: all {n} ({mb} MB)",
-    "ui.pack.left": "  left out: {n, plural, one {# image} other {# images}} ({mb} MB) — pages searched through; strom fetches them from the archive again when they are needed",
+    "ui.pack.images": "  images: {n} ({size}) — the ones its records stand on and the ones nobody can fetch again",
+    "ui.pack.images.all": "  images: all {n} ({size})",
+    "ui.pack.left": "  left out: {n, plural, one {# image} other {# images}} ({size}) — pages searched through; strom fetches them from the archive again when they are needed",
     "ui.pack.connectors": "  connectors: {list}",
     "ui.pack.noconnector": "⚠ some images left out came through a connector that is not on this computer — nobody could fetch them again: strom pack --all-images",
     "ui.pack.missing": "⚠ {n, plural, one {# image the family tree names is} other {# images the family tree names are}} not on this computer — not in the package",
@@ -2019,14 +2019,14 @@ export const UI = {
     "ui.remove.person": "only the person at the computer takes a family tree off it",
     "ui.remove.busy": "somebody is at work on \"{name}\" right now — it can go once the work is over",
     "ui.remove.what": "\"{name}\" ({root}) · people: {persons}",
-    "ui.remove.backup": "Pack it first as a backup, with all its images ({mb} MB)? It comes back any time with strom unpack.",
+    "ui.remove.backup": "Pack it first as a backup, with all its images ({size})? It comes back any time with strom unpack.",
     "ui.remove.backup.done": "  backup: {file}",
-    "ui.remove.images": "Into the trash too the images no other family tree uses ({n}, {mb} MB)?",
+    "ui.remove.images": "Into the trash too the images no other family tree uses ({n}, {size})?",
     "ui.remove.type": "To confirm, type the name of the family tree ({name}) — anything else takes nothing off:",
     "ui.remove.cancelled": "Nothing was taken off.",
     "ui.remove.done": "\"{name}\" is in the trash.",
     "ui.remove.live": "  the Strom app no longer follows it live",
-    "ui.remove.images.done": "  its images in the trash: {n} ({mb} MB)",
+    "ui.remove.images.done": "  its images in the trash: {n} ({size})",
     "ui.remove.images.folder": "{name} – images",
     "ui.remove.backup.back": "  it comes back from the backup: strom unpack \"{file}\"",
     "ui.remove.trash.alone": "  it comes back from the system's trash, until it is emptied",

package/dist/commands/fixchecks.js

@@ -14,7 +14,7 @@ import { mediaOrient } from "../core/views.js";
 import { median, readJournal } from "../core/readstats.js";
 import { metricsDir } from "../core/metrics.js";
 import { runGit } from "../core/git.js";
-import { READ_EXPECT_DEFAULT, READ_EXPECT_OTHERS } from "../core/live-read.js";
+import { READER_MS_MAX, readExpectDefault } from "../core/live-read.js";
 import { foldText } from "../core/text.js";
 import { loadReadings } from "./readings.js";
 import { isArchive } from "../core/mode.js";
@@ -39,6 +39,8 @@ export const BLIND_REDUCED_FIXED_AT = "2026-10-21T13:42:49Z";
 /** A view made for a reader this long before its reader began belongs to its reading. */
 const VIEW_BEFORE_MS = 30 * 60_000;
 const VIEW_AFTER_MS = 2 * 60_000;
+/** strom makes a reader's views before it begins it: of a reader whose own start is known, only those (ms rounding). */
+const VIEW_EXACT_MS = 100;
 /** Views of one reading are made within moments of each other. */
 const VIEW_CLUSTER_MS = 10_000;
 /** A later reading from a sharper copy that covers this much of a place has read it again. */
@@ -96,6 +98,9 @@ function blindReducedDetect(tree, env) {
     // when each reading began (its readers, this computer)
     const began = new Map();
     const capOf = new Map();
+    // when the reader of each image of a reading began, and every reader's start of an image (any reading)
+    const beganImage = new Map();
+    const startsOf = new Map();
     for (const r of readJournal(path.join(metricsDir(tree.root), "readers.jsonl"))) {
         if (r.kind !== "read" || typeof r.reader !== "string" || typeof r.at !== "string")
             continue;
@@ -105,6 +110,17 @@ function blindReducedDetect(tree, env) {
             began.set(stem, t);
         if (num(r.cap))
             capOf.set(stem, num(r.cap));
+        if (!Number.isFinite(t))
+            continue;
+        // the images it read (an older strom's record: those its reading is named after)
+        for (const id of Array.isArray(r.imageIds) ? r.imageIds : (stem.match(/M\d+/gu) ?? [])) {
+            if (typeof id !== "string")
+                continue;
+            const k = `${stem}|${id}`;
+            if (t < (beganImage.get(k) ?? Infinity))
+                beganImage.set(k, t);
+            startsOf.set(id, [...(startsOf.get(id) ?? []), t]);
+        }
     }
     // the views made for readers (this computer): a crop, the image it is of, when
     const views = new Map();
@@ -132,13 +148,23 @@ function blindReducedDetect(tree, env) {
         const times = r.reports.map((n) => added.get(n)).filter((t) => t !== undefined);
         return times.length ? Math.min(...times) : undefined;
     };
-    /** The views of one reading of an image: those made last before its reader began, within moments of each other. */
-    const viewsOf = (key, t) => {
-        const near = (views.get(key) ?? []).filter((v) => v.t >= t - VIEW_BEFORE_MS && v.t <= t + VIEW_AFTER_MS);
+    /**
+     * The views of one reading of an image: those made last before its reader began, within moments of each other —
+     * never those of another reader of the same image (made before it began). Its reader's own start unknown here and
+     * views of more than one moment near: which it read is not sure (an estimate).
+     */
+    const viewsOf = (stem, key, t) => {
+        const own = beganImage.get(`${stem}|${key}`);
+        const at = own ?? t;
+        const others = (startsOf.get(key) ?? []).filter((s) => s !== own);
+        const after = Math.min(at + (own !== undefined ? VIEW_EXACT_MS : VIEW_AFTER_MS), ...others.filter((s) => s > at));
+        const before = Math.max(at - VIEW_BEFORE_MS, ...others.filter((s) => s < at));
+        const near = (views.get(key) ?? []).filter((v) => v.t > before && v.t <= after);
         if (!near.length)
-            return [];
+            return { views: [], estimated: false };
         const last = Math.max(...near.map((v) => v.t));
-        return near.filter((v) => v.t >= last - VIEW_CLUSTER_MS);
+        const cluster = near.filter((v) => v.t >= last - VIEW_CLUSTER_MS);
+        return { views: cluster, estimated: own === undefined && cluster.length < near.length };
     };
     // places read again from a sharper copy since (a later reading): by whole image, fractions as the file lies
     const readSharper = new Map();
@@ -167,7 +193,7 @@ function blindReducedDetect(tree, env) {
             const m = byId.get(id);
             if (!m || m.retracted)
                 continue;
-            const own = viewsOf(id, t);
+            const { views: own, estimated: unsure } = viewsOf(r.stem, id, t);
             if (m.part) {
                 // a part read: the place in the whole image read sharper (when its views say where)
                 if (m.recordset !== undefined && m.image !== undefined) {
@@ -189,7 +215,7 @@ function blindReducedDetect(tree, env) {
                 const x1 = Math.max(...own.map((v) => v.region.x + v.region.w));
                 const y1 = Math.max(...own.map((v) => v.region.y + v.region.h));
                 const v = own[0];
-                places = [{ file: shownToFile({ x: x0 / v.W, y: y0 / v.H, w: (x1 - x0) / v.W, h: (y1 - y0) / v.H }, v.orient), estimated: false }];
+                places = [{ file: shownToFile({ x: x0 / v.W, y: y0 / v.H, w: (x1 - x0) / v.W, h: (y1 - y0) / v.H }, v.orient), estimated: unsure }];
             }
             else if ((views.size === 0 || !views.has(id)) && r.blind && few && t < Date.parse(BLIND_REDUCED_FIXED_AT)) {
                 // no record of its views here (another computer): the places of the sources' entries on the image, an estimate
@@ -504,7 +530,7 @@ function newModelDetect(tree, env) {
             const unclear = blocks.reduce((n, b) => n + Math.max(unclearOf(b), b.result === "unclear" ? 1 : 0), 0);
             // a blind reading that reads otherwise than the researcher's reading of the image before it
             const theirs = r.blind ? list.filter((x) => !x.r.blind && x.t <= t && x.r !== r).sort((a, b) => b.t - a.t)[0] : undefined;
-            const differ = !!theirs && compareReadings(theirs.blocks, blocks) === "differ";
+            const differ = !!theirs && compareReadings(theirs.blocks, blocks, tree.lang).result === "differ";
             const reg = cropRegion(crop);
             const src = reg && !m.part ? sourcesOf(sources, media, m, shownToFile(reg, mediaOrient(env.shared, m))) : sources.filter((s) => (s.media ?? []).includes(id) || (s.clips ?? []).some((c) => c.media === id)).map((s) => s.id).sort();
             const reasons = [...(unclear ? ["unclear"] : []), ...(differ ? ["differ"] : []), ...(src.some((s) => conflicted.has(s)) ? ["conflict"] : [])];
@@ -671,13 +697,16 @@ export function decide(tree, id, decision) {
             delete c.fixes;
     }, { op: "fix.decide", summary: decision ? `fix ${id}: ${decision}` : `fix ${id}: asked again` });
 }
-/** Each check with what it found here and the decision about it. */
+/**
+ * Each check with what it found here and the decision about it. Set right holds for what was read again: what a check
+ * still finds after (never read again — a few first, or a place strom took wrongly then) waits again, it alone.
+ */
 export function fixStates(tree, env) {
     return FIX_CHECKS.map((check) => {
         const found = check.detect(tree, env);
         const key = decisionKeyOf(tree, check, env);
         const decision = decisionOf(tree.config, key);
-        const state = decision ? decision.decision : found.items.length ? "pending" : "nothing";
+        const state = decision?.decision === "declined" ? "declined" : found.items.length ? "pending" : decision ? "fixed" : "nothing";
         return { check, key, found, ...(decision ? { decision } : {}), state };
     });
 }
@@ -691,7 +720,7 @@ function earlierReaders(root, agent, model) {
         if (num(r.usd) !== undefined && !r.usdPartial)
             usd.push(num(r.usd));
         const ms = num(r.wallMs) ?? num(r.ms);
-        if (ms)
+        if (ms && ms > 0 && ms <= READER_MS_MAX)
             secs.push(ms / 1000);
     }
     return { usd, secs };
@@ -710,7 +739,7 @@ export function estimateFix(root, o) {
     const e = earlierReaders(root, o.agent, o.model);
     const n = o.calls;
     const mUsd = e.usd.length >= EARLIER_MIN ? median(e.usd) : undefined;
-    const one = (e.secs.length >= EARLIER_MIN ? median(e.secs) : undefined) ?? READ_EXPECT_DEFAULT[o.agent] ?? READ_EXPECT_OTHERS;
+    const one = (e.secs.length >= EARLIER_MIN ? median(e.secs) : undefined) ?? readExpectDefault(o.agent);
     const secs = o.perReading !== undefined ? n * o.perReading : Math.ceil(n / Math.max(1, o.parallel)) * one;
     const minutes = Math.max(1, Math.ceil(secs / 60));
     if (mUsd !== undefined) {
@@ -719,39 +748,123 @@ export function estimateFix(root, o) {
     }
     return { level: n >= COST_COUNT.expensive ? "expensive" : n >= COST_COUNT.medium ? "medium" : "cheap", calls: n, minutes, basis: "count", earlier: 0 };
 }
-/** The words of a text, folded, without the marks of uncertainty. */
-function words(text) {
-    return new Set(foldText(text.replace(/\[\?\]/gu, " ")).split(/[^\p{L}\p{M}\p{N}]+/u).filter((w) => w.length > 1));
+/**
+ * Languages whose prose writes every noun with a capital ("Der Ausschnitt zeigt …"): there a lone capital is no name for
+ * sure, and the little words that begin a sentence there (an article, a pronoun) never one.
+ */
+const NOUNS_CAPITALIZED = {
+    de: new Set("der die das dem den des ein eine einen einem einer eines im am vom zum zur beim ins es er sie wir ich man dies diese dieser dieses hier da dort auch und aber oder nur noch so wie was wo nach unter von mit bei auf in an".split(" ")),
+};
+// a reader's quotation marks: what it quotes of the record is its transcript, the rest its comment
+const QUOTED = /[„“”"«»「」『』]([^„“”"«»「」『』]*)[„“”"«»「」『』]/gu;
+/** A word as compared: folded, the long s and the ezh of old hands as the letters they are. */
+const wordKey = (w) => foldText(w).replace(/ſ/gu, "s").replace(/ʒ/gu, "z");
+/**
+ * The facts of a transcript: the names (a word that begins with a capital, or any word of a script without capitals)
+ * and the numbers; a word broken over a line ("Wac- / lawa", "In= / mann", "Wac|lawa") whole, the marks of doubt and an editor's
+ * notes in brackets left out (a letter supplied in brackets, "Mi[cha]la", kept). Of a reader's own words (prose: nothing
+ * quoted), a capital that only begins a sentence ("The crop shows …", "Výřez ukazuje …") is a name only where the same
+ * word stands elsewhere as one; in a language that writes its nouns with a capital (`lang`), so is a lone capital — two or
+ * more together ("Jan Novak") and a month after a day ("5. Mai") stay names. Such a word is kept as maybe one.
+ */
+function readOf(text, unclear, found, prose = false, lang = "") {
+    const clean = text
+        .replace(/\[\?\]|\(\?\)/gu, "")
+        .replace(/\[[^\]]*\s[^\]]*\]/gu, " ")
+        .replace(/[[\]]/gu, "")
+        .replace(/([\p{L}\p{M}])(?:[-=¬]\s*[/|]?\s*|\|)(?=[\p{L}\p{M}])/gu, "$1");
+    const facts = new Map();
+    const words = new Set();
+    const tokens = [...clean.matchAll(/[\p{L}\p{M}\p{N}]+/gu)];
+    const little = prose ? NOUNS_CAPITALIZED[lang.toLowerCase().split(/[-_]/u)[0]] : undefined;
+    const capital = (i) => /^\p{Lu}/u.test(tokens[i]?.[0] ?? "") && !/\p{N}/u.test(tokens[i][0]) && !little?.has(wordKey(tokens[i][0]));
+    // the word before a token within its sentence (a sentence's end or a line's in between: none)
+    const joined = (a, b) => a >= 0 && b < tokens.length && !/[.!?…:;\n]/u.test(clean.slice(tokens[a].index + tokens[a][0].length, tokens[b].index).replace(/^\./u, (d) => (/\p{N}$/u.test(tokens[a][0]) ? "" : d)));
+    const maybeAt = [];
+    tokens.forEach((m, i) => {
+        const w = m[0];
+        const k = wordKey(w);
+        words.add(k);
+        const digits = /\p{N}/u.test(w);
+        const cased = /[\p{Lu}\p{Ll}]/u.test(w);
+        if (!digits && cased && prose && /^\p{Lu}/u.test(w)) {
+            if (little?.has(k))
+                return;
+            const lone = little ? !(joined(i - 1, i) && capital(i - 1)) && !(joined(i, i + 1) && capital(i + 1)) && !(joined(i - 1, i) && /^\p{N}+$/u.test(tokens[i - 1][0])) : opensSentence(clean, m.index, w.length);
+            if (lone) {
+                maybeAt.push({ word: w, key: k, at: i });
+                return;
+            }
+        }
+        if (digits || (w.length > 1 && (!cased || /^\p{Lu}/u.test(w))))
+            if (!facts.has(k))
+                facts.set(k, w);
+    });
+    const near = (i) => (i >= 0 && i < tokens.length ? wordKey(tokens[i][0]) : "");
+    const maybe = maybeAt.filter((x) => x.word.length > 1).map((x) => ({ word: x.word, key: x.key, prev: joined(x.at - 1, x.at) ? near(x.at - 1) : "", next: joined(x.at, x.at + 1) ? near(x.at + 1) : "" }));
+    return { facts, words, unclear, found, maybe };
+}
+/**
+ * A word that begins a sentence of prose: at a line's start or after a sentence's end (never after a number's dot, "5. Mai"),
+ * the next word of its sentence in small letters ("Jan Novak", "Jan, son of" stay names).
+ */
+function opensSentence(text, at, length) {
+    let i = at - 1;
+    while (i >= 0 && /\s/u.test(text[i]) && text[i] !== "\n")
+        i--;
+    const start = i < 0 || text[i] === "\n" || (/[.!?…]/u.test(text[i]) && i > 0 && !/\p{N}/u.test(text[i - 1]));
+    return start && /^\s+\p{Ll}/u.test(text.slice(at + length));
+}
+/**
+ * What a reader read of its blocks: the parts of its entries it quotes from the record (when it quotes any), else its
+ * entries — never a line of possible readings with their chances or of letters with theirs (a "%" in it), nor how it
+ * describes the hand or how sure it is (hand, certainty); what it could not read only counts as unclear.
+ */
+function readOfBlocks(blocks, lang) {
+    const lines = blocks.flatMap((b) => b.entries ?? []).filter((l) => !/%/u.test(l));
+    const quoted = lines.flatMap((l) => [...l.matchAll(QUOTED)].map((m) => m[1]));
+    const unclear = blocks.reduce((n, x) => n + unclearOf(x), 0);
+    const found = blocks.some((b) => b.result === "found");
+    return quoted.length ? readOf(quoted.join(" "), unclear, found) : readOf(lines.join("\n"), unclear, found, true, lang);
+}
+/** What a reading of a document read: the people's names and ages, the events' dates and places (the reader's own fields). */
+function readOfDocument(r) {
+    const { unclear } = docText(r);
+    const parts = r.entries.flatMap((e) => [...e.persons.flatMap((p) => [p.given, p.surname, p.age]), ...e.events.flatMap((v) => [v.date?.gedcom ?? v.date?.text, v.place?.text])]);
+    // every word of its fields counts: a document's reader says what each one is
+    const read = readOf(parts.filter(Boolean).join(" "), unclear, r.entries.length > 0);
+    for (const w of read.words)
+        if (!read.facts.has(w))
+            read.facts.set(w, w);
+    return { ...read, maybe: [] };
 }
-/** A reader's entries as one text, and its uncertain places. */
-const readText = (blocks) => ({ text: blocks.map((b) => (b.entries?.length ? b.entries.join(" ") : b.text)).join(" "), unclear: blocks.reduce((n, x) => n + unclearOf(x), 0) });
 /**
- * The new reading of a place against the earlier one: the same words (shoda), the same with fewer places unclear or
- * more read (upřesněno), or other words (rozchod) — nothing read: failed.
+ * The new reading of a place against the earlier one, by what each read — the names and numbers of its transcript:
+ * the same (shoda); all the earlier one read with more beside it, fewer places unclear, or found where it was unclear
+ * (upřesněno); something the earlier one read that the new one does not — another name, date, number or place (rozchod).
+ * Of a reader's own words, a capital that may only begin a sentence or be a noun in another place of the same sentence
+ * ("Marie byla …" against "Anna byla …"): not sure, so refined, never the same. Nothing read: failed. `lang`: the language
+ * the readers wrote their own words in (the research language).
  */
-export function compareReadings(before, now) {
-    return now.length ? compareTexts(readText(before), readText(now)) : "failed";
+export function compareReadings(before, now, lang) {
+    return now.length ? compareRead(readOfBlocks(before, lang), readOfBlocks(now, lang)) : { result: "failed", before: [], now: [] };
 }
-/** A reading of a document again against the earlier one, as compareReadings (its entries' transcripts). */
+/** A reading of a document again against the earlier one, as compareReadings (its people and events). */
 export function compareDocuments(before, now) {
     if (!now || !now.entries.length)
-        return "failed";
-    return compareTexts(docText(before), docText(now));
-}
-function compareTexts(before, now) {
-    const a = words(before.text);
-    const b = words(now.text);
-    const both = [...a].filter((w) => b.has(w)).length;
-    const all = new Set([...a, ...b]).size;
-    const alike = all ? both / all : 1;
-    const fewer = now.unclear < before.unclear;
-    // what the earlier reading had, the new one has too, with more beside it: read further
-    const more = a.size > 0 && both / a.size >= 0.85 && b.size > a.size;
-    if (alike >= 0.9)
-        return fewer ? "refined" : "same";
-    if ((alike >= 0.6 && fewer) || more)
-        return "refined";
-    return "differ";
+        return { result: "failed", before: [], now: [] };
+    return compareRead(readOfDocument(before), readOfDocument(now));
+}
+function compareRead(a, b) {
+    const before = [...a.facts].filter(([k]) => !b.words.has(k)).map(([, w]) => w);
+    const now = [...b.facts].filter(([k]) => !a.words.has(k)).map(([, w]) => w);
+    if (before.length)
+        return { result: "differ", before, now };
+    // a maybe-name of one where the other has another between the same words
+    const swapped = (x, y) => x.maybe.filter((m) => !x.facts.has(m.key) && !y.words.has(m.key) && y.maybe.some((o) => o.key !== m.key && o.prev === m.prev && o.next === m.next)).map((m) => m.word);
+    const maybeNow = swapped(b, a);
+    const surer = b.unclear < a.unclear || (b.found && !a.found);
+    return { result: now.length || maybeNow.length || surer ? "refined" : "same", before, now: [...now, ...maybeNow] };
 }
 // ── what waits ──────────────────────────────────────────────────────────────────────────────────────────────────
 /** The checks that wait for the person's decision here (none in an archive: nobody reads there). */

package/dist/commands/fixes.js

@@ -202,6 +202,12 @@ function blocksOf(tree, stem, media) {
     const r = loadReadings(tree).find((x) => x.stem === stem);
     return (r?.blocks ?? []).filter((b) => b.media === media.id || (b.recordset === media.recordset && b.num !== undefined && b.num === media.image));
 }
+/** A comparison as a reading again keeps it: its result, and what differs where something does. */
+function compared(c) {
+    if (!c)
+        return { result: "failed" };
+    return { result: c.result, ...(c.before.length || c.now.length ? { differs: { before: c.before, now: c.now } } : {}) };
+}
 /** Each place read again, blind with the earlier question, from the sharper copy; the readings held against each other. */
 async function readAgain(ctx, tree, t, items, model) {
     const { def } = resolveCommand(["read"]);
@@ -231,7 +237,8 @@ async function readAgain(ctx, tree, t, items, model) {
             }
             const before = loadDocResult(tree.root, item.reading);
             const secs = (Date.now() - began) / 1000;
-            return [{ item, result: before ? compareDocuments(before, now) : "failed", ...(now?.id ? { reading: now.id } : {}), secs, ...(error ? { error } : {}) }];
+            const c = before ? compareDocuments(before, now) : undefined;
+            return [{ item, ...compared(c), ...(now?.id ? { reading: now.id } : {}), secs, ...(error ? { error } : {}) }];
         }
         const opts = { question: item.question, ...(model ? { model } : {}), ...(item.crop ? { crop: item.crop } : {}), parallel: "1", ...(item.blind ? { blind: true } : {}), ...(item.context ? { context: item.context } : {}) };
         let reading;
@@ -249,7 +256,7 @@ async function readAgain(ctx, tree, t, items, model) {
             const m = byId.get(i.media);
             const now = reading && m ? blocksOf(tree, reading, m) : [];
             const before = m ? blocksOf(tree, i.reading, m) : [];
-            return { item: i, result: compareReadings(before, now), ...(reading ? { reading } : {}), secs, ...(error ? { error } : {}) };
+            return { item: i, ...compared(compareReadings(before, now, tree.lang)), ...(reading ? { reading } : {}), secs, ...(error ? { error } : {}) };
         });
     })).flat();
 }
@@ -267,7 +274,7 @@ function tasksFor(tree, check, done, now) {
             priority: d.result === "differ" ? 2 : 3,
             what: phrase(lang, `${p}.what`, { media: i.document ? i.document.files.join(", ") : i.media, old: i.reading, now: d.reading }),
             where: [...(i.document ? i.document.files : [i.media]), ...i.sources],
-            why: phrase(lang, `${p}.why.${d.result}`, { since: check.since, from: i.from ?? "", before: i.before ? label(i.before) : "", now: now ? label(now) : "" }),
+            why: [phrase(lang, `${p}.why.${d.result}`, { since: check.since, from: i.from ?? "", before: i.before ? label(i.before) : "", now: now ? label(now) : "" }), differsText(lang, d)].filter(Boolean).join(" "),
             doneWhen: phrase(lang, `${p}.done`, { old: i.reading, now: d.reading, sources: i.sources.join(", ") || i.media, show: i.document ? "strom document show" : "strom readings" }),
             subject: [...i.sources],
             state: "open",
@@ -276,6 +283,15 @@ function tasksFor(tree, check, done, now) {
         d.task = task.id;
     }
 }
+/** One sentence of what differs (the facts each read that the other does not), or what the new reading read beside. */
+function differsText(lang, d) {
+    const list = (ws) => (ws.length ? ws.slice(0, 6).join(", ") + (ws.length > 6 ? ", …" : "") : "—");
+    if (!d.differs)
+        return "";
+    if (d.result === "differ")
+        return phrase(lang, "fix.differs", { before: list(d.differs.before), now: list(d.differs.now) });
+    return d.differs.now.length ? phrase(lang, "fix.more", { now: list(d.differs.now) }) : "";
+}
 /** `secs`: the real time the readings took, readers at once and all. Its places: the same, refined, different. */
 function summaryText(t, done, secs) {
     const n = (r) => done.filter((d) => d.result === r).length;
@@ -532,14 +548,15 @@ register({
         // who reads, before anything is offered: the agent asked, or with nothing asked, any here
         if (typeof opts.model === "string" && !opts.model.trim())
             throw new UsageError("--model names a model", { hint: `${set} --model <model>` });
-        if (ctx.settings.agent(tree.config).source === "flag" || typeof opts.model === "string" || !readyHere(ctx).length)
-            requireReady(ctx, tree, set);
-        personOnly(ctx, t, "Read places of this research again (paid readings)?", set);
         const first = positive(opts.first, "first");
         const tryN = positive(opts.try, "try", FIX_TRY);
         const states = args[0] ? [stateOfCheck(ctx, tree, args[0])] : fixStates(tree, fixEnv(ctx, tree)).filter((s) => s.state === "pending");
-        if (!states.length)
-            return { text: t("ui.fixes.none"), data: { checks: [] } };
+        // nothing to read again: said so, before who reads or whose choice it is
+        if (!states.some((s) => s.found.items.length))
+            return { text: t("ui.fixes.none"), data: { checks: states.map((s) => ({ id: s.check.id, read: 0, tasks: [] })) } };
+        if (ctx.settings.agent(tree.config).source === "flag" || typeof opts.model === "string" || !readyHere(ctx).length)
+            requireReady(ctx, tree, set);
+        personOnly(ctx, t, "Read places of this research again (paid readings)?", set);
         const results = [];
         for (const s of states) {
             if (!s.found.items.length) {

package/dist/commands/pack.js

@@ -8,12 +8,12 @@ import { NeedsConsentError, UsageError } from "../core/errors.js";
 import { findPack, freeRoot, INSTALL_UNIX, INSTALL_WINDOWS, packPlan, unpack, writePack } from "../core/pack.js";
 import { desktopDir, userHome } from "../core/paths.js";
 import { safeFolderName } from "../core/text.js";
+import { mb } from "../core/tidy.js";
 import { Tree } from "../core/tree.js";
 import { syncAgentFiles } from "../agents/files.js";
 import { setupWizard } from "../cli/wizard.js";
 import { isAgent } from "../core/which.js";
 import { ensureShared } from "./setup.js";
-const mb = (bytes) => (bytes / 1e6 < 10 ? (bytes / 1e6).toFixed(1) : Math.round(bytes / 1e6).toString());
 /** Where a package goes unless named: the desktop (else the home), the tree's name and the day, a free name. */
 export function defaultPackFile(ctx, tree) {
     const base = `${safeFolderName(tree.config.name) || "tree"} ${new Date().toISOString().slice(0, 10)}`;
@@ -60,11 +60,11 @@ register({
         if (ctx.dryRun) {
             const plan = packPlan(tree, shared, all);
             const bytes = plan.media.reduce((s, m) => s + m.size, 0);
-            return { text: `dry run: would pack "${tree.config.name}" with ${counted(plan.media.length, "image")} (${mb(bytes)} MB) into ${ctx.display(out)} — nothing written`, data: { out, plan } };
+            return { text: `dry run: would pack "${tree.config.name}" with ${counted(plan.media.length, "image")} (${mb(bytes)}) into ${ctx.display(out)} — nothing written`, data: { out, plan } };
         }
         const r = packTree(tree, shared, out, all);
         const took = r.plan.media.reduce((s, m) => s + m.size, 0);
-        const text = lines(ui(lang, "ui.pack.done", { name: tree.config.name, file: ctx.display(r.file), mb: mb(r.bytes) }), ui(lang, "ui.pack.saved"), ui(lang, all ? "ui.pack.images.all" : "ui.pack.images", { n: r.plan.media.length, mb: mb(took) }), r.plan.left.count ? ui(lang, "ui.pack.left", { n: r.plan.left.count, mb: mb(r.plan.left.bytes) }) : undefined, r.plan.connectors.length ? ui(lang, "ui.pack.connectors", { list: r.plan.connectors.join(", ") }) : undefined, r.plan.left.count && r.plan.left.connectors ? ui(lang, "ui.pack.noconnector") : undefined, r.plan.missing.length ? ui(lang, "ui.pack.missing", { n: r.plan.missing.length }) : undefined, "", ui(lang, "ui.pack.send"));
+        const text = lines(ui(lang, "ui.pack.done", { name: tree.config.name, file: ctx.display(r.file), size: mb(r.bytes, lang) }), ui(lang, "ui.pack.saved"), ui(lang, all ? "ui.pack.images.all" : "ui.pack.images", { n: r.plan.media.length, size: mb(took, lang) }), r.plan.left.count ? ui(lang, "ui.pack.left", { n: r.plan.left.count, size: mb(r.plan.left.bytes, lang) }) : undefined, r.plan.connectors.length ? ui(lang, "ui.pack.connectors", { list: r.plan.connectors.join(", ") }) : undefined, r.plan.left.count && r.plan.left.connectors ? ui(lang, "ui.pack.noconnector") : undefined, r.plan.missing.length ? ui(lang, "ui.pack.missing", { n: r.plan.missing.length }) : undefined, "", ui(lang, "ui.pack.send"));
         return { text, data: { file: r.file, bytes: r.bytes, manifest: r.manifest, missing: r.plan.missing } };
     },
 });

package/dist/commands/trees.js

@@ -152,17 +152,16 @@ register({
         const others = ctx.knownTrees().map((k) => k.root).filter((r) => path.resolve(r) !== path.resolve(root));
         const only = onlyItsFiles(root, others, shared);
         const onlyBytes = only.reduce((s, f) => s + f.size, 0);
-        const mb = (b) => (b / 1e6 < 10 ? (b / 1e6).toFixed(1) : Math.round(b / 1e6).toString());
         ctx.io.stdout(ui(lang, "ui.remove.what", { name, root: ctx.display(root), persons: tree.list("person").length }) + "\n");
         // a way back first
         let backup;
         const all = packPlan(tree, shared, true).media.reduce((s, m) => s + m.size, 0);
-        if (await ctx.confirm(ui(lang, "ui.remove.backup", { mb: mb(all) }), true)) {
+        if (await ctx.confirm(ui(lang, "ui.remove.backup", { size: mb(all, lang) }), true)) {
             const out = defaultPackFile(ctx, tree);
             backup = packTree(tree, shared, out, true).file;
             ctx.io.stdout(ui(lang, "ui.remove.backup.done", { file: ctx.display(backup) }) + "\n");
         }
-        const images = only.length > 0 && (await ctx.confirm(ui(lang, "ui.remove.images", { n: only.length, mb: mb(onlyBytes) }), backup !== undefined));
+        const images = only.length > 0 && (await ctx.confirm(ui(lang, "ui.remove.images", { n: only.length, size: mb(onlyBytes, lang) }), backup !== undefined));
         const typed = (await ctx.ask(ui(lang, "ui.remove.type", { name }))).trim();
         if (!typed || foldText(typed) !== foldText(name))
             return { text: ui(lang, "ui.remove.cancelled"), data: { removed: false, ...(backup ? { backup } : {}) } };
@@ -182,7 +181,7 @@ register({
             moveToTrash(folder, ctx.env, ui(lang, "ui.remove.images.folder", { name }));
         }
         const cfg = ctx.settings.config;
-        const text = lines(ui(lang, "ui.remove.done", { name }), followed ? ui(lang, "ui.remove.live") : undefined, moved ? ui(lang, "ui.remove.images.done", { n: moved, mb: mb(onlyBytes) }) : undefined, backup ? ui(lang, "ui.remove.backup.back", { file: ctx.display(backup) }) : undefined, ui(lang, backup ? "ui.remove.trash" : "ui.remove.trash.alone"), next ? ui(lang, "ui.remove.next", { name: next }) : undefined);
+        const text = lines(ui(lang, "ui.remove.done", { name }), followed ? ui(lang, "ui.remove.live") : undefined, moved ? ui(lang, "ui.remove.images.done", { n: moved, size: mb(onlyBytes, lang) }) : undefined, backup ? ui(lang, "ui.remove.backup.back", { file: ctx.display(backup) }) : undefined, ui(lang, backup ? "ui.remove.trash" : "ui.remove.trash.alone"), next ? ui(lang, "ui.remove.next", { name: next }) : undefined);
         return { text, data: { removed: true, root, images: moved, ...(backup ? { backup } : {}), ...(next ? { current: cfg.currentTree } : {}) } };
     },
 });

package/dist/core/live-read.js

@@ -303,6 +303,10 @@ function notReady(tree, settings, env, seen, now) {
 /** A reading's seconds before any of this agent's readers ended here (measured 2026-10-20 and 21): Grok's take minutes. */
 export const READ_EXPECT_DEFAULT = { grok: 240 };
 export const READ_EXPECT_OTHERS = 60;
+/** The seconds a reading is expected to take with this agent before any of its readers ended here (any name: its own key only). */
+export const readExpectDefault = (agent) => (Object.hasOwn(READ_EXPECT_DEFAULT, agent) ? READ_EXPECT_DEFAULT[agent] : READ_EXPECT_OTHERS);
+/** A reader's time past this is no reader's (a journal written by hand, a clock gone wrong): never learned from. */
+export const READER_MS_MAX = DAY_MS;
 /** The readers of documents a reading's time is learned from: the last so many of the agent that read to an end. */
 const EXPECT_LAST = 9;
 const expectSeen = new Map();
@@ -322,7 +326,7 @@ function readerSecs(root, agent) {
         const secs = new Map();
         for (const r of readJournal(file)) {
             const ms = typeof r.wallMs === "number" ? r.wallMs : typeof r.ms === "number" ? r.ms : NaN;
-            if (r.kind !== "document" || r.outcome !== "ok" || typeof r.agent !== "string" || !(ms >= 0))
+            if (r.kind !== "document" || r.outcome !== "ok" || typeof r.agent !== "string" || !(ms >= 0 && ms <= READER_MS_MAX))
                 continue;
             secs.set(r.agent, [...(secs.get(r.agent) ?? []), ms / 1000].slice(-EXPECT_LAST));
         }
@@ -339,7 +343,7 @@ function readerSecs(root, agent) {
 export function expectSecs(root, agent, rounds = 1) {
     const secs = readerSecs(root, agent).sort((a, b) => a - b);
     const mid = secs.length >> 1;
-    const one = secs.length ? (secs.length % 2 ? secs[mid] : (secs[mid - 1] + secs[mid]) / 2) : (READ_EXPECT_DEFAULT[agent] ?? READ_EXPECT_OTHERS);
+    const one = secs.length ? (secs.length % 2 ? secs[mid] : (secs[mid - 1] + secs[mid]) / 2) : readExpectDefault(agent);
     return Math.max(1, Math.round(one * Math.max(1, rounds)));
 }
 /** A reading at work or queued: how long it is expected to take from its start (since, when it is reading). */

package/dist/core/phone.js

@@ -248,6 +248,19 @@ export function phoneRunning(env) {
     const run = phoneRun(env);
     return run && !run.ended && alive(run.pid) ? run : undefined;
 }
+/** How long a server just started may take to say itself (phone-run.json) before another may be started. */
+const SPAWN_SAYS_MS = 20_000;
+/**
+ * A server started a moment ago that has not said itself yet (Node starting, its addresses bound): its pid while it
+ * lives. Several asking at once (a bridge of each research, a strom just updated) start that one, not one each.
+ */
+function startedJustNow(env) {
+    const s = readSafe(file(env, "phone-spawn.json"));
+    if (!s || typeof s.pid !== "number" || typeof s.at !== "string")
+        return undefined;
+    const age = Date.now() - Date.parse(s.at);
+    return age >= 0 && age < SPAWN_SAYS_MS && alive(s.pid) ? s.pid : undefined;
+}
 function spawnPhone(env, extra = {}) {
     const { command, args } = stromLauncher();
     const dir = configDir(env);
@@ -270,6 +283,14 @@ function spawnPhone(env, extra = {}) {
     child.unref();
     if (typeof log === "number")
         fs.closeSync(log);
+    if (child.pid) {
+        try {
+            writeJson(file(env, "phone-spawn.json"), { pid: child.pid, at: new Date().toISOString() });
+        }
+        catch {
+            // another may start one meanwhile: the one that gets the server's lock serves, the other ends at once
+        }
+    }
     return child.pid;
 }
 /**
@@ -293,9 +314,13 @@ export function startPhone(env, opts = {}) {
         const now = phoneRunning(env);
         if (now)
             return now;
-        if (opts.why)
-            notePhone(env, opts.why);
-        const pid = spawnPhone(env);
+        // one started a moment ago and not said yet: waited for, none started beside it
+        let pid = startedJustNow(env);
+        if (!pid) {
+            if (opts.why)
+                notePhone(env, opts.why);
+            pid = spawnPhone(env);
+        }
         const waitMs = opts.waitMs ?? 8000;
         for (let waited = 0; pid && waited < waitMs; waited += 50) {
             const run = phoneRun(env);
@@ -552,19 +577,19 @@ function pairMs(env) {
     const t = Number(env.STROM_PHONE_PAIR_MS);
     return phoneTest(env) && Number.isFinite(t) && t > 0 ? t : PAIR_MS;
 }
-function readPair(env) {
+function readPair(env, clock = Date.now) {
     const p = readSafe(file(env, "phone-pair.json"));
-    return p && typeof p.code === "string" && /^[A-Za-z0-9_-]{22}$/.test(p.code) && isTime(p.expiresAt) && Date.parse(p.expiresAt) > Date.now() ? p : undefined;
+    return p && typeof p.code === "string" && /^[A-Za-z0-9_-]{22}$/.test(p.code) && isTime(p.expiresAt) && Date.parse(p.expiresAt) > clock() ? p : undefined;
 }
 /** When the code to pair a phone ends, while there is one (never the code). */
-export function pairExpires(env) {
-    return readPair(env)?.expiresAt;
+export function pairExpires(env, clock = Date.now) {
+    return readPair(env, clock)?.expiresAt;
 }
 /**
  * The code to pair a phone: the one that holds, else a new one (128 bits, PAIR_MS long, kept for strom's user alone).
  * `tree`: the tree whose QR code it is (the last one shown wins: the page opens it once paired).
  */
-export function pairCode(env, opts = {}) {
+export function pairCode(env, opts = {}, clock = Date.now) {
     return withLock(file(env, "phone-pair.lock"), { owner: "the code to pair a phone" }, () => {
         const f = file(env, "phone-pair.json");
         const write = (p) => {
@@ -576,7 +601,7 @@ export function pairCode(env, opts = {}) {
                 // Windows: the user's folder is theirs
             }
         };
-        const now = readPair(env);
+        const now = readPair(env, clock);
         if (now) {
             // the last shown counts: one shown with no tree (outside a tree's folder) opens the tree the page chose
             if (now.tree !== opts.tree) {
@@ -586,7 +611,7 @@ export function pairCode(env, opts = {}) {
             return { code: now.code, expiresAt: now.expiresAt };
         }
         const code = crypto.randomBytes(16).toString("base64url");
-        const at = new Date();
+        const at = new Date(clock());
         const expiresAt = new Date(at.getTime() + pairMs(env)).toISOString();
         write({ code, at: at.toISOString(), expiresAt, ...(opts.tree ? { tree: opts.tree } : {}) });
         notePhone(env, `a code to pair a phone made, it holds until ${expiresAt}`);
@@ -623,9 +648,9 @@ export function phoneName(ua) {
  * The code given back by a phone's page, taken once: right and holding — the phone paired (its key, only now and only
  * to it); anything else — none, and the code still holds for the phone it was shown to.
  */
-export function pairPhone(env, code, info) {
+export function pairPhone(env, code, info, clock = Date.now) {
     const taken = withLock(file(env, "phone-pair.lock"), { owner: "the code to pair a phone" }, () => {
-        const p = readPair(env);
+        const p = readPair(env, clock);
         const a = Buffer.from(p?.code ?? "");
         const b = Buffer.from(code);
         if (!p || a.length !== b.length || !crypto.timingSafeEqual(a, b))

package/dist/core/phrases.js

@@ -111,6 +111,8 @@ export const PHRASES = {
     "fix.model.why.differ": "Read again by {now} (earlier: {before}) where something stayed open, and the readings differ.",
     "fix.model.why.refined": "Read again by {now} (earlier: {before}) where something stayed open, and the new reading reads more or is surer.",
     "fix.model.done": "both readings held against each other ({show} {old} · {show} {now}) and against {sources}: what holds kept on the source, the facts on it checked; nothing taken away without a reason",
+    "fix.differs": "What differs: earlier {before}, now {now}.",
+    "fix.more": "Read now beside the earlier: {now}.",
     "fix.model.unknown": "a model not recorded",
     "fix.model.own": "its own model",
     "batch.unnamed": "material from the Strom app",

package/dist/core/tree.js

@@ -27,7 +27,7 @@ import { lastBackup } from "./backup.js";
 export const TREE_FILE = "strom.json";
 // 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.19.0-beta.5";
+export const VERSION = "1.19.0-beta.7";
 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.19.0-beta.5",
+  "version": "1.19.0-beta.7",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {