strom-research 1.14.0 → 1.15.0-beta.1

package/assets/lang/cs.json

@@ -184,7 +184,7 @@
   "ui.tune.q.window": "Odpovědět na otázku ke čtení snímků – „{text}“: {label}?",
   "ui.tune.q.kept": "✓ Odpověď uložena: {label}.",
   "ui.tune.q.kept.tasks": "✓ Přidané úkoly: {tasks} – ve frontě s prioritou práce, ze které vzešly.",
-  "ui.tune.q.kept.notasks": "Teď není koho hledat: žádný úkol nepřibyl (každá osoba už jeden má, nebo není na kraji stromu ani v rozpracovaném směru).",
+  "ui.tune.q.kept.notasks": "Teď není koho hledat: žádný úkol nepřibyl (každá osoba už jeden má, nebo není na kraji stromu ani v rozpracované linii).",
   "ui.tune.q.kept.calibrate": "Kalibraci spouští člověk: strom media calibrate (cena se řekne předem).",
   "ui.tune.q.kept.reset": "Vrátí se příkazem: {command}",
   "ui.tune.q.kept.vision": "✓ Skeny se odteď čtou modelem {model} (model.vision).",
@@ -197,7 +197,7 @@
   "ui.tune.q.c.never": "Nikdy",
   "ui.tune.q.weak": "Kniha {book} ({title}): záporů na slabých skenech {n}, teď je tu ostřejší kopie. Hledat znovu?",
   "ui.tune.q.weak.why": "{n} z {of} záporů vzniklo na pohledech zvětšených nad detail skenů; ostřejší kopie ({copies}) mají až {gain}× víc detailu.",
-  "ui.tune.q.c.edge": "Ano, u osob na kraji stromu nebo v rozpracovaném směru (úkolů asi {tasks})",
+  "ui.tune.q.c.edge": "Ano, u osob na kraji stromu nebo v rozpracované linii (úkolů asi {tasks})",
   "ui.tune.q.c.brief": "Jen uvést v zadání agenta",
   "ui.tune.q.c.no": "Ne",
   "ui.tune.q.sharper": "Kniha {book} ({title}) se čte hůř než ostatní a její archiv dává ostřejší výřezy. Stáhnout ostřejší výřezy nejistých snímků?",
@@ -923,11 +923,11 @@
   "ui.stats.cost.readers": ", z toho čtenáři skenů {cost}",
   "ui.stats.stories": "Vyprávění: {n}",
   "ui.status.data": "Osoby: {persons} · rodiny: {families}",
-  "ui.status.directions": " · směry výzkumu: {n}",
+  "ui.status.directions": " · linie výzkumu: {n}",
   "ui.status.check.ok": "Kontrola: v pořádku",
   "ui.status.check.errors": "Kontrola: chyb {n} → strom check",
   "ui.status.check.warnings": " · upozornění {n}",
-  "ui.status.dirs": "Směry výzkumu:",
+  "ui.status.dirs": "Linie výzkumu:",
   "ui.status.recent": "Naposledy:",
   "ui.help.cmd.menu": "Průvodní menu: vše, co člověk se stromem dělá, podle čísel",
   "ui.help.cmd.status": "Rodokmen v kostce: data, kontrola, co čeká, co se naposledy změnilo, místo na disku",
@@ -945,10 +945,10 @@
   "ui.help.cmd.chat": "Rozhovor s agentem o výzkumu",
   "ui.help.cmd.run": "Nechat agenta pracovat samotného na dalších úkolech",
   "ui.help.cmd.session.finish": "Požádat pracujícího agenta, ať zapíše, co našel, a skončí",
-  "ui.help.cmd.research.new": "Nový směr: předkové nebo potomci někoho, nebo jedna otázka",
-  "ui.help.cmd.research.pause": "Pozastavit směr: jeho úkoly počkají",
-  "ui.help.cmd.research.resume": "Znovu se pustit do pozastaveného směru",
-  "ui.help.cmd.research.done": "Ukončit směr (nic se nesmaže)",
+  "ui.help.cmd.research.new": "Nová linie: předkové nebo potomci někoho, nebo jedna otázka",
+  "ui.help.cmd.research.pause": "Pozastavit linii: její úkoly počkají",
+  "ui.help.cmd.research.resume": "Znovu se pustit do pozastavené linie",
+  "ui.help.cmd.research.done": "Ukončit linii (nic se nesmaže)",
   "ui.help.cmd.review": "Revize osoby: prověřit a doplnit, co o ní víme",
   "ui.help.cmd.intake": "Přidat podklady od rodiny: dokumenty, fotky, rodokmen, co je známo",
   "ui.help.cmd.sync": "Načíst úpravy z aplikace Strom nebo z jiného rodokmenu (nejdřív ukáže, zapíše s --apply)",
@@ -1213,7 +1213,7 @@
   "ui.menu.app.tip.archive": "Tip: výzkum jde prohlédnout jako rodokmen v aplikaci Strom – volba {key}.",
   "ui.dry.done": "Nanečisto (--dry-run): nic se nezapsalo – řádky výše říkají, co by se stalo.",
   "ui.trees.persons": "osob: {n}",
-  "ui.trees.researches": "směrů výzkumu: {n}",
+  "ui.trees.researches": "linií výzkumu: {n}",
   "ui.trees.none": "zatím žádný rodokmen → strom init \"<název>\"",
   "ui.trees.use": "teď se pracuje na „{name}“ ({root})",
   "ui.error.live.not-started": "most se nespustil",
