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

package/CHANGELOG.cs.md

@@ -7,7 +7,7 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 
 ## 1.18.0
 
-*Připravuje se: bety do 1.18.0-beta.3. Oddíl bude úplný s vydáním.*
+*Připravuje se: bety do 1.18.0-beta.4. Oddíl bude úplný s vydáním.*
 
 - **Fotky z telefonu nastojato.** Fotka otočená podle údaje EXIF se čte tak, jak se má dívat, nastojato; místa na ní
   vyznačená (výřezy, poloviny dvoustrany, uložená část) jsou místa obrázku, jak se ukazuje. Fotka sama zůstává, jak
@@ -20,7 +20,8 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   z matriky, dopis, listinu, náhrobek, rub fotky: přepis slovo od slova, překlad, význam starých slov a zkratek
   a osoby, které jmenuje, i s tím, kdo ze stromu to může být. Nic se nedomýšlí: jméno, které v dokumentu není,
   vypadne — i příjmení, nikdy se nebere od otce ani z jiné rodiny —, co nejde přečíst, je označené; druhý čtenář
-  může číst naslepo. Do stromu se z toho nic nezapíše samo.
+  může číst naslepo. Do stromu se z toho nic nezapíše samo. Dokument už přečtený to o sobě řekne, takže se omylem
+  nečte podruhé.
 - **Fotky z telefonu.** `strom phone on`, které zapíná jen člověk, pustí k počítači telefon v domácí síti (Wi-Fi
   nebo kabel — nikdy mobilní síť ani VPN). Telefon se jednou spáruje přes QR kód; jeho stránka pak fotí nebo vybírá
   z galerie a posílá fotky celé do stromu výzkumu, s poznámkou a osobou, kterou ukazují — stejně jako „Přidat

package/CHANGELOG.de.md

@@ -7,7 +7,7 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.18.0
 
