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

package/CHANGELOG.cs.md

@@ -7,7 +7,7 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 
 ## 1.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.6. 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á
@@ -30,15 +30,16 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   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 — a úkol jednou větou
+  řekne, který údaj se liší. 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ě.
 
 ## 1.18.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.6. 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
@@ -31,20 +31,21 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   Neustart des Computers startet, sagen `strom phone` und die Einstellungen, dass die Verbindung an ist und ihr Server
   mit der Forschung wieder startet.
 - **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 —, und die Aufgabe sagt in
+  einem Satz, welche Angabe abweicht. 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.
 
 ## 1.18.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.6. 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:
@@ -32,16 +32,17 @@ The changes of each version in short. The full notes and the install lines are o
   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 — the task says in one sentence which of them
+  differs. 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.
 
 ## 1.18.0
 

package/assets/lang/cs.json

@@ -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

@@ -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/dist/commands/fixchecks.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).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 };
     });
 }
@@ -719,39 +748,94 @@ 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));
+// 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 no name.
+ */
+function readOf(text, unclear, found, prose = false) {
+    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();
+    for (const m of clean.matchAll(/[\p{L}\p{M}\p{N}]+/gu)) {
+        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) && opensSentence(clean, m.index, w.length))
+            continue;
+        if (digits || (w.length > 1 && (!cased || /^\p{Lu}/u.test(w))))
+            if (!facts.has(k))
+                facts.set(k, w);
+    }
+    return { facts, words, unclear, found };
+}
+/**
+ * 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) {
+    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);
+}
+/** 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;
 }
-/** 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).
+ * Nothing read: failed.
  */
 export function compareReadings(before, now) {
-    return now.length ? compareTexts(readText(before), readText(now)) : "failed";
+    return now.length ? compareRead(readOfBlocks(before), readOfBlocks(now)) : { 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 };
+    const surer = b.unclear < a.unclear || (b.found && !a.found);
+    return { result: now.length || surer ? "refined" : "same", before, now };
 }
 // ── 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)), ...(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;

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.6";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/package.json

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