@@ -1342,11 +1342,11 @@
   "ui.consent.hook.on": "Nechat hook „{name}“, aby se dozvídal všechno, co se uloží do výzkumů? Je to program na tomto počítači a udělá s tím, k čemu byl napsán.",
   "ui.consent.hook.off": "Přestat hooku „{name}“ hlásit, co se ukládá?",
   "ui.run.others": "⚠ V tomto rodokmenu už pracuje jiný běh (od {since}): tento si vezme jiné úkoly – náklady se sčítají.",
-  "ui.menu.more": "Rozšířit výzkum: podklady, nový směr, revize osoby, jiný rodokmen",
-  "ui.menu.more.app": "Rozšířit výzkum: podklady, nový směr, revize osoby, úpravy z aplikace Strom",
+  "ui.menu.more": "Rozšířit výzkum: podklady, nová linie, revize osoby, jiný rodokmen",
+  "ui.menu.more.app": "Rozšířit výzkum: podklady, nová linie, revize osoby, úpravy z aplikace Strom",
   "ui.more.title": "Rozšířit výzkum",
   "ui.more.intake": "Přidat podklady: dokumenty, fotky, rodokmen z jiného programu, co je známo",
-  "ui.more.research": "Nový směr výzkumu: předkové nebo potomci někoho dalšího, nebo jedna otázka",
+  "ui.more.research": "Nová linie výzkumu: předkové nebo potomci někoho dalšího, nebo jedna otázka",
   "ui.more.sync": "Načíst úpravy z aplikace Strom nebo z jiného rodokmenu (.ged, .json)",
   "ui.more.undo": "Vrátit poslední poslání z aplikace Strom ({when})",
   "ui.more.undo.what": "Vrátit, co výzkum převzal z aplikace Strom {when}:",
@@ -1373,20 +1373,20 @@
   "ui.link.what.chat.person": "rozhovor s agentem ({agent}) o osobě {person}.",
   "ui.link.chat.say": "Podívejme se na osobu {person}: řekni mi krátce, co o ní výzkum ví, a zeptej se mě, co chci zjistit.",
   "ui.link.what.review.person": "prověřit znovu osobu {person}.",
-  "ui.link.what.direction.pause": "pozastavit směr „{name}“: jeho úkoly ({n}) počkají mimo frontu a nic nového se pro něj nenavrhne. Nic se nemaže.",
-  "ui.link.what.direction.done": "ukončit směr „{name}“: jeho úkoly ({n}) odejdou z fronty. Nic se nemaže, jde ho znovu spustit.",
-  "ui.link.what.direction.resume": "znovu spustit směr „{name}“: jeho úkoly ({n}) se vrátí do fronty a výzkum navrhne, co chybí.",
-  "ui.link.direction.none": "Směr {id} v tomto výzkumu není. Nic se nestalo.",
-  "ui.link.direction.cannot": "Směr „{name}“ už je {state}. Nic se nestalo.",
-  "ui.link.direction.why": "Proč? (pár slov, zůstane u směru; Enter: bez důvodu)",
-  "ui.link.what.chat.research": "rozhovor s agentem ({agent}) o směru „{name}“, jen jeho úkoly.",
-  "ui.link.chat.research.say": "Pojďme pracovat na směru „{name}“ ({id}), na jeho úkolech.",
+  "ui.link.what.direction.pause": "pozastavit linii „{name}“: její úkoly ({n}) počkají mimo frontu a nic nového se pro ni nenavrhne. Nic se nemaže.",
+  "ui.link.what.direction.done": "ukončit linii „{name}“: její úkoly ({n}) odejdou z fronty. Nic se nemaže, jde ji znovu spustit.",
+  "ui.link.what.direction.resume": "znovu spustit linii „{name}“: její úkoly ({n}) se vrátí do fronty a výzkum navrhne, co chybí.",
+  "ui.link.direction.none": "Linie {id} v tomto výzkumu není. Nic se nestalo.",
+  "ui.link.direction.cannot": "Linie „{name}“ už je {state}. Nic se nestalo.",
+  "ui.link.direction.why": "Proč? (pár slov, zůstane u linie; Enter: bez důvodu)",
+  "ui.link.what.chat.research": "rozhovor s agentem ({agent}) o linii „{name}“, jen její úkoly.",
+  "ui.link.chat.research.say": "Pojďme pracovat na linii „{name}“ ({id}), na jejích úkolech.",
   "ui.link.what.finish": "požádat agenta {agent}, aby dokončil sezení {session} ({task}): zapíše, co našel, a sezení zavře; při samostatné práci další nezačne.",
   "ui.link.finish.none": "Sezení {session} už neběží (mezitím skončilo). Nic se nestalo.",
   "ui.link.what.review.family": "prověřit znovu osobu {person} i s partnery a dětmi.",
   "ui.link.what.review.line": "prověřit znovu osobu {person} i s předky.",
-  "ui.link.what.research.ancestors": "hledat předky osoby {person} (nový směr výzkumu).",
-  "ui.link.what.research.descendants": "hledat potomky osoby {person} (nový směr výzkumu).",
+  "ui.link.what.research.ancestors": "hledat předky osoby {person} (nová linie výzkumu).",
+  "ui.link.what.research.descendants": "hledat potomky osoby {person} (nová linie výzkumu).",
   "ui.link.noperson": "Osoba {person} v tomto výzkumu není (nebo z něj byla vyřazena). Nic se nestalo.",
   "ui.link.notask": "Tento úkol už nečeká (odpověď už má, nebo ho převzal agent). Nic se nestalo.",
   "ui.link.task.none": "Úkol {task} v tomto výzkumu není. Nic se nestalo.",