-*In Vorbereitung: die Betas bis 1.18.0-beta.3. Der Abschnitt ist mit dem Release vollständig.*
+*In Vorbereitung: die Betas bis 1.18.0-beta.4. Der Abschnitt ist mit dem Release vollständig.*
 
 - **Handyfotos aufrecht.** Ein Foto, das nach seiner EXIF-Ausrichtung gedreht ist, wird gelesen, wie es gesehen
   werden soll, aufrecht; die darauf markierten Stellen (Ausschnitte, die Hälften einer Doppelseite, ein gespeicherter
@@ -21,7 +21,8 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   Abschrift Wort für Wort, ihre Übersetzung, was alte Wörter und Abkürzungen bedeuten, und die genannten Personen,
   samt wem im Stammbaum sie entsprechen können. Nichts wird ergänzt: ein Name, der nicht im Dokument steht, fällt
   weg — auch ein Nachname, nie vom Vater oder aus einer anderen Familie genommen —, Unleserliches wird markiert; ein
-  zweiter Leser kann blind lesen. In den Stammbaum gelangt nichts von selbst.
+  zweiter Leser kann blind lesen. In den Stammbaum gelangt nichts von selbst. Ein schon gelesenes Dokument sagt es,
+  so wird es nicht versehentlich ein zweites Mal gelesen.
 - **Fotos vom Handy.** `strom phone on`, das nur ein Mensch einschaltet, lässt ein Handy im Heimnetz (WLAN oder
   Kabel — nie ein Mobilfunknetz oder ein VPN) zu diesem Computer. Das Handy wird einmal per QR-Code gekoppelt; seine
   Seite fotografiert dann oder wählt aus der Galerie und schickt die Fotos ganz in einen Stammbaum der Forschung, mit

package/CHANGELOG.md

@@ -7,7 +7,7 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 1.18.0
 
-*In preparation: the betas up to 1.18.0-beta.3. The section is complete with the release.*
+*In preparation: the betas up to 1.18.0-beta.4. The section is complete with the release.*
 
 - **Phone photos upright.** A photo turned by its EXIF orientation is read as it is meant to be seen, upright; the
   places marked on it (excerpts, the halves of a spread, a cut-out part) are of the picture as it is shown. The
@@ -20,7 +20,8 @@ The changes of each version in short. The full notes and the install lines are o
   entry, a letter, a deed, a gravestone, the back of a photo: the transcript word for word, its translation, what its
   old words and abbreviations mean, and the people it names, with who of the tree they may be. Nothing is filled in:
   a name the document does not have is left out — a surname too, never taken from a father or another family —,
-  what cannot be read is marked; a second reader can read it blind. Nothing of it enters the tree by itself.
+  what cannot be read is marked; a second reader can read it blind. Nothing of it enters the tree by itself. A
+  document read already says so, so it is not read a second time by mistake.
 - **Photos from a phone.** `strom phone on`, turned on by the person alone, lets a phone on the home network (Wi-Fi
   or a cable — never a mobile network or a VPN) reach this computer. The phone is paired once by its QR code; its
   page then takes photos or picks them from the gallery and sends them whole into a tree of the research, with a

package/assets/lang/cs.json

@@ -674,6 +674,15 @@
   "sync.reading.note": "Uživatel přečetl tento záznam v aplikaci Strom jinak ({source}); čtení výzkumu platí, dokud se záznam nepřečte znovu:",
   "sync.reading.page": "strana",
   "sync.reading.text": "přepis",
+  "read.note.source.edited": "Přepis byl upraven v aplikaci Strom; čtení {read} má: {text}",
+  "read.note.edited": "Přepis byl upraven v aplikaci Strom: vodítko, dokud se záznam nepřečte ({read})",
+  "read.note.one": "Přečetl jeden čtenář ({read}): možné do druhého, slepého čtení a vlastního pohledu výzkumu na záznam",
+  "read.note.differ": "Čtenáři {read} přečetli jinak: {list} — vodítko, dokud se záznam nepřečte",
+  "read.note.absent": "Čtení {read} to tak neuvádí: vodítko, dokud se záznam nepřečte",
+  "read.note.uncertain": "Čtenář {read} si tím nebyl jistý: vodítko, dokud se záznam nepřečte",
+  "read.verify.what": "Ověřit čtení dokumentu u osoby {name}: {list}",
+  "read.verify.why": "údaje stojí na čtení čtenářů stromu ({read}, potvrzeném v aplikaci Strom, {source}), které ještě není jisté: jeden čtenář, rozdílná čtení, nebo ručně upravený přepis; druhé, slepé čtení a vlastní pohled výzkumu na záznam je doloží, nebo ukáže chybu",
+  "read.verify.done": "po jednom čtenáři druhý, slepý (strom document again {read} --readers 2) a zápis prohlédnutý výzkumem samotným (strom source show {source}, jeho snímek): čtení se shodují → pravděpodobné, prokázané až po tomto pohledu a jen u primární informace; liší se → rozpor s oběma čteními",
   "archive.held": "odloženo: výzkum je Archiv Stromu (data přicházejí z aplikace Strom); do fronty se vrátí, až se zapne práce s agentem",
   "archive.removed": "odebráno v aplikaci Strom",
   "archive.wait": "Rozhodnutí o stahování z archivu {title}",
@@ -1172,6 +1181,8 @@
   "ui.sync.do.family.cite.read": "bude ho citovat rodina (její sňatek), na čtení záznamu z aplikace",
   "ui.sync.do.source.new": "pramen výzkumu; přepis z aplikace je vodítko, dokud záznam nepřečte výzkum",
   "ui.sync.do.source.new.read": "pramen výzkumu; přepis z aplikace platí jako čtení záznamu",
+  "ui.sync.do.source.new.reading": "pramen výzkumu z jeho vlastního čtení dokumentu (snímek a výřez zápisu): údaje tak jisté, jak je čtenáři přečetli",
+  "ui.sync.do.source.new.reading.edited": "pramen výzkumu z jeho čtení dokumentu, přepis upravený v aplikaci: údaje jsou vodítko, dokud záznam nepřečte výzkum",
   "ui.sync.do.source.changed": "převezme se: je to čtení z aplikace",
   "ui.sync.do.source.changed.read": "převezme se: je to čtení z aplikace a platí",
   "ui.sync.do.source.reading": "uloží se vedle čtení výzkumu; výzkum záznam přečte znovu",
@@ -1180,6 +1191,7 @@
   "ui.sync.do.fact.cite": "údaj výzkumu ho bude citovat (vodítko, dokud záznam nepřečte výzkum)",
   "ui.sync.do.fact.cite.read": "údaj výzkumu ho bude citovat a stojí na čtení záznamu z aplikace",
   "ui.sync.do.reading": "přidá se na čtení záznamu z aplikace",
+  "ui.sync.do.reading.document": "přidá se tak jistý, jak ho čtenáři dokumentu přečetli (jeden čtenář: možné, dva ve shodě: pravděpodobné, rozdílně: vodítko)",
   "ui.sync.family.new": "{n}. nová rodina: {who}{kids}",
   "ui.sync.child.new": "{n}. {who}: dítě — {child}",
   "ui.sync.child.gone": "{n}. {who}: už to není jejich dítě — {child}",

package/assets/lang/de.json

@@ -674,6 +674,15 @@
   "sync.reading.note": "Der Benutzer hat diesen Eintrag in der Strom-App anders gelesen ({source}); die Lesung der Forschung gilt, bis er erneut gelesen ist:",
   "sync.reading.page": "Seite",
   "sync.reading.text": "Abschrift",
+  "read.note.source.edited": "Die Abschrift wurde in der Strom-App geändert; die Lesung {read} hat: {text}",
+  "read.note.edited": "Die Abschrift wurde in der Strom-App geändert: ein Hinweis, bis der Eintrag gelesen ist ({read})",
+  "read.note.one": "Von einem Leser gelesen ({read}): möglich bis zu einer zweiten, blinden Lesung und dem eigenen Blick der Forschung auf den Eintrag",
+  "read.note.differ": "Die Leser von {read} lasen es verschieden: {list} — ein Hinweis, bis der Eintrag gelesen ist",
+  "read.note.absent": "Die Lesung {read} sagt es nicht so: ein Hinweis, bis der Eintrag gelesen ist",
+  "read.note.uncertain": "Der Leser von {read} war sich dessen nicht sicher: ein Hinweis, bis der Eintrag gelesen ist",
+  "read.verify.what": "Die Lesung eines Dokuments für {name} prüfen: {list}",
+  "read.verify.why": "die Angaben stehen auf einer Lesung der Leser von strom ({read}, in der Strom-App bestätigt, {source}), die noch nicht sicher ist: ein Leser, verschiedene Lesungen oder die Abschrift von Hand geändert; eine zweite, blinde Lesung und der eigene Blick der Forschung auf den Eintrag belegen sie oder zeigen einen Fehler",
+  "read.verify.done": "nach einem Leser ein zweiter, blinder (strom document again {read} --readers 2), und der Eintrag von der Forschung selbst angesehen (strom source show {source}, sein Bild): die Lesungen stimmen überein → wahrscheinlich, belegt erst nach diesem Blick und nur bei primärer Information; sie weichen ab → ein Widerspruch mit beiden Lesungen",
   "archive.held": "zurückgestellt: die Forschung ist ein Strom-Archiv (die Daten kommen aus der Strom-App); zurück in der Warteschlange, wenn die Arbeit mit einem Agenten eingeschaltet wird",
   "archive.removed": "in der Strom-App entfernt",
   "archive.wait": "Entscheidung über das Herunterladen aus dem Archiv {title}",
@@ -1172,6 +1181,8 @@
   "ui.sync.do.family.cite.read": "die Familie (ihre Heirat) zitiert sie, auf die eigene Lesung des Eintrags",
   "ui.sync.do.source.new": "eine Quelle der Forschung; die eigene Abschrift ist ein Hinweis, bis die Forschung den Eintrag liest",
   "ui.sync.do.source.new.read": "eine Quelle der Forschung; die eigene Abschrift gilt als Lesung des Eintrags",
+  "ui.sync.do.source.new.reading": "eine Quelle der Forschung aus ihrer eigenen Lesung des Dokuments (Bild und Ausschnitt des Eintrags): die Angaben so sicher, wie die Leser sie lasen",
+  "ui.sync.do.source.new.reading.edited": "eine Quelle der Forschung aus ihrer Lesung des Dokuments, die Abschrift in der App geändert: die Angaben ein Hinweis, bis die Forschung den Eintrag liest",
   "ui.sync.do.source.changed": "übernommen: es ist die eigene Lesung",
   "ui.sync.do.source.changed.read": "übernommen: es ist die eigene Lesung, und sie gilt",
   "ui.sync.do.source.reading": "neben der Lesung der Forschung festgehalten; die Forschung liest den Eintrag erneut",
@@ -1180,6 +1191,7 @@
   "ui.sync.do.fact.cite": "die Angabe der Forschung zitiert sie (ein Hinweis, bis die Forschung den Eintrag liest)",
   "ui.sync.do.fact.cite.read": "die Angabe der Forschung zitiert sie und steht auf der eigenen Lesung des Eintrags",
   "ui.sync.do.reading": "hinzugefügt auf der eigenen Lesung des Eintrags",
+  "ui.sync.do.reading.document": "wird so sicher hinzugefügt, wie die Leser des Dokuments es lasen (ein Leser: möglich, zwei übereinstimmend: wahrscheinlich, verschieden: ein Hinweis)",
   "ui.sync.family.new": "{n}. eine neue Familie: {who}{kids}",
   "ui.sync.child.new": "{n}. {who}: ein Kind — {child}",
   "ui.sync.child.gone": "{n}. {who}: nicht mehr ihr Kind — {child}",

package/dist/brief/brief.js

@@ -22,6 +22,7 @@ import { clock, hostAllowed, hostState, REFUSED_FOREVER } from "../core/net.js";
 import { archiveLevel } from "../core/terms.js";
 import { onHost, permissionQuestions, setHosts } from "../core/archivewait.js";
 import { runs, runsArg, shellArg } from "../cli/format.js";
+import { readingsLine, readingsOf } from "../core/readsync.js";
 import { commandSheet } from "./sheet.js";
 import { foldText } from "../core/text.js";
 import { subjectPeople } from "../core/records.js";
@@ -933,9 +934,13 @@ export function buildBrief(tree, opts) {
                         const file = inputPath(tree, i);
                         // all that strom input show says of it, so it needs no extra command (K6)
                         const small = !i.text && i.kind === "text" && file && (i.size ?? 0) < 20_000 && /\.(txt|md|csv)$/i.test(file) ? readSmall(file) : undefined;
+                        // read already (strom document read): its result, the file not read again
+                        const read = readingsLine(tree, i);
+                        const readDone = readingsOf(tree, i).some((r) => r.state === "done");
                         return [
                             `${i.id} ${i.name} [${i.kind} · ${i.state}]${i.from ? ` from ${i.from}` : ""}${i.mime ? ` · ${i.mime}${i.size !== undefined ? ` ${Math.round(i.size / 1024)} kB` : ""}` : ""}`,
-                            file ? `file: ${file}${i.kind === "document" || i.kind === "photo" ? " — open it and read it yourself" : ""}` : "",
+                            file ? `file: ${file}${(i.kind === "document" || i.kind === "photo") && !readDone ? " — open it and read it yourself" : ""}` : "",
+                            read ? `read: ${read}` : "",
                             i.batch ? `batch: ${i.batch}${i.path ? ` · ${i.path}` : ""}` : "",
                             i.persons?.length ? `of: ${i.persons.join(", ")}` : "",
                             i.sorted ? `sorted: ${i.sorted.as}${i.sorted.source ? ` → ${i.sorted.source}` : ""}${i.sorted.reason ? ` (${i.sorted.reason})` : ""}` : "",

package/dist/cli/ui.js

@@ -1073,6 +1073,8 @@ export const UI = {
     "ui.sync.do.family.cite.read": "the family (its marriage) cites it, on the file's reading of the record",
     "ui.sync.do.source.new": "a source of the research; the file's transcript is a lead until the research reads the record",
     "ui.sync.do.source.new.read": "a source of the research; the file's transcript counts as a reading of the record",
+    "ui.sync.do.source.new.reading": "a source of the research from its own reading of the document (its picture and the entry's excerpt): the facts as sure as its readers read them",
+    "ui.sync.do.source.new.reading.edited": "a source of the research from its reading of the document, the transcript changed in the app: the facts a lead until the research reads the record",
     "ui.sync.do.source.changed": "taken: it is the file's reading",
     "ui.sync.do.source.changed.read": "taken: it is the file's reading, and it counts",
     "ui.sync.do.source.reading": "kept beside the research's reading; the research reads the record again",
@@ -1081,6 +1083,7 @@ export const UI = {
     "ui.sync.do.fact.cite": "the research's fact cites it (a lead on it until the research reads the record)",
     "ui.sync.do.fact.cite.read": "the research's fact cites it and stands on the file's reading of the record",
     "ui.sync.do.reading": "added on the file's reading of the record",
+    "ui.sync.do.reading.document": "added as sure as the readers of the document read it (one reader: possible; two alike: probable; apart: a lead)",
     "ui.sync.family.new": "{n}. a new family: {who}{kids}",
     "ui.sync.child.new": "{n}. {who}: a child — {child}",
     "ui.sync.child.gone": "{n}. {who}: no longer their child — {child}",

package/dist/commands/document.js

@@ -562,20 +562,21 @@ register({
     tree: true,
     args: [{ name: "reading", description: "the reading: D…", required: true }],
     examples: ["strom document show D20260101120000-ab12 --json"],
-    run: (ctx, { args }) => {
-        const tree = ctx.tree();
-        const id = readId(args[0]);
-        const s = loadState(tree.root, id);
-        let result;
-        if (s)
-            result = buildResult(tree, settled(tree, s));
-        else if (fs.existsSync(resultPath(tree.root, id)))
-            result = JSON.parse(fs.readFileSync(resultPath(tree.root, id), "utf8"));
-        else
-            throw new UsageError(`no reading ${id}`, { hint: "strom document list" });
-        return { text: said(ctx, result), data: result };
-    },
+    run: (ctx, { args }) => showReading(ctx, readId(args[0])),
 });
+/** A reading of a document as strom document show (and strom readings D…) says it: its result, or what its readers wrote so far. */
+export function showReading(ctx, id) {
+    const tree = ctx.tree();
+    const s = loadState(tree.root, id);
+    let result;
+    if (s)
+        result = buildResult(tree, settled(tree, s));
+    else if (fs.existsSync(resultPath(tree.root, id)))
+        result = JSON.parse(fs.readFileSync(resultPath(tree.root, id), "utf8"));
+    else
+        throw new UsageError(`no reading ${id}`, { hint: "strom document list" });
+    return { text: said(ctx, result), data: result };
+}
 register({
     path: ["document", "list"],
     summary: "The readings of documents of this research, newest first",

package/dist/commands/intake.js

@@ -8,6 +8,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { register } from "../cli/registry.js";
 import { counted, lines, moreLine, paginate, table, truncate } from "../cli/format.js";
+import { readingsLine, readingsOf } from "../core/readsync.js";
 import { notFound, UsageError } from "../core/errors.js";
 import { collectFiles, fileSha256, inputPath, MAX_IN_TREE, mimeOf, storeShared } from "../core/media.js";
 import { create, normId, requireRecord, update } from "../core/records.js";
@@ -248,8 +249,9 @@ register({
         const all = ctx.tree().list("input").filter((i) => !opts.state || i.state === opts.state);
         const page = paginate(all, ctx.limit, ctx.page);
         return {
-            text: all.length ? lines(table(page.items.map((i) => [i.id, i.kind, i.state, truncate(i.name, 60)])), moreLine(page, "strom input list")) : 'no inputs → strom intake <files or folder>',
-            data: { total: all.length, inputs: opts.full ? page.items : page.items.map((i) => ({ id: i.id, kind: i.kind, state: i.state, name: i.name })) },
+            // a file read already (strom document read) says so: its reading, not read again
+            text: all.length ? lines(table(page.items.map((i) => [i.id, i.kind, i.state, truncate(i.name, 60), i.read?.length ? `read ${i.read[i.read.length - 1]} (strom readings ${i.read[i.read.length - 1]})` : ""])), moreLine(page, "strom input list")) : 'no inputs → strom intake <files or folder>',
+            data: { total: all.length, inputs: opts.full ? page.items : page.items.map((i) => ({ id: i.id, kind: i.kind, state: i.state, name: i.name, ...(i.read?.length ? { read: i.read } : {}) })) },
         };
     },
 }, {
@@ -263,10 +265,10 @@ register({
         const i = requireRecord(tree, args[0], "input");
         const abs = inputPath(tree, i);
         const tasks = tree.list("task").filter((t) => t.where.includes(i.id));
-        const text = lines(`${i.id} ${i.name}  [${i.kind} · ${i.state}]`, abs ? `file   ${abs}` : undefined, i.from ? `from   ${i.from}` : undefined, i.batch ? `batch  ${i.batch}${i.path ? ` · ${i.path}` : ""}` : undefined, i.persons?.length ? `of     ${i.persons.join(", ")}` : undefined, i.sorted ? `sorted ${i.sorted.as}${i.sorted.source ? ` → ${i.sorted.source}` : ""}${i.sorted.reason ? ` (${i.sorted.reason})` : ""}` : undefined, i.mime ? `type   ${i.mime}${i.size !== undefined ? ` · ${Math.round(i.size / 1024)} kB` : ""}` : undefined, i.imported ? `import ${i.imported.persons} persons, ${i.imported.families} families as leads, cited as ${i.source}` : undefined, i.text ? `\n${i.text}` : undefined, !i.text && i.kind === "text" && abs && fs.existsSync(abs) && (i.size ?? 0) < 20_000 && /\.(txt|md|csv)$/i.test(abs) ? `\n${fs.readFileSync(abs, "utf8").trim()}` : undefined, tasks.length ? `\ntasks\n${table(tasks.map((t) => [`  ${t.id}`, t.state, truncate(t.what, 60)]))}` : undefined, ...i.notes.map((n) => `note   ${n.text}`), i.kind === "document" && abs
+        const text = lines(`${i.id} ${i.name}  [${i.kind} · ${i.state}]`, abs ? `file   ${abs}` : undefined, i.from ? `from   ${i.from}` : undefined, i.batch ? `batch  ${i.batch}${i.path ? ` · ${i.path}` : ""}` : undefined, i.persons?.length ? `of     ${i.persons.join(", ")}` : undefined, i.sorted ? `sorted ${i.sorted.as}${i.sorted.source ? ` → ${i.sorted.source}` : ""}${i.sorted.reason ? ` (${i.sorted.reason})` : ""}` : undefined, i.mime ? `type   ${i.mime}${i.size !== undefined ? ` · ${Math.round(i.size / 1024)} kB` : ""}` : undefined, i.imported ? `import ${i.imported.persons} persons, ${i.imported.families} families as leads, cited as ${i.source}` : undefined, i.read?.length ? `read   ${readingsLine(tree, i)}` : undefined, i.text ? `\n${i.text}` : undefined, !i.text && i.kind === "text" && abs && fs.existsSync(abs) && (i.size ?? 0) < 20_000 && /\.(txt|md|csv)$/i.test(abs) ? `\n${fs.readFileSync(abs, "utf8").trim()}` : undefined, tasks.length ? `\ntasks\n${table(tasks.map((t) => [`  ${t.id}`, t.state, truncate(t.what, 60)]))}` : undefined, ...i.notes.map((n) => `note   ${n.text}`), i.kind === "document" && abs && !readingsOf(tree, i).some((r) => r.state === "done")
             ? `\nread the file (a big image: strom media view ${i.id} --grid, then --crop), then record what it says: strom source add … --input ${i.id}`
             : undefined);
-        return { text, data: { input: i, path: abs, tasks: tasks.map((t) => t.id) } };
+        return { text, data: { input: i, path: abs, tasks: tasks.map((t) => t.id), ...(i.read?.length ? { readings: readingsOf(tree, i) } : {}) } };
     },
 }, {
     path: ["input", "done"],

package/dist/commands/output.js

@@ -13,7 +13,7 @@ import { UsageError } from "../core/errors.js";
 import { excerptSettings, planExcerpts } from "../core/excerpt.js";
 import { runGit, tracked } from "../core/git.js";
 import { Settings } from "../core/config.js";
-import { appKnowsArchive, appKnowsNoCouple, appShowsHypothesisLinks, appDecidesConflicts, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsSourceReads, appShowsFactStatus, appShowsStoryDrafts, appTurnsExcerpts } from "../core/stromapp.js";
+import { appKnowsArchive, appKnowsNoCouple, appShowsHypothesisLinks, appShowsReadings, appDecidesConflicts, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsSourceReads, appShowsFactStatus, appShowsStoryDrafts, appTurnsExcerpts } from "../core/stromapp.js";
 import { EXCERPT_QUALITIES, EXCERPT_SCOPES } from "../core/model.js";
 import { ui } from "../cli/ui.js";
 import { isAgent } from "../core/which.js";
@@ -91,7 +91,9 @@ export function writeTreeGed(tree, opts) {
     const hypothesisLinks = opts.for === "strom" && appShowsHypothesisLinks(new Settings(tree.env, {}), opts.stromVersion);
     // …and the sides of a conflict of the user's edit, for an app that decides it
     const conflictSides = opts.for === "strom" && appDecidesConflicts(new Settings(tree.env, {}), opts.stromVersion);
-    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}), ...(clips ? { clips } : {}), ...(research ? { research } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}), ...(hypothesisLinks ? { hypothesisLinks } : {}), ...(conflictSides ? { conflictSides } : {}) });
+    // …and the reading of a document each source is an entry of, for an app that opens it
+    const readings = opts.for === "strom" && appShowsReadings(new Settings(tree.env, {}), opts.stromVersion);
+    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}), ...(clips ? { clips } : {}), ...(research ? { research } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}), ...(hypothesisLinks ? { hypothesisLinks } : {}), ...(conflictSides ? { conflictSides } : {}), ...(readings ? { readings } : {}) });
     const findings = validateGedcom(result.text, opts.for === "standard" ? { strict: true } : {});
     const file = opts.out ?? gedFile(tree, opts.for, opts.research);
     if (!hasGedErrors(findings) && !tree.dryRun) {

package/dist/commands/readings.js

@@ -9,6 +9,8 @@ import { counted, lines, runs, shellArg, truncate } from "../cli/format.js";
 import { UsageError } from "../core/errors.js";
 import { requireRecord } from "../core/records.js";
 import { imageRange } from "../core/media.js";
+import { listReadings, READ_ID } from "../core/document.js";
+import { showReading } from "./document.js";
 import { parseReport } from "../core/reader.js";
 import { foldText } from "../core/text.js";
 import { REDUCED_BELOW, viewRegion } from "../core/views.js";
@@ -396,20 +398,29 @@ register({
         "blocks with nothing found only what the reader could not read (a possible match is often there), the gaps in\n" +
         "the page numbering and the parts of the book they saw. One image's block word for word: --image N.\n" +
         "Default: the newest reading; with --images, --image or --match all of them. Nothing is written.",
-    args: [{ name: "which", description: "a record set (B…), or a reading: its report's name or the start of it (a day)" }],
+    args: [{ name: "which", description: "a record set (B…), a reading: its report's name or the start of it (a day), or a reading of a document (D…)" }],
     options: [
         { name: "images", type: "string", value: "<from-to>", description: "only these image numbers, e.g. 40-69 or 5-113,130-228" },
         { name: "image", type: "string", value: "<n>", description: "that image's whole block, word for word (a few: 35-38)" },
         { name: "match", type: "string", multiple: true, value: "<words>", description: "only blocks that mention it — any spelling of accents (repeatable: variants)" },
         { name: "list", type: "boolean", description: "the readings there are, one line each" },
     ],
-    examples: ["strom readings", "strom readings B0001 --images 40-69 --match Novák --match Nowak", "strom readings B0001 --image 57", "strom readings --list"],
+    examples: ["strom readings", "strom readings B0001 --images 40-69 --match Novák --match Nowak", "strom readings B0001 --image 57", "strom readings D20260101120000-ab12", "strom readings --list"],
     run(ctx, { args, opts }) {
         const tree = ctx.tree();
+        const which = args[0]?.trim();
+        // a reading of a document (strom document read): its result, as strom document show says it
+        if (which && READ_ID.test(which))
+            return showReading(ctx, which);
         let all = loadReadings(tree);
-        if (all.length === 0)
+        // the readings of documents, one line each, after those of the books (--list)
+        const documents = () => listReadings(tree.root).map((r) => ({ line: `${r.id} · document · ${r.state} · ${r.files.join(", ")} · ${counted(r.pages, "page")} — strom readings ${r.id}`, data: { id: r.id, state: r.state, files: r.files, pages: r.pages } }));
+        if (all.length === 0) {
+            const docs = opts.list ? documents() : [];
+            if (docs.length)
+                return { text: lines(...docs.map((d) => d.line)), data: { readings: [], documents: docs.map((d) => d.data) } };
             return { text: "no readings yet (strom read writes them into notes/readings)", data: { readings: [] } };
-        const which = args[0]?.trim();
+        }
         let book;
         if (which && /^[Bb]\d+$/.test(which))
             book = requireRecord(tree, which, "recordset").id;
@@ -439,8 +450,9 @@ register({
         if (shown.length === 0)
             return { text: `no reader reported ${image !== undefined ? `image ${runs([...image])}` : "these images"}${book ? ` of ${book}` : ""} · strom readings --list`, data: { readings: [] } };
         if (opts.list) {
-            const text = lines(...shown.flatMap(({ r, blocks }) => readingHead(r, blocks)[0].concat(r.question ? ` · "${truncate(r.question, 60)}"` : "")));
-            return { text, data: { readings: shown.map(({ r, blocks }) => ({ stem: r.stem, question: r.question, reports: r.reports, images: blocks.map((b) => b.num) })) } };
+            const docs = which || ranges || image !== undefined || match.length ? [] : documents();
+            const text = lines(...shown.flatMap(({ r, blocks }) => readingHead(r, blocks)[0].concat(r.question ? ` · "${truncate(r.question, 60)}"` : "")), ...docs.map((d) => d.line));
+            return { text, data: { readings: shown.map(({ r, blocks }) => ({ stem: r.stem, question: r.question, reports: r.reports, images: blocks.map((b) => b.num) })), ...(docs.length ? { documents: docs.map((d) => d.data) } : {}) } };
         }
         if (image !== undefined) {
             const text = lines(...shown.flatMap(({ r, blocks }) => blocks.flatMap((b) => [`${b.report}${b.recordset ? ` · ${b.recordset}` : ""}${r.question ? ` · question: ${truncate(r.question, 120)}` : ""}`, `## ${b.text}`, ""])));

package/dist/commands/sync.js

@@ -77,7 +77,7 @@ function newReads(c, incoming) {
     return !!s && s.quay !== 0 && (incoming.transcripts === "evidence" || !!s.verified);
 }
 /** One change as the user reads it, with what strom does with it. */
-function changeLine(tree, c, incoming, lang) {
+function changeLine(tree, c, incoming, lang, readings) {
     const name = (key) => {
         if (!key)
             return "?";
@@ -150,11 +150,16 @@ function changeLine(tree, c, incoming, lang) {
                                             ? "ui.sync.do.detail"
                                             : c.kind === "fact.part" && (c.action === "add" || c.action === "user")
                                                 ? `ui.sync.do.part${c.action === "user" ? ".user" : ""}`
-                                                : c.kind.startsWith("source.") || c.kind === "fact.cite" || c.kind === "person.cite" || c.kind === "family.cite"
-                                                    ? `ui.sync.do.${c.kind}${c.reads || (c.kind === "source.new" && newReads(c, incoming)) ? ".read" : ""}`
-                                                    : c.kind === "fact.new" && c.reads
-                                                        ? "ui.sync.do.reading"
-                                                        : `ui.sync.do.${c.action}`;
+                                                : c.kind === "source.new" && c.reading?.ok
+                                                    ? `ui.sync.do.source.new.reading${c.reading.edited ? ".edited" : ""}`
+                                                    : c.kind.startsWith("source.") || c.kind === "fact.cite" || c.kind === "person.cite" || c.kind === "family.cite"
+                                                        ? `ui.sync.do.${c.kind}${c.reads || (c.kind === "source.new" && newReads(c, incoming)) ? ".read" : ""}`
+                                                        : c.kind === "fact.new" && c.reads
+                                                            ? "ui.sync.do.reading"
+                                                            // a fact on an entry of the research's reading of a document: as sure as its readers read it
+                                                            : c.kind === "fact.new" && c.fact?.cites?.some((x) => readings?.get(x.source)?.ok)
+                                                                ? "ui.sync.do.reading.document"
+                                                                : `ui.sync.do.${c.action}`;
     // an archive: nobody reads a record there, nor is an agent told — said without it
     const said = actsAsArchive(tree) && `${does}.archive` in UI ? `${does}.archive` : does;
     return `${ui(lang, key, v)} → ${ui(lang, said)}`;
@@ -163,7 +168,7 @@ function planText(tree, plan, incoming, file, lang, edits) {
     const shown = file.includes(" ") ? `"${file}"` : file;
     if (!plan.changes.length)
         return ui(lang, "ui.sync.nothing", { file: path.basename(file) });
-    return lines(ui(lang, "ui.sync.title", { file: path.basename(file), n: plan.changes.length }), plan.base ? ui(lang, "ui.sync.base", { head: plan.head?.slice(0, 8) ?? incoming.since ?? "" }) : ui(lang, plan.head ? "ui.sync.headmissing" : "ui.sync.nobase", { head: plan.head?.slice(0, 8) ?? "" }), plan.partial ? ui(lang, "ui.sync.partial") : undefined, plan.identity.strangers.length ? ui(lang, "ui.sync.strangers", { ids: plan.identity.strangers.join(", ") }) : undefined, "", ...plan.changes.map((c) => `  ${changeLine(tree, c, incoming, lang)}`), "", 
+    return lines(ui(lang, "ui.sync.title", { file: path.basename(file), n: plan.changes.length }), plan.base ? ui(lang, "ui.sync.base", { head: plan.head?.slice(0, 8) ?? incoming.since ?? "" }) : ui(lang, plan.head ? "ui.sync.headmissing" : "ui.sync.nobase", { head: plan.head?.slice(0, 8) ?? "" }), plan.partial ? ui(lang, "ui.sync.partial") : undefined, plan.identity.strangers.length ? ui(lang, "ui.sync.strangers", { ids: plan.identity.strangers.join(", ") }) : undefined, "", ...plan.changes.map((c) => `  ${changeLine(tree, c, incoming, lang, plan.readings)}`), "", 
     // an archive mirrors the app whatever the setting says (planSync)
     actsAsArchive(tree) ? ui(lang, "ui.sync.edits.archive") : ui(lang, "ui.sync.edits", { mode: ui(lang, edits === "user" ? "ui.sync.mode.user" : "ui.sync.mode.conflict") }), ui(lang, "ui.sync.next", { file: shown }));
 }

package/dist/core/live.js

@@ -112,7 +112,7 @@ import { knownNewerVersion, updateChannel } from "./update.js";
 import { whatsNew } from "./whatsnew.js";
 import { gitProgram, runGit } from "./git.js";
 import { RECENT_HOURS, recentChanges, recentNow } from "./recent.js";
-import { appKnowsArchive, appKnowsNoCouple, appShowsHypothesisLinks, appDecidesConflicts, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsFactStatus, appShowsSourceReads, appShowsStoryDrafts, appTurnsExcerpts, appUrlSetting, isAppVersion, isStromAppOrigin } from "./stromapp.js";
+import { appKnowsArchive, appKnowsNoCouple, appShowsHypothesisLinks, appShowsReadings, appDecidesConflicts, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsFactStatus, appShowsSourceReads, appShowsStoryDrafts, appTurnsExcerpts, appUrlSetting, isAppVersion, isStromAppOrigin } from "./stromapp.js";
 import { Settings } from "./config.js";
 import { LINK_SCHEME, linkActions, linkHandlerState, linkHandlerStateLater, linkScheme } from "./links.js";
 import { autoTidy } from "./tidy.js";
@@ -702,7 +702,7 @@ function idsOf(applied, known) {
     return Object.keys(ids.persons).length || Object.keys(ids.sources).length ? { ids } : {};
 }
 /** What the bridge does that an app may ask about (each added once, never taken away). */
-export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes", "hypothesis.links", "status.recent", "spend.readers", "hypothesis.intree", "archive.permission", "task.check", "waiting.groups", "waiting.sent", "waiting.note", "batch.kept", "live.end", "whats.new", "terminal.choice", "person.marriedSurname", "phone", "read.now"];
+export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes", "hypothesis.links", "status.recent", "spend.readers", "hypothesis.intree", "archive.permission", "task.check", "waiting.groups", "waiting.sent", "waiting.note", "batch.kept", "live.end", "whats.new", "terminal.choice", "person.marriedSurname", "phone", "read.now", "read.sync"];
 /** /status recent, when it is ready. */
 function recentOf(root, env, head) {
     const recent = head ? recentNow(root, env, head) : undefined;
@@ -1364,12 +1364,13 @@ export function serveLive(root, env) {
             const titles = appReadsTitles(new Settings(env, {}), version);
             const hypothesisLinks = appShowsHypothesisLinks(new Settings(env, {}), version);
             const conflictSides = appDecidesConflicts(new Settings(env, {}), version);
+            const readings = appShowsReadings(new Settings(env, {}), version);
             const offered = opens ? links(env) : [];
             ged = {
                 head: h,
                 links: offered.join(" "),
                 version: version ?? "",
-                text: exportGedcom(tree, { for: "strom", ...(h ? { head: h } : {}), ...(images ? { excerpts: images.of } : {}), ...(opens ? { clips: true, research: true } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}), ...(hypothesisLinks ? { hypothesisLinks } : {}), ...(conflictSides ? { conflictSides } : {}), ...(offered.length ? { links: offered, ...(linkScheme(env) !== LINK_SCHEME ? { linkScheme: linkScheme(env) } : {}) } : {}) }).text,
+                text: exportGedcom(tree, { for: "strom", ...(h ? { head: h } : {}), ...(images ? { excerpts: images.of } : {}), ...(opens ? { clips: true, research: true } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}), ...(hypothesisLinks ? { hypothesisLinks } : {}), ...(conflictSides ? { conflictSides } : {}), ...(readings ? { readings } : {}), ...(offered.length ? { links: offered, ...(linkScheme(env) !== LINK_SCHEME ? { linkScheme: linkScheme(env) } : {}) } : {}) }).text,
             };
         }
         res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store", "X-Strom-Head": h }).end(ged.text);
@@ -1701,6 +1702,11 @@ export function serveLive(root, env) {
                             : {}),
                         // the changes the research could not write (the rest is written): what and why
                         ...(data.skipped?.length ? { skipped: data.skipped } : {}),
+                        // the sources that said they are an entry of a reading of a document (_STROM_READING): taken as the
+                        // research's reading, or not (why: a stable code) and so the app's own source as any
+                        ...(changes.some((c) => c.reading)
+                            ? { readings: changes.filter((c) => c.reading).map((c) => ({ source: c.source.startsWith("x:") ? `@${c.source.slice(2)}@` : c.source, read: c.reading.id, ok: c.reading.ok, ...(c.reading.entry ? { entry: c.reading.entry } : {}), ...(c.reading.code ? { code: c.reading.code } : {}), ...(c.reading.edited ? { edited: true } : {}) })) }
+                            : {}),
                         head: head(root),
                         ...(data.input ? { input: data.input } : {}),
                         conflicts,

package/dist/core/phrases.js

@@ -60,6 +60,15 @@ export const PHRASES = {
     "sync.reading.note": "The user read this record otherwise in the Strom app ({source}); the research's reading stays until it is read again:",
     "sync.reading.page": "page",
     "sync.reading.text": "transcript",
+    "read.note.source.edited": "The transcript was changed in the Strom app; the reading {read} has: {text}",
+    "read.note.edited": "The transcript was changed in the Strom app: a lead until the record is read ({read})",
+    "read.note.one": "Read by one reader ({read}): possible until a second, blind reading and the research's own look at the record",
+    "read.note.differ": "The readers of {read} read it apart: {list} — a lead until the record is read",
+    "read.note.absent": "The reading {read} does not say it so: a lead until the record is read",
+    "read.note.uncertain": "The reader of {read} was unsure of it: a lead until the record is read",
+    "read.verify.what": "Check the reading of a document for {name}: {list}",
+    "read.verify.why": "the facts stand on a reading by strom's readers ({read}, confirmed in the Strom app, {source}) not sure yet: one reader, readers apart, or the transcript changed by hand; a second, blind reading and the research's own look at the record prove them or show a mistake",
+    "read.verify.done": "after one reader a second, blind one (strom document again {read} --readers 2), and the entry looked at by the research itself (strom source show {source}, its image): the readings agree → probable, proven only after that look and only for primary information; they differ → a conflict with both readings",
     "archive.held": "kept for later: the research is a Strom archive (the data come from the Strom app); back in the queue when work with an agent is switched on",
     "archive.removed": "removed in the Strom app",
     "archive.wait": "Decision on downloading from the archive {title}",

package/dist/core/readsync.js

@@ -0,0 +1,269 @@
+// A reading of a document confirmed in the Strom app (spec 013 U4d): the app writes what the person took of a reading
+// into its tree, one source per entry carrying the reading's mark (_STROM_READING D…, the original's _STROM_SHA), and
+// sends it as any edit. Here the mark is checked against the reading the research keeps, the source is made the
+// research's own (its input, images, the entry's excerpt) and each fact citing it gets its status by what the readers
+// read — never by what the app says.
+import fs from "node:fs";
+import path from "node:path";
+import { buildResult, loadState, READ_ID, resultPath } from "./document.js";
+import { normalizeDate } from "./gdate.js";
+import { Settings } from "./config.js";
+import { exifOrientation, imageSizeOfFile } from "../image/index.js";
+import { shownToFile } from "../image/image.js";
+import { inputPath, mimeOf, storeShared } from "./media.js";
+import { create, update } from "./records.js";
+import { foldText } from "./text.js";
+/** The reading's result as the research keeps it: its finished result (in git), else its state here when done. */
+export function readingResult(tree, id) {
+    if (!READ_ID.test(id))
+        return undefined;
+    try {
+        const file = resultPath(tree.root, id);
+        if (fs.existsSync(file))
+            return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        // an unreadable result is none
+    }
+    const s = loadState(tree.root, id);
+    return s?.state === "done" ? buildResult(tree, s) : undefined;
+}
+/**
+ * The readings of an input (Input.read) as an agent is told of them: each one's ID and state here (its state on this
+ * computer, else its result kept in git) — one read already is not read again, its result is strom readings D….
+ */
+export function readingsOf(tree, input) {
+    return (input.read ?? []).map((id) => ({ id, state: loadState(tree.root, id)?.state ?? readingResult(tree, id)?.state ?? "gone" }));
+}
+/** One line of an input's readings for an agent: "D… done — strom readings D…, not read again", or nothing. */
+export function readingsLine(tree, input) {
+    const all = readingsOf(tree, input);
+    if (!all.length)
+        return undefined;
+    const done = all.filter((r) => r.state === "done");
+    return `${all.map((r) => `${r.id} ${r.state}`).join(", ")} — ${done.length ? `read already: strom readings ${done[done.length - 1].id}; not read again` : `strom readings ${all[all.length - 1].id}`}`;
+}
+/** The words of a transcript as they are compared: NFC, one space, the line breaks (and the reading's " | ") as spaces. */
+// the reading writes a line break of the record as " | ", the app may send it as a new line: the same
+const plain = (t) => (t ?? "").normalize("NFC").replace(/\s*\|\s*/gu, " ").replace(/\s+/gu, " ").trim();
+const tokens = (t) => new Set(foldText(t).split(/[^\p{L}\p{M}\p{N}]+/u).filter(Boolean));
+/** How much of two transcripts is the same words (0–1). */
+function likeness(a, b) {
+    const x = tokens(a);
+    const y = tokens(b);
+    if (!x.size || !y.size)
+        return 0;
+    let both = 0;
+    for (const w of x)
+        if (y.has(w))
+            both++;
+    return (2 * both) / (x.size + y.size);
+}
+/**
+ * Whether the mark is the research's reading: it exists and is read, one of its pages is the original the source
+ * names (by its content), and the source is one entry of it — by the entry the app names, else its words. The
+ * person's words changed since are theirs (edited); the source is still that entry.
+ */
+export function checkReading(tree, mark, text) {
+    const id = mark.id;
+    const no = (code) => ({ id, ok: false, code });
+    if (!READ_ID.test(id))
+        return no("reading.none");
+    const result = readingResult(tree, id);
+    if (!result)
+        return loadState(tree.root, id) ? no("reading.state") : no("reading.none");
+    if (result.state !== "done")
+        return no("reading.state");
+    const shaOf = (p) => p.sha ?? tree.get(p.file)?.sha;
+    const pages = result.pages.filter((p) => mark.shas.includes(shaOf(p) ?? ""));
+    if (!pages.length)
+        return no("reading.sha");
+    const on = result.entries.filter((e) => pages.some((p) => p.n === e.page));
+    let entry;
+    if (mark.entry)
+        entry = on.find((e) => e.id === mark.entry);
+    else {
+        const words = plain(text);
+        entry = on.find((e) => plain(e.transcript) === words) ?? (on.length === 1 ? on[0] : undefined);
+        if (!entry && words) {
+            const best = on.map((e) => ({ e, k: likeness(e.transcript, words) })).sort((a, b) => b.k - a.k)[0];
+            if (best && best.k >= 0.6)
+                entry = best.e;
+        }
+    }
+    if (!entry)
+        return no("reading.entry");
+    const page = result.pages.find((p) => p.n === entry.page);
+    const edited = !!plain(text) && plain(text) !== plain(entry.transcript);
+    return { id, ok: true, entry, page, result, ...(edited ? { edited: true } : {}) };
+}
+/** The kind of record a kind of document is. */
+const KIND_OF_DOC = {
+    "register.baptism": "baptism",
+    "register.birth": "birth",
+    "register.marriage": "marriage",
+    "register.death": "death",
+    "register.burial": "burial",
+    "register.other": "church",
+    letter: "letter",
+    deed: "notarial",
+    certificate: "certificate",
+    list: "census",
+    "photo.back": "photo",
+};
+/** The source's kind and information by the kind of document the readers said it is. */
+export function readingKind(result) {
+    const k = result.doc.kind ?? "";
+    const kind = KIND_OF_DOC[k];
+    // a register, a certificate, a deed: written at the time by who was there, for most of what it says
+    const primary = k.startsWith("register.") || k === "certificate" || k === "deed";
+    return { ...(kind ? { kind } : {}), information: primary ? "primary" : "unknown" };
+}
+const kindOf = (k) => (k === "CHR" ? "BAPM" : k.toUpperCase());
+const firstPart = (s) => foldText((s ?? "").split(",")[0].replace(/\[\?\]/gu, ""));
+/** Whether a place of the fact is the place the reader read (as written, or a place of the tree it is). */
+function samePlace(tree, fact, read) {
+    if (!read)
+        return false;
+    const f = firstPart(fact);
+    if (!f)
+        return false;
+    if (firstPart(read.text) === f)
+        return true;
+    const known = read.known ? tree.get(read.known) : undefined;
+    return !!known && known.names.some((n) => firstPart(n.name) === f);
+}
+function sameDate(fact, read) {
+    if (!read)
+        return false;
+    const a = normalizeDate(fact) ?? plain(fact).toUpperCase();
+    const b = normalizeDate(read.gedcom ?? read.text) ?? plain(read.gedcom ?? read.text).toUpperCase();
+    return a === b;
+}
+/**
+ * How sure a fact citing the reading is (the decision of 19 Oct 2026): the person changed the transcript, the
+ * reading does not say it, or its reader was unsure — a lead; read by one reader — possible (a check waits); read
+ * alike by two readers, blind — probable. Proven only after the research's own look at the record, never here.
+ */
+export function readingGrade(tree, check, fact) {
+    const e = check.entry;
+    if (check.edited)
+        return { status: "lead", why: "edited" };
+    const kind = kindOf(fact.kind);
+    const two = e.agree !== undefined;
+    const varied = (fields) => (e.variants ?? []).filter((v) => fields.includes(v.field));
+    // what a person of it is: an occupation, a residence
+    if (kind === "OCCU" || kind === "RESI") {
+        const said = foldText(fact.value ?? fact.place ?? "");
+        const field = kind === "OCCU" ? "occupation" : "residence";
+        const p = e.persons.find((x) => {
+            const v = foldText(x[field] ?? "");
+            return !!v && !!said && (v === said || v.includes(said) || said.includes(v));
+        });
+        if (!p)
+            return { status: "lead", why: "absent" };
+        if (p.uncertain?.includes(field))
+            return { status: "lead", why: "uncertain" };
+        if (!two)
+            return { status: "possible", why: "one" };
+        const words = tokens(p[field] ?? "");
+        const other = (e.variants ?? []).filter((v) => v.field === "entry" || (v.field === "transcript" && [...tokens(v.at)].some((w) => words.has(w))));
+        return other.length ? { status: "lead", why: "differ", variants: other.map(({ at, other: o }) => ({ at, other: o })) } : { status: "probable", why: "two" };
+    }
+    const events = e.events.filter((x) => kindOf(x.type) === kind);
+    const ev = events.find((x) => (!fact.date || sameDate(fact.date, x.date)) && (!fact.place || samePlace(tree, fact.place, x.place)));
+    if (!ev)
+        return { status: "lead", why: "absent" };
+    const asked = [fact.date ? "date" : "", fact.place ? "place" : ""].filter(Boolean);
+    if (asked.some((f) => ev.uncertain?.includes(f)))
+        return { status: "lead", why: "uncertain" };
+    if (!two)
+        return { status: "possible", why: "one" };
+    const other = varied(["entry", ev.type, ...asked.map((f) => `${ev.type}.${f}`)]);
+    return other.length ? { status: "lead", why: "differ", variants: other.map(({ at, other: o }) => ({ at, other: o })) } : { status: "probable", why: "two" };
+}
+const RANK = { lead: 0, possible: 1, probable: 2 };
+/** The best of the grades of a fact's readings (cited twice: the surer one counts). */
+export function bestGrade(grades) {
+    return grades.reduce((a, g) => (!a || RANK[g.status] > RANK[a.status] ? g : a), undefined);
+}
+/** Whether a status is surer than another (proven and the rest above all a reading gives). */
+export function surer(a, than) {
+    const r = (s) => (s && s in RANK ? RANK[s] : s === "proven" ? 3 : s === "disproven" ? -1 : 0);
+    return r(a) > r(than);
+}
+export function readingSource(check, text) {
+    const e = check.entry;
+    const r = check.result;
+    const { kind, information } = readingKind(r);
+    const input = check.page?.file.startsWith("I") ? check.page.file : undefined;
+    return {
+        ...(kind ? { kind } : {}),
+        information,
+        form: "original",
+        // the person's words where they changed them: theirs stand, the reading's beside them (a note)
+        transcript: check.edited && text ? text.trim() : e.transcript,
+        ...(e.translation ? { translation: e.translation } : {}),
+        ...(r.doc.language?.[0] ? { language: r.doc.language[0] } : {}),
+        ...(input ? { input } : {}),
+        reading: check.id,
+        readingEntry: e.id,
+    };
+}
+const CLIPPED = new Set(["image/jpeg", "image/png"]);
+/**
+ * The reading's page the entry is on as the source's image (a picture: registered by its content, the one there
+ * already when it is), the entry's region of it as the source's excerpt, and the input sorted as the source.
+ */
+export function takeReadingImages(tree, source, check, reason) {
+    const out = {};
+    const page = check.page;
+    const entry = check.entry;
+    const rec = tree.get(page.file);
+    let media = rec?.type === "media" ? rec : undefined;
+    const input = rec?.type === "input" ? rec : undefined;
+    if (input) {
+        const sha = input.sha;
+        media = sha ? tree.list("media").find((m) => !m.retracted && m.sha === sha) : undefined;
+        const file = inputPath(tree, input);
+        const mime = input.mime ?? mimeOf(input.name);
+        const shared = new Settings(tree.env, {}).shared()?.value;
+        // a picture of one page (a PDF's pages are no image of their own): registered as the record's image
+        if (!media && sha && shared && file && fs.existsSync(file) && mime.startsWith("image/") && page.page <= 1) {
+            const rel = input.file.startsWith("media:") ? input.file.slice(6) : path.relative(shared, tree.dryRun ? file : storeShared(shared, file, sha)).split(path.sep).join("/");
+            const size = imageSizeOfFile(file);
+            media = create(tree, "media", {
+                sha,
+                file: rel,
+                mime,
+                size: input.size ?? fs.statSync(file).size,
+                ...(size ? { width: size.width, height: size.height } : {}),
+                from: input.name,
+                accessed: new Date().toISOString().slice(0, 10),
+            }, (id) => `+${id} image "${input.name.slice(0, 50)}" of ${source.id} (read ${check.id})`, [source.id, input.id]);
+            out.added = media.id;
+        }
+    }
+    if (media) {
+        out.media = media.id;
+        const shared = new Settings(tree.env, {}).shared()?.value;
+        const file = shared ? path.join(shared, media.file) : undefined;
+        // the entry where it lies in the file: the reading's region is of the page upright
+        const r = entry.region;
+        const clip = r && CLIPPED.has(media.mime) && !source.clips?.length ? { media: media.id, region: shownToFile({ x: r[0], y: r[1], w: r[2], h: r[3] }, file && fs.existsSync(file) ? exifOrientation(file) : undefined) } : undefined;
+        if (clip)
+            out.clip = clip;
+        update(tree, source.id, "source", (x) => ({ ...x, media: [...new Set([...(x.media ?? []), media.id])], ...(clip ? { clips: [clip] } : {}) }), {
+            op: "source.media",
+            summary: `${source.id} image ${media.id}${clip ? " with the part the entry is on" : ""} (${reason})`,
+        });
+    }
+    if (input && input.state !== "processed") {
+        out.input = { id: input.id, before: { state: input.state, ...(input.sorted ? { sorted: input.sorted } : {}) } };
+        update(tree, input.id, "input", (x) => ({ ...x, state: "processed", sorted: { as: "source", source: source.id, reason: `read ${check.id}, confirmed in the Strom app`, at: new Date().toISOString(), by: tree.actor } }), {
+            op: "input.sort",
+            summary: `${input.id} the source ${source.id} (read ${check.id}, ${reason})`,
+        });
+    }
+    return out;
+}

package/dist/core/review.js

@@ -13,6 +13,7 @@ import { birthEvent, displayName, familiesAsPartner, lifespan } from "./people.j
 import { phrase } from "./phrases.js";
 import { foldText } from "./text.js";
 import { weighedSources } from "./conflicts.js";
+import { loadState } from "./document.js";
 import { parseYears } from "./years.js";
 export const REVIEW_KINDS = ["mentions", "entries", "verify", "reread", "conflicts", "marriage", "death"];
 /** At most so many records, entries or facts in one task: a session's worth. */
@@ -122,6 +123,15 @@ export function readersOf(tree) {
     for (const [id, app] of fromApp)
         if (app.read)
             out.set(id, new Set(["user"]));
+    // an entry of a reading of a document the app sent back: its readers read it (their model), not whoever ran the sync
+    const readings = new Set();
+    for (const s of tree.list("source")) {
+        if (!s.reading)
+            continue;
+        readings.add(s.id);
+        if (!out.has(s.id))
+            out.set(s.id, new Set([loadState(tree.root, s.reading)?.model ?? "unknown"]));
+    }
     for (const op of tree.readOps()) {
         if (op.op !== "source.add" && op.op !== "source.edit")
             continue;
@@ -129,7 +139,7 @@ export function readersOf(tree) {
         for (const id of op.targets) {
             if (!id.startsWith("S"))
                 continue;
-            if (fromApp.has(id) && (op.op === "source.add" || !model.has(op.by)))
+            if ((fromApp.has(id) || readings.has(id)) && (op.op === "source.add" || !model.has(op.by)))
                 continue;
             (out.get(id) ?? out.set(id, new Set()).get(id)).add(who);
         }

package/dist/core/stromapp.js

@@ -373,6 +373,27 @@ export function appShowsFactStatus(settings, version) {
             return (a[i] ?? 0) > (b[i] ?? 0);
     return true;
 }
+/**
+ * The first Strom app that opens a reading of a document from its source (spec 013 U6): each source the research made
+ * of a reading confirmed in the app carries 1 _STROM_READING D… (2 _STROM_ENTRY e…). An older app lists the tag as one
+ * it does not know and loses nothing, so an unknown version gets it once the app is out. Not released yet: set with
+ * the app's U6 — never to a beta version; beta/dev copies of the app get it at once.
+ */
+export const APP_SHOWS_READINGS = undefined;
+export function appShowsReadings(settings, version) {
+    if (anotherCopy(settings))
+        return true;
+    if (!APP_SHOWS_READINGS)
+        return false;
+    if (!version)
+        return true;
+    const n = (v) => v.split(".").map((x) => Number.parseInt(x, 10) || 0);
+    const [a, b] = [n(version), n(APP_SHOWS_READINGS)];
+    for (let i = 0; i < 3; i++)
+        if ((a[i] ?? 0) !== (b[i] ?? 0))
+            return (a[i] ?? 0) > (b[i] ?? 0);
+    return true;
+}
 /**
  * The Strom app shows what each variant of an open hypothesis would connect (the app's spec
  * docs/ZADANI_VYZKUM_nejista-spojeni.md, phase 1): 2 _VAR under each 1 _STROM_HYPO with its claim (3 TITL), its links

package/dist/core/sync.js

@@ -42,6 +42,7 @@ import { now, Tree, typeOfId } from "./tree.js";
 import { actsAsArchive } from "./state.js";
 import { appSides } from "./conflicts.js";
 import { APP_DATA_SEX_UNKNOWN, isAppVersion } from "./stromapp.js";
+import { bestGrade, checkReading, readingGrade, readingResult, readingSource, surer, takeReadingImages } from "./readsync.js";
 import { cleanTitle, familiesAsPartner, formatName, foundTitles, gedcomTitledName, parseName, primaryName, sameName as sameWords, titledName } from "./people.js";
 /** The words of a _STAT (the Strom app's own, also Legacy's and FTM's) as a union, or nothing it names. */
 function unionOfStat(value) {
@@ -454,6 +455,19 @@ export function stampAppVersion(text, version) {
     lines.splice(sour + 1, 0, `2 VERS ${version}`);
     return lines.join(eol);
 }
+/**
+ * The reading a source of the app is an entry of: 1 _STROM_READING D… (2 _STROM_ENTRY e…), and the originals its
+ * excerpts are cut from (2 _STROM_SHA under its OBJE, or 1 _STROM_SHA of its own).
+ */
+function readingMarkOf(r) {
+    const n = r.children.find((c) => c.tag === "_STROM_READING");
+    const id = n?.value.trim();
+    if (!n || !id)
+        return {};
+    const entry = val(n, "_STROM_ENTRY")?.trim();
+    const shas = [...children(r, "_STROM_SHA"), ...children(r, "OBJE").flatMap((o) => children(o, "_STROM_SHA"))].map((x) => x.value.trim().toLowerCase()).filter(Boolean);
+    return { reading: { id, ...(entry ? { entry } : {}), shas: [...new Set(shas)] } };
+}
 /** A GEDCOM file (or one of ours, in memory) as a snapshot; an unreadable one throws. */
 export function readGedcom(text) {
     const { records, problems } = parseGedcomText(text);
@@ -485,6 +499,7 @@ export function readGedcom(text) {
             ...(url ? { url } : {}),
             ...(note ? { note } : {}),
             ...(/^y(es)?$/i.test(val(r, "_STROM_VERIFIED")?.trim() ?? "") ? { verified: true } : {}),
+            ...readingMarkOf(r),
         });
     }
     const cite = (n) => {
@@ -710,6 +725,15 @@ export function readStromJson(data) {
             ...(str(a.note) ? { note: str(a.note) } : {}),
             ...(q !== undefined ? { quay: q } : {}),
             ...(a.transcriptVerified === true ? { verified: true } : {}),
+            ...(str(a.reading)
+                ? {
+                    reading: {
+                        id: str(a.reading),
+                        ...(str(a.readingEntry) ? { entry: str(a.readingEntry) } : {}),
+                        shas: [...new Set([a.readingSha, ...(Array.isArray(a.excerpts) ? a.excerpts.map((x) => x?.originalSha) : [])].map((x) => str(x)?.toLowerCase()).filter((x) => !!x))],
+                    },
+                }
+                : {}),
         });
     }
     const citesOf = (ids) => {
@@ -1857,8 +1881,9 @@ export function planSync(tree, incoming, edits, opts = {}) {
     const carried = new Set([...incoming.persons.values()].flatMap((p) => p.facts.map((f) => kindOf(f.kind))));
     const carriedFam = new Set(incoming.families.flatMap((f) => f.facts.map((x) => kindOf(x.kind))));
     // the sources first: what the file's citations are the research has, or what comes with them
-    const sources = planSources(tree, incoming, ours, base, push);
-    const reads = readsFor(tree, incoming, sources, changes);
+    const readings = new Map();
+    const sources = planSources(tree, incoming, ours, base, push, readings);
+    const reads = readsFor(tree, incoming, sources, changes, readings);
     const idOf = (key) => (key.startsWith("x:") ? key : (resolve(tree, key)?.id ?? key));
     // who the records name at a fact: the same person by their key or a name of theirs; the role "other" is any role
     // (the Strom app has no name for an informant or a midwife)
@@ -2501,7 +2526,7 @@ export function planSync(tree, incoming, edits, opts = {}) {
         if (left.length)
             c.uncited = [...new Set(left)];
     }
-    return { changes, sources, base: !!base, ...(incoming.head ? { head: incoming.head } : {}), partial, identity };
+    return { changes, sources, readings, base: !!base, ...(incoming.head ? { head: incoming.head } : {}), partial, identity };
 }
 /**
  * The send a copy of the app says it is a copy of (_STROM_SINCE R…, the app's beta.34): that send as it came, kept, its
@@ -2767,7 +2792,7 @@ export function readByResearch(tree) {
  * before), or new. Of the research's, what the user changed in the app since it was given — the app's own source
  * corrected, a record the research read a second reading beside it — and "transcript verified" ticked.
  */
-function planSources(tree, incoming, ours, base, push) {
+function planSources(tree, incoming, ours, base, push, readings) {
     const map = new Map();
     let readSet;
     if (!incoming.sources?.size)
@@ -2780,11 +2805,19 @@ function planSources(tree, incoming, ours, base, push) {
             mine = tree.get(mine.mergedInto);
         if (mine && (mine.type !== "source" || mine.retracted))
             mine = undefined;
-        // one the research has: the same entry (a send the app has not had back yet)
+        // an entry of a reading of a document the person confirmed in the app: the research's reading, when it is one
+        // (it exists and is read, the original is its page, the words its entry's) — else the app's own source as any
+        const check = !mine && inc.reading ? checkReading(tree, inc.reading, inc.text) : undefined;
+        // one the research has: the source it made of that entry before (a send the app has not had back yet), the same entry
+        if (check?.ok)
+            mine ??= live.find((s) => s.reading === check.id && s.readingEntry === check.entry.id);
         mine ??= live.find((s) => sameEntry(tree, s, pageOf(s), inc));
         if (!mine) {
+            if (check?.ok)
+                readings.set(key, check);
+            const reading = check ? { reading: { id: check.id, ok: check.ok, ...(check.entry ? { entry: check.entry.id } : {}), ...(check.code ? { code: check.code } : {}), ...(check.edited ? { edited: true } : {}) } } : {};
             if (inc.title || inc.text)
-                push({ kind: "source.new", action: "add", source: key, text: inc.title || inc.text.slice(0, 60) });
+                push({ kind: "source.new", action: "add", source: key, text: inc.title || inc.text.slice(0, 60), ...reading });
             continue;
         }
         map.set(key, mine.id);
@@ -2813,11 +2846,14 @@ function planSources(tree, incoming, ours, base, push) {
  * not authored) whose transcript counts — the app's own source when the send says evidence, or verified (now or
  * before); the research's own one cited by the user when the send says evidence.
  */
-function readsFor(tree, incoming, sources, changes) {
+function readsFor(tree, incoming, sources, changes, readings) {
     const evidence = incoming.transcripts === "evidence";
     return (key) => {
         const inc = incoming.sources?.get(key);
         const id = sources.get(key);
+        // a reading of the research: its readers read it, not the user (the facts' status is by what they read)
+        if (!id && readings.has(key))
+            return false;
         if (!id) {
             // new: the app's quality 0 is someone's word, no record
             return !!inc && inc.quay !== 0 && (evidence || !!inc.verified);
@@ -3134,6 +3170,8 @@ export function applySync(tree, plan, incoming, source, only) {
     // the app's sources first: the facts cite them
     const made = new Map(); // a new source's key → its ID
     const srcId = (key) => plan.sources.get(key) ?? made.get(key);
+    // the sources that are an entry of a reading of the research: its ID → the reading as checked
+    const checks = new Map();
     for (const c of plan.changes.filter((x) => x.kind === "source.new" && taken(x))) {
         const inc = incoming.sources?.get(c.source);
         if (!inc)
@@ -3141,6 +3179,33 @@ export function applySync(tree, plan, incoming, source, only) {
         const repository = inc.repo ? repositoryFor(tree, inc.repo, applied) : undefined;
         const [form, information] = QUAY_EVIDENCE[inc.quay ?? -1] ?? ["original", "unknown"];
         const title = inc.title || inc.text.slice(0, 60);
+        const check = plan.readings?.get(c.source);
+        if (check) {
+            // the research's reading of the record: its transcript, translation, language, input and images; the person's
+            // words where they changed them (the reading's kept beside them, theirs not yet a reading that counts)
+            const read = readingSource(check, inc.text);
+            const notes = [inc.note, check.edited ? phrase(tree.lang, "read.note.source.edited", { read: check.id, text: check.entry.transcript }) : undefined].filter(Boolean).join("\n\n");
+            const made1 = create(tree, "source", {
+                ...read,
+                kind: read.kind ?? sourceKind(incoming, c.source),
+                title,
+                ...(repository ? { repository } : {}),
+                ...(inc.page ? { locator: inc.page } : {}),
+                ...(inc.date ? { date: inc.date } : {}),
+                ...(inc.url ? { url: inc.url } : {}),
+                ...(check.edited ? { app: { read: false } } : {}),
+                ...(notes ? { note: notes } : {}),
+            }, (id) => `+${id} source "${truncateText(title, 50)}" (read ${check.id} ${check.entry.id}, confirmed in the Strom app, ${source.id})`, read.input ? [read.input] : []);
+            made.set(c.source, made1.id);
+            applied.push({ do: "source.add", id: made1.id, before: c.source });
+            const took = takeReadingImages(tree, made1, check, `the Strom app, ${source.id}`);
+            if (took.added)
+                applied.push({ do: "media.add", id: took.added });
+            if (took.input)
+                applied.push({ do: "input.sort", id: took.input.id, before: JSON.stringify(took.input.before) });
+            checks.set(made1.id, check);
+            continue;
+        }
         const made1 = create(tree, "source", {
             kind: sourceKind(incoming, c.source),
             title,
@@ -3161,7 +3226,64 @@ export function applySync(tree, plan, incoming, source, only) {
     /** Whether a citation of this source stands on a reading of a record: the user's, when it counts. */
     const reading = (id) => {
         const s = tree.get(id);
-        return !!s && !isWeak(s) && (s.app ? s.app.read : evidence);
+        // a reading of the research's readers: its facts by what they read (graded), unless the person's words changed
+        // there count now (verified)
+        return !!s && !isWeak(s) && (s.app ? s.app.read : !s.reading && evidence);
+    };
+    /** A source that is an entry of a reading of the research (made now, or by a sync before): the reading as checked. */
+    const checkOf = (id) => {
+        if (checks.has(id))
+            return checks.get(id);
+        const s = tree.get(id);
+        const result = s?.reading && !s.retracted ? readingResult(tree, s.reading) : undefined;
+        const entry = result?.entries.find((e) => e.id === s.readingEntry);
+        const k = result && entry ? { id: s.reading, ok: true, entry, page: result.pages.find((p) => p.n === entry.page), result, ...(s.app ? { edited: true } : {}) } : undefined;
+        if (k)
+            checks.set(id, k);
+        return k;
+    };
+    /** How sure a fact is by the readings it cites (decision of 19 Oct 2026; none cited: undefined), and which they are. */
+    const graded = (cits, f) => {
+        if (!f)
+            return undefined;
+        const each = cits.flatMap((c) => {
+            const k = checkOf(c.source);
+            return k && !tree.get(c.source)?.app?.read ? [{ g: readingGrade(tree, k, f), read: k.id, source: c.source }] : [];
+        });
+        const grade = bestGrade(each.map((x) => x.g));
+        return grade ? { grade, reads: [...new Set(each.map((x) => x.read))], sources: [...new Set(each.map((x) => x.source))] } : undefined;
+    };
+    /** Why a fact of a reading is not probable, beside it (both readings where they differ). */
+    const gradeNote = (gr) => {
+        const read = gr.reads.join(", ");
+        switch (gr.grade.why) {
+            case "two":
+                return undefined;
+            case "differ":
+                return phrase(tree.lang, "read.note.differ", { read, list: (gr.grade.variants ?? []).map((v) => `"${v.at}" / "${v.other}"`).join("; ") });
+            default:
+                return phrase(tree.lang, `read.note.${gr.grade.why}`, { read });
+        }
+    };
+    // the people whose facts stand on a reading not yet sure (one reader, readers apart, the words changed): one task each
+    const readVerify = new Map();
+    const toCheck = (owner, gr) => {
+        if (!gr || gr.grade.status === "probable")
+            return;
+        const people = owner.startsWith("F") ? (tree.get(owner)?.partners ?? []) : [owner];
+        for (const p of people)
+            for (const s1 of gr.sources)
+                (readVerify.get(p) ?? readVerify.set(p, new Set()).get(p)).add(s1);
+    };
+    /** A fact of the research a reading now makes surer (never less sure): its status raised. */
+    const lift = (owner, e, gr) => {
+        if (!gr || !surer(gr.grade.status, e.status))
+            return;
+        update(tree, owner, owner.startsWith("F") ? "family" : "person", (o) => ({ ...o, events: o.events.map((x) => (x.id === e.id ? { ...x, status: gr.grade.status } : x)) }), {
+            op: "event.status",
+            summary: `${e.id} ${gr.grade.status}: read ${gr.reads.join(", ")} (${reason})`,
+        });
+        applied.push({ do: "event.status", id: e.id, before: e.status });
     };
     /** The citations of a fact from the file: its sources (where in them), else the sync. */
     const citesOf = (f) => {
@@ -3181,7 +3303,7 @@ export function applySync(tree, plan, incoming, source, only) {
         const unread = cits.filter((c) => {
             const s = tree.get(c.source);
             // a reading of the user's that counts is the first reading: read again only by the usual rules
-            return !!s?.app && !s.app.read && !isWeak(s) && !researchRead(tree, s, (read ??= readByResearch(tree)));
+            return !!s?.app && !s.app.read && !s.reading && !isWeak(s) && !researchRead(tree, s, (read ??= readByResearch(tree)));
         });
         if (!unread.length)
             return;
@@ -3233,9 +3355,12 @@ export function applySync(tree, plan, incoming, source, only) {
                     const theirs = citesOf(c.fact);
                     if (c.kind === "fact.new" || !mine || (c.action === "add" && !mine)) {
                         const citations = theirs.length ? theirs : [cite(c.fact.kind)];
-                        const { event } = addEvent(tree, owner, { ...fields(c.fact), status: citations.some((x) => reading(x.source)) ? "probable" : "lead", citations });
+                        const gr = graded(citations, c.fact);
+                        const note = gr ? gradeNote(gr) : undefined;
+                        const { event } = addEvent(tree, owner, { ...fields(c.fact), status: gr ? gr.grade.status : citations.some((x) => reading(x.source)) ? "probable" : "lead", ...(note ? { note } : {}), citations });
                         applied.push({ do: "event.add", id: event.id });
                         toVerify(owner, citations);
+                        toCheck(owner, gr);
                     }
                     else if (c.action === "refine") {
                         // the record's fact stays as it is proven; what the user added to it cites their tree (or the sources they gave)
@@ -3274,6 +3399,9 @@ export function applySync(tree, plan, incoming, source, only) {
                         if (stale.length)
                             applied.push({ do: "event.uncite", id: mine.id, before: JSON.stringify(stale) });
                         toVerify(owner, theirs);
+                        const gr = graded(theirs, c.fact);
+                        lift(owner, eventById(tree, mine.id) ?? mine, gr);
+                        toCheck(owner, gr);
                         applied.push({ do: "event.edit", id: mine.id, before: { kind: mine.kind, ...(mine.date ? { date: mine.date } : {}), ...(mine.place ? { place: mine.place } : {}), ...(mine.value ? { value: mine.value } : {}) } });
                     }
                     else if (c.action === "user") {
@@ -3283,9 +3411,12 @@ export function applySync(tree, plan, incoming, source, only) {
                             break;
                         // the user's word: no record makes it probable — unless it is their reading of one, which counts
                         const citations = theirs.length ? theirs : [cite(c.fact.kind)];
-                        const { event } = addEvent(tree, owner, { ...fields(c.fact), status: citations.some((x) => reading(x.source)) ? "probable" : "possible", citations });
+                        const gr = graded(citations, c.fact);
+                        const note = gr ? gradeNote(gr) : undefined;
+                        const { event } = addEvent(tree, owner, { ...fields(c.fact), status: gr ? gr.grade.status : citations.some((x) => reading(x.source)) ? "probable" : "possible", ...(note ? { note } : {}), citations });
                         applied.push({ do: "event.add", id: event.id });
                         toVerify(owner, citations);
+                        toCheck(owner, gr);
                     }
                     else {
                         const title = editTitle(c.name ?? owner, eventName(c.fact.kind, tree.lang, c.fact.label), factWords(tree, incoming, mine), factWords(tree, incoming, c.fact));
@@ -3331,12 +3462,16 @@ export function applySync(tree, plan, incoming, source, only) {
                     if (!add.length)
                         break;
                     const up = (mine.status === "lead" || mine.status === "possible") && add.some((x) => reading(x.source));
-                    update(tree, owner, owner.startsWith("F") ? "family" : "person", (o) => ({ ...o, events: o.events.map((e) => (e.id === mine.id ? { ...e, citations: [...e.citations, ...add], ...(up ? { status: "probable" } : {}) } : e)) }), {
+                    // a reading the person gave it: the research's fact as the readers read it (surer only, never less)
+                    const gr = graded(add, mine);
+                    const to = gr && surer(gr.grade.status, up ? "probable" : mine.status) ? gr.grade.status : up ? "probable" : undefined;
+                    update(tree, owner, owner.startsWith("F") ? "family" : "person", (o) => ({ ...o, events: o.events.map((e) => (e.id === mine.id ? { ...e, citations: [...e.citations, ...add], ...(to ? { status: to } : {}) } : e)) }), {
                         op: "event.cite",
-                        summary: `${mine.id} cites ${add.map((x) => x.source).join(", ")}${up ? " — probable on the user's reading" : ""} (${reason})`,
+                        summary: `${mine.id} cites ${add.map((x) => x.source).join(", ")}${to && !up ? ` — ${to}: read ${gr.reads.join(", ")}` : up ? " — probable on the user's reading" : ""} (${reason})`,
                     });
                     applied.push({ do: "event.cite", id: mine.id, before: JSON.stringify({ status: mine.status, sources: add.map((x) => x.source) }) });
                     toVerify(owner, add);
+                    toCheck(owner, gr);
                     break;
                 }
                 case "fact.part": {
@@ -3801,8 +3936,32 @@ export function applySync(tree, plan, incoming, source, only) {
         }, (id) => `+${id} task "read for itself what the user wrote of ${person}"`);
         applied.push({ do: "task.add", id: t.id });
     }
+    // one task per person to check what one reader read, or readers read apart, or the person changed (the readings
+    // are the research's own: a second, blind reading and its own look prove them or show a mistake)
+    const openRead = tree.list("task").filter((t) => t.origin === READ_VERIFY_ORIGIN && ["open", "doing", "parked", "waiting"].includes(t.state));
+    for (const [person, srcs] of actsAsArchive(tree) ? [] : readVerify) {
+        const p = tree.get(person);
+        if (!p || p.retracted || openRead.some((t) => t.subject.includes(person) && [...srcs].every((x) => t.subject.includes(x))))
+            continue;
+        const reads = [...new Set([...srcs].map((x) => tree.get(x)?.reading).filter((x) => !!x))];
+        const images = [...new Set([...srcs].flatMap((x) => tree.get(x)?.clips?.map((k) => k.media) ?? []))];
+        const t = create(tree, "task", {
+            level: "verify",
+            priority: 3,
+            what: truncateText(phrase(tree.lang, "read.verify.what", { name: person, list: [...srcs].join(", ") }), 200),
+            where: [...srcs, ...images],
+            why: phrase(tree.lang, "read.verify.why", { read: reads.join(", "), source: source.id }),
+            doneWhen: phrase(tree.lang, "read.verify.done", { read: reads[0] ?? "D…", source: [...srcs][0] }),
+            subject: [person, ...srcs],
+            state: "open",
+            origin: READ_VERIFY_ORIGIN,
+        }, (id) => `+${id} task "check the reading ${reads.join(", ")} of ${person}"`);
+        applied.push({ do: "task.add", id: t.id });
+    }
     return { applied, changes: changes - skipped.length, skipped };
 }
+/** Where a task to check a reading of a document confirmed in the app comes from (one per person and its sources). */
+export const READ_VERIFY_ORIGIN = "read:verify";
 /** Where a task to read the user's transcripts again comes from (one per person at a time). */
 export const VERIFY_ORIGIN = "sync:verify";
 /** The Strom app's quality of a citation (GEDCOM QUAY) → what kind of record it is and its information. */
@@ -4218,6 +4377,15 @@ export function undoSync(tree, input) {
             case "source.add":
                 update(tree, a.id, "source", (x) => ({ ...x, retracted: { at: now(), reason } }), { op: "source.retract", summary: `${a.id} retracted: ${reason}` });
                 break;
+            case "media.add":
+                update(tree, a.id, "media", (x) => ({ ...x, retracted: { at: now(), reason } }), { op: "media.retract", summary: `${a.id} retracted: ${reason}`, reason });
+                break;
+            case "input.sort": {
+                // the material as it stood before the reading's source was made of it
+                const b = JSON.parse(String(a.before ?? "{}"));
+                update(tree, a.id, "input", ({ sorted: _s, ...x }) => ({ ...x, state: b.state ?? "new", ...(b.sorted ? { sorted: b.sorted } : {}) }), { op: "input.sort", summary: `${a.id} ${b.state ?? "new"} again: ${reason}`, reason });
+                break;
+            }
             case "repo.add":
                 update(tree, a.id, "repository", (x) => ({ ...x, retracted: { at: now(), reason } }), { op: "repo.retract", summary: `${a.id} retracted: ${reason}`, reason });
                 break;

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

package/dist/gedcom/export.js

@@ -411,6 +411,12 @@ export function exportGedcom(tree, opts = {}) {
         }
         if (opts.sourceReads && s.app?.verified)
             w.line(1, "_STROM_VERIFIED", "Y");
+        // the reading of a document the source is an entry of: the app opens its result there (its pages, translation)
+        if (opts.readings && s.reading) {
+            w.line(1, "_STROM_READING", s.reading);
+            if (s.readingEntry)
+                w.line(2, "_STROM_ENTRY", s.readingEntry);
+        }
         for (const cut of opts.excerpts?.(s) ?? []) {
             const e = opts.turnsExcerpts ? cut : turned(cut);
             w.line(1, "OBJE");

package/package.json

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