@@ -1675,11 +1675,11 @@
   "log.event.status": "Změněná jistota údaje: {who} – {fact}",
   "log.event.restore": "Údaj znovu platí: {who} – {fact}",
   "log.input.sync.undo": "Vrácený rodokmen: {name}",
-  "log.research.add": "Nový směr výzkumu: {name}",
-  "log.research.edit": "Upravený směr výzkumu: {name}",
-  "log.research.pause": "Směr pozastaven: {name}",
-  "log.research.resume": "Směr znovu běží: {name}",
-  "log.research.done": "Směr ukončen: {name}",
+  "log.research.add": "Nová linie výzkumu: {name}",
+  "log.research.edit": "Upravená linie výzkumu: {name}",
+  "log.research.pause": "Linie pozastavena: {name}",
+  "log.research.resume": "Linie znovu běží: {name}",
+  "log.research.done": "Linie ukončena: {name}",
   "log.mode.archive": "Výzkum je teď archiv",
   "log.mode.research": "Výzkum je znovu zapnutý",
   "log.reading.loose": "Pročteno snímků: {n}",
@@ -1717,21 +1717,21 @@
   "ui.task.answer.window": "Zapsat k úkolu {task} odpověď: „{answer}“?",
   "ui.intake.empty": "Není v tom nic, co by se dalo přidat.",
   "ui.intake.ours": "{path} je složka samotného stromu (výzkumu), ne rodinné podklady.",
-  "ui.research.exists": "Takový výzkum už je: „{name}“ – agent v něm pokračuje.",
-  "ui.more.directions": "Směry výzkumu: pozastavit, ukončit nebo znovu spustit",
-  "ui.dirs.pick": "Který směr?",
+  "ui.research.exists": "Taková linie výzkumu už je: „{name}“ – agent v ní pokračuje.",
+  "ui.more.directions": "Linie výzkumu: pozastavit, ukončit nebo znovu spustit",
+  "ui.dirs.pick": "Která linie?",
   "ui.dirs.item": "{name} – {state} · úkoly: {n}",
   "ui.dirs.active": "běží",
-  "ui.dirs.paused": "pozastavený",
-  "ui.dirs.done": "ukončený",
+  "ui.dirs.paused": "pozastavená",
+  "ui.dirs.done": "ukončená",
   "ui.dirs.what": "„{name}“:",
-  "ui.dirs.do.pause": "Pozastavit – jeho úkoly počkají, agent vezme jiné",
-  "ui.dirs.do.done": "Ukončit – jeho úkoly odejdou z fronty (nic se nemaže)",
-  "ui.dirs.do.resume": "Znovu spustit – jeho úkoly se vrátí do fronty",
-  "ui.dirs.paused.now": "⏸ „{name}“ je pozastavený: jeho úkoly ({n}) počkají, dokud se tady znovu nespustí.",
-  "ui.dirs.done.now": "■ „{name}“ je ukončený: jeho úkoly ({n}) jsou mimo frontu – nic se nesmazalo, tady ho jde znovu spustit.",
-  "ui.dirs.active.now": "▶ „{name}“ zase běží: jeho úkoly ({n}) jsou zpátky ve frontě.",
-  "ui.research.resume": "Takový výzkum už je, {state}: „{name}“. Spustit ho znovu?",
+  "ui.dirs.do.pause": "Pozastavit – její úkoly počkají, agent vezme jiné",
+  "ui.dirs.do.done": "Ukončit – její úkoly odejdou z fronty (nic se nemaže)",
+  "ui.dirs.do.resume": "Znovu spustit – její úkoly se vrátí do fronty",
+  "ui.dirs.paused.now": "⏸ „{name}“ je pozastavená: její úkoly ({n}) počkají, dokud se tady znovu nespustí.",
+  "ui.dirs.done.now": "■ „{name}“ je ukončená: její úkoly ({n}) jsou mimo frontu – nic se nesmazalo, tady ji jde znovu spustit.",
+  "ui.dirs.active.now": "▶ „{name}“ zase běží: její úkoly ({n}) jsou zpátky ve frontě.",
+  "ui.research.resume": "Taková linie výzkumu už je, {state}: „{name}“. Spustit ji znovu?",
   "ui.alone.gate.bad": "Čekám počet bodů od 0 do 100 (třeba 10).",
   "ui.alone.addons": "Bez osobních doplňků agenta (skilly, pluginy, MCP servery): {state}",
   "ui.alone.addons.about": "Agent při samostatné práci načte jen nástroje výzkumu. Spojení s aplikací Strom a prohlížeč fungují dál. Chat s agentem doplňky načítá vždy.",

package/dist/brief/sheet.js

@@ -28,11 +28,12 @@ const RARE = {
     "search add": ["by"],
     "task add": ["research", "anyway"],
     "media view": ["scale", "max", "grey", "png", "image"],
-    read: ["context", "batch", "parallel", "model", "minutes", "max"],
-    fetch: ["take", "result"],
+    read: ["context", "batch", "model", "minutes", "max"],
+    // a book the research has already: the refusal says --again where it applies
+    fetch: ["take", "result", "again"],
     "source add": ["translation", "media"],
     "source edit": ["translation", "media"],
-    "recordset add": ["images"],
+    "recordset add": ["images", "again"],
     grep: ["regex", "files"],
     // what a waiting task waits for is said when it is set waiting (task wait); edit fills it for an older one
     "task edit": ["on", "kind", "to", "request", "url"],

package/dist/commands/connectors.js

@@ -18,7 +18,8 @@ import { EXIT, StromError, UsageError } from "../core/errors.js";
 import { deadlineOf, REMIND_MS } from "../core/clock.js";
 import { isAgent } from "../core/which.js";
 import { RECORD_TYPES } from "../core/model.js";
-import { requireRecord } from "../core/records.js";
+import { requireRecord, update } from "../core/records.js";
+import { sameBooks, sameBookText } from "../core/samebook.js";
 import { guardIndexFirst } from "../core/indexfirst.js";
 import { readable } from "../core/text.js";
 import { findImage, isWhole, partHere, regionText, SHARPER } from "../core/media.js";
@@ -500,28 +501,49 @@ function netWords(ctx, c, levels) {
 /** Up to this many books, each comes with the command to register it; more, one line each. */
 const BOOKS_IN_FULL = 3;
 const BOOKS_SHOWN = 30;
-function bookLines(r, c, listOne) {
+function bookLines(r, c, listOne, tree) {
     // a connector that fetches nothing (the terms forbid it, or it only finds): the images come by hand
     const fetches = !byHandOnly(c) && c.manifest.can.some((x) => x === "fetch" || x === "locate");
+    // a book the research has already (its link, or images fetched from it): read there, never registered again
+    const known = (b) => (tree ? sameBooks(tree, { ...(b.url ? { url: b.url } : {}), connector: c.name, ...(b.id !== undefined ? { book: String(b.id) } : {}) }) : []);
     const line = (b) => `${b.title}${b.callNumber ? ` (${b.callNumber})` : ""}${b.years ? ` · ${b.years}` : ""}${b.kinds?.length ? ` · ${b.kinds.join(",")}` : ""}${b.images ? ` · ${b.images} images` : ""}`;
+    const here = (b) => {
+        const same = known(b);
+        return same.length ? ` · already in the research as ${same.map(sameBookText).join(", ")}` : "";
+    };
     if (r.books.length > BOOKS_IN_FULL)
         return [
-            ...r.books.slice(0, BOOKS_SHOWN).map((b) => `  ${b.id ? `${b.id}  ` : ""}${line(b)}`),
+            ...r.books.slice(0, BOOKS_SHOWN).map((b) => `  ${b.id ? `${b.id}  ` : ""}${line(b)}${here(b)}`),
             r.books.length > BOOKS_SHOWN ? `  … ${r.books.length - BOOKS_SHOWN} more — narrow it with --years, or read them all with --json` : undefined,
             `  one of them, with the command to register it: ${listOne}`,
         ].filter((l) => l !== undefined);
-    return r.books.map((b) => [
-        `  ${line(b)}`,
-        b.url ? `    ${b.url}` : undefined,
-        `    strom recordset add ${shellArg(b.title)}${b.callNumber ? ` --call-number ${shellArg(b.callNumber)}` : ""}${b.kinds?.length ? ` --kinds ${b.kinds.join(",")}` : ""}${b.places?.length ? ` --places ${shellArg(b.places.join(","))}` : ""}${b.years ? ` --years ${b.years}` : ""}${b.url ? ` --url ${shellArg(b.url)}` : ""} --access online-free`,
-        !fetches
-            ? `    then: the user saves the images by hand — strom task wait T… --images B…:<from-to> --on "<the book, its link, which images>"`
-            : b.id
-                ? `    then: strom fetch ${c.name} ${shellArg(b.id)} --images <from-to> --recordset B…`
-                : undefined,
-    ]
-        .filter(Boolean)
-        .join("\n"));
+    return r.books.map((b) => {
+        const same = known(b);
+        if (same.length) {
+            const first = same[0];
+            return [
+                `  ${line(b)}`,
+                b.url ? `    ${b.url}` : undefined,
+                `    already in the research as ${same.map(sameBookText).join(", ")} — never registered again`,
+                `    read it: strom read ${first.book.id} --images <from-to>`,
+                fetches && b.id ? `    its images not here yet: strom fetch ${c.name} ${shellArg(b.id)} --images <from-to> --recordset ${first.book.id}` : undefined,
+            ]
+                .filter(Boolean)
+                .join("\n");
+        }
+        return [
+            `  ${line(b)}`,
+            b.url ? `    ${b.url}` : undefined,
+            `    strom recordset add ${shellArg(b.title)}${b.callNumber ? ` --call-number ${shellArg(b.callNumber)}` : ""}${b.kinds?.length ? ` --kinds ${b.kinds.join(",")}` : ""}${b.places?.length ? ` --places ${shellArg(b.places.join(","))}` : ""}${b.years ? ` --years ${b.years}` : ""}${b.url ? ` --url ${shellArg(b.url)}` : ""} --access online-free`,
+            !fetches
+                ? `    then: the user saves the images by hand — strom task wait T… --images B…:<from-to> --on "<the book, its link, which images>"`
+                : b.id
+                    ? `    then: strom fetch ${c.name} ${shellArg(b.id)} --images <from-to> --recordset B…`
+                    : undefined,
+        ]
+            .filter(Boolean)
+            .join("\n");
+    });
 }
 function parseImages(v, max = 1000) {
     if (v === undefined)
@@ -1226,6 +1248,7 @@ register({
         { name: "list", type: "boolean", description: "describe the book (title, images)" },
         { name: "take", type: "boolean", description: "through the browser: take over what it downloaded (checked, registered)" },
         { name: "result", type: "string", value: "<line>", description: "with --take: the line the browser script returned (strom-result …)" },
+        { name: "again", type: "string", value: "<reason>", description: "fetch although a book of the research is this book (the same link, or its images came from it): why — into --recordset, another book (kept on it); without it, into the inbox" },
         { name: "no-index", type: "boolean", description: "fetch the images although an index of the book's parish and years is known (read already, or of no use here) — a session of strom run needs it from as many images on as strom read --no-index says" },
     ],
     examples: [
@@ -1261,6 +1284,8 @@ register({
                     ? partRequest(tree, c, args[1], opts)
                     : { cmd: "fetch", book: need(args[1], "the book"), images: parseImages(opts.images, perHour) ?? needImages() };
         const recordset = opts.recordset ? requireRecord(tree, String(opts.recordset), "recordset").id : undefined;
+        if (request.cmd === "fetch")
+            sameBookFirst(ctx, c, request, recordset, typeof opts.again === "string" ? opts.again.trim() || undefined : undefined);
         return fetchWith(ctx, c, request, recordset, Boolean(opts["no-index"]));
     },
 }, {
@@ -1810,6 +1835,37 @@ function fromStore(ctx, c, request, recordset, h, via) {
         },
     };
 }
+/**
+ * A book the research has under another ID is never fetched again (B0389 = B0169: every image asked of the archive
+ * twice, found by its hash only after): before any request, the book of the same link, or whose images came from this
+ * book of the connector, is named — fetch into it, read it. --again with a reason fetches into --recordset all the
+ * same and keeps why on it (the same book never asked again).
+ */
+function sameBookFirst(ctx, c, request, recordset, again) {
+    const tree = ctx.tree();
+    const target = recordset ? tree.get(recordset) : undefined;
+    // the book registered first is fetched into as before: only one registered before the target makes it a copy
+    const before = (b) => !target || b.created.localeCompare(target.created) < 0 || (b.created === target.created && b.id < target.id);
+    const same = sameBooks(tree, { ...(target?.url ? { url: target.url } : {}), connector: c.name, book: String(request.book) }, recordset).filter((x) => before(x.book));
+    if (!same.length)
+        return;
+    const first = same[0].book.id;
+    const imgs = imagesArg(request.images);
+    if (!recordset) {
+        if (again)
+            return;
+        throw new UsageError(`book ${request.book} of ${c.name} is ${same.map(sameBookText).join(", ")} in the research — nothing fetched`, {
+            hint: `its images: strom fetch ${c.name} ${shellArg(String(request.book))} --images ${imgs} --recordset ${first} (only those not here are asked for) · read it: strom read ${first} --images ${imgs} · into the inbox all the same: --again "<why>"`,
+        });
+    }
+    if (!again)
+        throw new UsageError(`${recordset} is the same book as ${same.map(sameBookText).join(", ")} (${same[0].by === "url" ? "the same link" : `its images came from book ${request.book} of ${c.name}`}) — nothing fetched`, {
+            hint: `fetch into it: strom fetch ${c.name} ${shellArg(String(request.book))} --images ${imgs} --recordset ${first} (only the images not here are asked for) · read it: strom read ${first} --images ${imgs} · ${recordset} is another book (another film): --again "<why>"`,
+        });
+    if (tree.dryRun)
+        return;
+    update(tree, recordset, "recordset", (cur) => ({ ...cur, duplicates: { of: [...new Set([...(cur.duplicates?.of ?? []), ...same.map((x) => x.book.id)])], reason: again } }), { op: "recordset.edit", summary: `${recordset} duplicates (beside ${same.map((x) => x.book.id).join(", ")})`, reason: again });
+}
 /** strom fetch, once the request is known: checked against the archive's terms, then through strom or the user's browser. */
 async function fetchWith(ctx, c, request, recordset, noIndex = false, again = false) {
     const tree = ctx.tree();
@@ -1904,7 +1960,7 @@ async function fetchWith(ctx, c, request, recordset, noIndex = false, again = fa
         fs.rmSync(workDir, { recursive: true, force: true });
         const wait = later(r, "the same command");
         return {
-            text: lines(describeRun(r, `${request.cmd} (${took})`), r.books.length ? [`books (${r.books.length}):`, ...bookLines(r, c, `strom fetch ${c.name} <id> --list`)].join("\n") : advice ?? (r.stopped ? "no books — the run stopped before any came" : "no books found"), r.books.length ? advice : undefined, wait.line, near),
+            text: lines(describeRun(r, `${request.cmd} (${took})`), r.books.length ? [`books (${r.books.length}):`, ...bookLines(r, c, `strom fetch ${c.name} <id> --list`, tree)].join("\n") : advice ?? (r.stopped ? "no books — the run stopped before any came" : "no books found"), r.books.length ? advice : undefined, wait.line, near),
             data: r,
             ...(wait.exitCode ? { exitCode: wait.exitCode } : r.stopped && !r.books.length ? { exitCode: 1 } : {}),
         };

package/dist/commands/media.js

@@ -89,8 +89,10 @@ export function registerImages(tree, shared, items, recordset) {
         }
     });
     const woken = [];
+    // a task that waits for images of a book is woken by that book alone, whatever other books it names
+    const wakes = (t, b) => (t.awaits ? t.awaits.recordset === b : t.where.includes(b) || (t.waitingOn ?? "").includes(b));
     if (recordset && added.length)
-        for (const t of tree.list("task").filter((t) => t.state === "waiting" && (t.where.includes(recordset) || (t.waitingOn ?? "").includes(recordset)))) {
+        for (const t of tree.list("task").filter((t) => t.state === "waiting" && wakes(t, recordset))) {
             // what it asked for and what is still missing, for the session that takes it up
             const have = new Set(tree.list("media").filter((m) => m.recordset === recordset).map((m) => m.image)); // a part counts: it was asked for too
             const missing = t.awaits?.recordset === recordset ? (parseImageList(t.awaits.images) ?? []).filter((n) => !have.has(n)) : [];

package/dist/commands/read.js

@@ -7,6 +7,7 @@ import path from "node:path";
 import { register } from "../cli/registry.js";
 import { lines, runs } from "../cli/format.js";
 import { StromError, UsageError } from "../core/errors.js";
+import { DEFAULT_READ_PARALLEL, READ_PARALLEL_MAX } from "../core/config.js";
 import { normId, requireRecord } from "../core/records.js";
 import { pageOf } from "../core/calibration.js";
 import { coveringPart, findImage, IMAGE_RANGE_MAX, imageOfRef, onlyParts, regionText, wholeSizeOf } from "../core/media.js";
@@ -98,7 +99,7 @@ register({
         { name: "contrast", type: "boolean", description: "more contrast (faded ink)" },
         { name: "max", type: "string", value: "<px>", description: `size of the views (default: what the readers' model takes, ${IMAGE_MAX} or ${IMAGE_MAX_LARGE}); smaller = cheaper browsing` },
         { name: "batch", type: "string", value: "<n>", description: `views per reader — a double page in halves is two (default ${BATCH}, fewer where strom tuned the reading of this agent and model: strom config get reading.batch; at most ${BATCH_MAX})` },
-        { name: "parallel", type: "string", value: "<n>", description: "readers at the same time (default 3)" },
+        { name: "parallel", type: "string", value: "<n>", description: `readers at the same time, 1 to ${READ_PARALLEL_MAX} (default ${DEFAULT_READ_PARALLEL}, or the setting read.parallel: strom config set read.parallel <n>)` },
         { name: "model", type: "string", value: "<model>", description: "model of the readers (default: model.vision — never weaker for handwriting)" },
         { name: "minutes", type: "string", value: "<n>", description: READER_MINUTES_HELP, mistaken: ["timeout", "time", "time-limit", "max-minutes"] },
         { name: "no-index", type: "boolean", description: `browse the images although an index of the book's parish and years is known (read already, or of no use here) — from ${INDEX_FIRST_DEFAULT} images on (the person's answer: strom media calibrate --questions) strom names the index first, and a session of strom run needs this to go on` },
@@ -192,7 +193,10 @@ register({
         const size = opts.batch === undefined ? readingOf(ctx.settings.config, sizes.key, { since, on: tuningOn(ctx.settings), root: tree.root }).readerBatch : Number(opts.batch);
         if (!Number.isInteger(size) || size < 1)
             throw new UsageError("--batch must be a positive number");
-        const parallel = opts.parallel === undefined ? 3 : Math.max(1, Number(opts.parallel) || 1);
+        // readers at the same time: --parallel, else read.parallel (the tree's, else the user's), else DEFAULT_READ_PARALLEL
+        const parallel = opts.parallel === undefined ? ctx.settings.readParallel(tree.config) : Number(opts.parallel);
+        if (!Number.isInteger(parallel) || parallel < 1 || parallel > READ_PARALLEL_MAX)
+            throw new UsageError(`--parallel is a whole number from 1 to ${READ_PARALLEL_MAX}`, { hint: `readers at the same time (default ${DEFAULT_READ_PARALLEL}; strom config set read.parallel <n> keeps another)` });
         // a reader's time limit: by hand, else by what it is given and what the readers before it needed (readerLimit)
         const minutesSaid = opts.minutes === undefined ? undefined : Number(opts.minutes);
         if (minutesSaid !== undefined && !(minutesSaid > 0))

package/dist/commands/setup.js

@@ -6,7 +6,7 @@ import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { APP_URL_INVALID_SETTING, register } from "../cli/registry.js";
 import { lines, secondsIn, table } from "../cli/format.js";
-import { appWebPages, checkValue, configFile, DEFAULT_BUDGET, DEFAULT_RUN_MINUTES, OTHER_ENV, readStored, SETTINGS, settingDef, settingDescription, writeStored } from "../core/config.js";
+import { appWebPages, checkValue, configFile, DEFAULT_BUDGET, DEFAULT_READ_PARALLEL, DEFAULT_RUN_MINUTES, OTHER_ENV, readStored, SETTINGS, settingDef, settingDescription, writeStored } from "../core/config.js";
 import { syncAgentFiles } from "../agents/files.js";
 import { gitVersion } from "../core/git.js";
 import { linuxGitCommand } from "../core/deps.js";
@@ -780,6 +780,8 @@ function effective(ctx, def, recordset) {
         return { value: DEFAULT_RUN_MINUTES, source: "default" };
     if (def.key === "web.perHost")
         return { value: WEB_PER_HOST, source: "default" };
+    if (def.key === "read.parallel")
+        return { value: DEFAULT_READ_PARALLEL, source: "default" };
     if (def.key === "connectors.consent")
         return { value: "off", source: "default" };
     if (def.key === "agent.addons")

package/dist/commands/sources.js

@@ -15,6 +15,7 @@ import { partRegion } from "../core/views.js";
 import { formatName } from "../core/people.js";
 import { yearsOption, yearsOverlap } from "../core/years.js";
 import { levelWords } from "../core/archiveasks.js";
+import { bookUrlKey, sameBooks, sameBookText } from "../core/samebook.js";
 function written(tree) {
     return lines(...tree.written.map((o) => o.summary));
 }
@@ -108,6 +109,25 @@ evidence, opts, merge = () => ({})) {
 function editOptions(options, extra = []) {
     return [...extra, ...(options ?? []).map((o) => ({ ...o, description: o.description.replace(/\s*\(default[^)]*\)/, "") }))];
 }
+/**
+ * A book registered twice is fetched twice (every image asked of the archive again): a link another book of the
+ * research has is refused, pointing to that book — unless --again says why this is another book (then kept on it).
+ */
+function sameLink(tree, url, again, said, self) {
+    const same = url ? sameBooks(tree, { url }, self).filter((x) => x.by === "url") : [];
+    if (!same.length) {
+        if (again)
+            said.push("--again: no other book of the research has this link — nothing to explain");
+        return undefined;
+    }
+    const first = same[0].book.id;
+    if (!again)
+        throw new UsageError(`this link is the book ${same.map(sameBookText).join(", ")} of the research already — the same book is never registered twice`, {
+            hint: `read it: strom read ${first} --images <from-to> · its images not here yet: strom fetch <connector> <book> --images <from-to> --recordset ${first} · another book at the same link (another film): --again "<why>"`,
+        });
+    said.push(`registered beside ${same.map((x) => x.book.id).join(", ")} (the same link): ${again}`);
+    return { of: same.map((x) => x.book.id), reason: again };
+}
 function readText(ctx) {
     return (p) => fs.readFileSync(ctx.resolvePath(p), "utf8");
 }
@@ -349,6 +369,7 @@ register({
         { name: "images", type: "string", value: "<n>", description: "number of images" },
         { name: "layout", type: "string", value: "<text>", description: "how pages are laid out (columns, two years per page, …)" },
         { name: "note", type: "string", value: "<text>", description: "short note" },
+        { name: "again", type: "string", value: "<reason>", description: "register it although a book of the research has the same link: why it is another book (another film, another copy)" },
     ],
     examples: ['strom recordset add "Týnec nad Labem 17, N 1861-1869" --repo R0001 --kinds baptism --places "Týnec nad Labem,Bělušice" --years 1861-1869 --access online-free --url https://…'],
     run(ctx, { args, opts }) {
@@ -356,6 +377,7 @@ register({
         if (opts.repo)
             requireRecord(tree, opts.repo, "repository");
         const said = [];
+        const duplicates = sameLink(tree, str(opts.url), str(opts.again), said);
         const years = yearsOption(str(opts.years), said, "1784-1820");
         const images = opts.images === undefined ? undefined : Number(opts.images);
         if (images !== undefined && (!Number.isInteger(images) || images < 1))
@@ -373,6 +395,7 @@ register({
             calibration: [],
             layout: str(opts.layout),
             note: str(opts.note),
+            duplicates,
         }, (id) => `+${id} record set "${truncate(args[0], 60)}"`);
         return { text: lines(written(tree), ...said), data: { recordset: b } };
     },
@@ -731,6 +754,11 @@ register({
         const images = opts.images === undefined ? undefined : Number(opts.images);
         if (images !== undefined && (!Number.isInteger(images) || images < 1))
             throw new UsageError("--images must be a positive number");
+        const cur = requireRecord(tree, args[0], "recordset");
+        // a link changed is checked; --again alone explains the link the book has
+        const url = str(opts.url);
+        const changed = url !== undefined && bookUrlKey(url) !== bookUrlKey(cur.url ?? "");
+        const duplicates = sameLink(tree, changed ? url : str(opts.again) ? cur.url : undefined, str(opts.again), said, cur.id);
         const b = editFields(tree, args[0], "recordset", {
             title: str(opts.title),
             repository: opts.repo ? normId(opts.repo) : undefined,
@@ -742,7 +770,7 @@ register({
             url: str(opts.url),
             images,
             layout: str(opts.layout),
-        }, {}, opts);
+        }, {}, opts, (cur) => (duplicates ? { duplicates: { of: [...new Set([...(cur.duplicates?.of ?? []), ...duplicates.of])], reason: duplicates.reason } } : {}));
         return { text: lines(written(tree), ...said), data: { recordset: b } };
     },
 }, {

package/dist/core/config.js

@@ -27,6 +27,9 @@ const PERMISSION_ALIASES = { list: "auto", bypass: "full" };
  */
 export const DEFAULT_BUDGET = 55_000;
 export const DEFAULT_RUN_MINUTES = 60;
+/** Readers of strom read at the same time: the default, and the most one research may set (each reader is an agent process). */
+export const DEFAULT_READ_PARALLEL = 5;
+export const READ_PARALLEL_MAX = 10;
 export const SETTINGS = [
     { key: "home", env: "STROM_HOME", tree: false, kind: "path", description: "folder with the trees and shared data" },
     { key: "shared", env: "STROM_SHARED", tree: false, kind: "path", description: "shared data: scans, catalog, tools (default <home>/shared)" },
@@ -51,6 +54,7 @@ export const SETTINGS = [
     { key: "model.effort", env: "", tree: true, kind: "model", description: "reasoning effort of the agent's model in the sessions strom starts (Codex, Claude Code, Antigravity, Grok): high recommended — old handwriting read with the best setting; a plan's limit runs out sooner. Unset: the agent's own settings (Codex: its config.toml); only you raise it" },
     { key: "brief.budget", env: "STROM_BRIEF_BUDGET", tree: true, kind: "number", description: `size of the brief in tokens (default ${DEFAULT_BUDGET})` },
     { key: "run.minutes", env: "STROM_RUN_MINUTES", tree: true, kind: "number", description: `time limit of one \`strom run\` session (default ${DEFAULT_RUN_MINUTES})` },
+    { key: "read.parallel", env: "", tree: true, kind: "number", description: `readers of \`strom read\` at the same time, 1 to ${READ_PARALLEL_MAX} (default ${DEFAULT_READ_PARALLEL}): --parallel of the command, else the tree's, else yours — the same readers and requests, only sooner; fewer when the agent's usage runs out too fast` },
     // Read from the config files only (the user's or the tree's) — no variable: more requests to one server is the
     // user's decision (as model.effort higher); lowering it is anyone's.
     { key: "web.perHost", env: "", tree: true, kind: "number", description: `web requests to one site (its mirrors with it) in one session through an agent's own web fetch (default ${WEB_PER_HOST}; past ${WEB_SOFT} they go slower and the agent builds a connector): past it a run refuses and a conversation asks you, and more pages of that site go through strom fetch with a connector — only you raise it` },
@@ -97,6 +101,7 @@ export const SETTINGS = [
 const FIELDS = {
     "brief.budget": "briefBudget",
     "run.minutes": "runMinutes",
+    "read.parallel": "readParallel",
     "web.perHost": "webPerHost",
     "gedcom.for": "gedcomFor",
     "strom.version": "stromVersion",
@@ -246,6 +251,8 @@ export function checkValue(def, raw, resolvePath, env = {}) {
             const n = Number(v);
             if (!Number.isFinite(n) || n <= 0)
                 throw new UsageError(`${def.key} must be a positive number`);
+            if (def.key === "read.parallel" && (!Number.isInteger(n) || n > READ_PARALLEL_MAX))
+                throw new UsageError(`${def.key} is a whole number from 1 to ${READ_PARALLEL_MAX}`, { hint: `readers at the same time — strom config set read.parallel ${DEFAULT_READ_PARALLEL}` });
             return def.key === "brief.budget" || def.key === "web.perHost" ? Math.max(1, Math.round(n)) : n;
         }
     }
@@ -416,6 +423,11 @@ export class Settings {
         const r = this.resolve(key, tree);
         return r ? Number(r.value) : fallback;
     }
+    /** Readers of strom read at the same time (read.parallel: tree > user, else DEFAULT_READ_PARALLEL); a stored value out of range is brought into it. */
+    readParallel(tree) {
+        const n = Math.round(this.number("read.parallel", tree, DEFAULT_READ_PARALLEL));
+        return Number.isFinite(n) ? Math.min(READ_PARALLEL_MAX, Math.max(1, n)) : DEFAULT_READ_PARALLEL;
+    }
     /** Web requests to one server in one session through an agent's own web fetch before strom refuses or asks (web.perHost: tree > user). */
     webPerHost(tree) {
         const n = Math.round(this.number("web.perHost", tree, WEB_PER_HOST));

package/dist/core/samebook.js

@@ -0,0 +1,42 @@
+// The same book under two IDs: one book of an archive registered twice is fetched twice — every image asked of the
+// archive again, then found by its hash to be another book's. A book is known by its link, or by the book of a
+// connector its images came from.
+/** A link as it is compared: no fragment, no trailing slash, the scheme and host in lower case (http = https). */
+export function bookUrlKey(url) {
+    const u = url.trim().replace(/#.*$/u, "").replace(/\/+$/u, "");
+    const m = /^([a-z][a-z0-9+.-]*):\/\/([^/?]*)(.*)$/iu.exec(u);
+    if (!m)
+        return u;
+    const scheme = m[1].toLowerCase().replace(/^https$/u, "http");
+    return `${scheme}://${m[2].toLowerCase()}${m[3]}`;
+}
+/**
+ * The books of the research that are this one: the same link, or images fetched through this connector from this
+ * book. `except` — the book asked about itself, and those it was knowingly registered beside (`duplicates`).
+ */
+export function sameBooks(tree, of, except) {
+    const key = of.url ? bookUrlKey(of.url) : undefined;
+    const media = tree.list("media");
+    const own = except ? tree.get(except) : undefined;
+    const skip = new Set([...(except ? [except] : []), ...(own?.duplicates?.of ?? [])]);
+    const out = [];
+    for (const b of tree.list("recordset")) {
+        if (skip.has(b.id) || b.duplicates?.of.includes(except ?? ""))
+            continue;
+        const mine = media.filter((m) => m.recordset === b.id);
+        const by = key && b.url && bookUrlKey(b.url) === key
+            ? "url"
+            : of.connector && of.book !== undefined && mine.some((m) => m.fetched?.connector === of.connector && m.fetched?.book === String(of.book))
+                ? "connector"
+                : undefined;
+        if (!by)
+            continue;
+        out.push({ book: b, images: new Set(mine.filter((m) => !m.part && m.image !== undefined).map((m) => m.image)).size, by });
+    }
+    // the book registered first is the book: the others are its copies
+    return out.sort((a, b) => a.book.created.localeCompare(b.book.created) || a.book.id.localeCompare(b.book.id));
+}
+/** "B0169 (148 images here)" */
+export function sameBookText(s) {
+    return `${s.book.id}${s.images ? ` (${s.images} image${s.images === 1 ? "" : "s"} here)` : " (no images here yet)"}`;
+}

package/dist/core/schema.js

@@ -49,6 +49,7 @@ export const SCHEMAS = {
         images: { t: "number", int: true, min: 1 },
         calibration: { t: "array", req: true, of: { image: { t: "number", req: true, int: true, min: 1 }, page: S({ req: true }) } },
         layout: S({ max: 1000 }),
+        duplicates: { t: "object", of: { of: RS("recordset", 1), reason: S({ req: true, max: 1000 }) } },
     },
     place: {
         names: { t: "array", req: true, min: 1, of: { name: S({ req: true }), lang: S(), from: { t: "number", int: true }, to: { t: "number", int: true } } },

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.14.0";
+export const VERSION = "1.15.0-beta.1";
 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.14.0",
+  "version": "1.15.0-beta.1",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {
@@ -45,5 +45,8 @@
   "devDependencies": {
     "@types/node": "^22.20.4",
     "typescript": "^7.0.2"
+  },
+  "publishConfig": {
+    "tag": "beta"
   }
 }