strom-research 1.15.0-beta.4 → 1.15.0-beta.6

package/CHANGELOG.cs.md

@@ -0,0 +1,45 @@
+# Co je nového ve Strom výzkumu
+
+[English](CHANGELOG.md) · Čeština · [Deutsch](CHANGELOG.de.md)
+
+Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou na
+[GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (anglicky).
+
+## 1.15.0
+
+*Patří k aplikaci Strom 3.12.0.*
+
+- **Archiv Stromu podle volby, i s AI agentem.** Průvodce nastavením se ptá, zda nové rodokmeny budou výzkumem
+  s agentem, nebo jen Archivem Stromu; v nastavení jde volbu změnit pro jeden rodokmen nebo pro nové.
+- **Výzkum čeká na svého agenta.** Rodokmen, jehož AI agent na tomto počítači není, ukládá, co posílá aplikace Strom,
+  jako Archiv Stromu. Jakmile je agent nainstalovaný, výzkum pokračuje sám.
+- **Jedna kniha archivu se stahuje jednou.** Kniha, která už ve výzkumu je, se pojmenuje místo nového zápisu
+  a stahování, takže archiv nikdy nedostane dvakrát žádost o tytéž snímky.
+- **Rychlejší čtení.** Snímky čte současně pět čtenářů (nastavení `read.parallel`, 1 až 10) a dlouhé stahování
+  ukazuje, kolik už je hotovo („40/109 snímků“). Čtenáři začnou už během stahování knihy: snímky se registrují
+  po deseti a co nepřišlo, je řečeno přesně; Ctrl-C ponechá, co už přišlo. Archiv dostane stejné žádosti ve stejném
+  tempu. Kniha se může stahovat i na pozadí, zatímco agent pracuje dál (`strom fetch --background`), nikdy z archivu,
+  který dovoluje jen tempo člověka. Hledání jednoho zápisu může skončit u nálezu (`strom read --until-found`):
+  přečtené snímky jsou řečeny přesně a jen ty se počítají jako prohledané.
+- **Rodokmeny z jiných programů.** Soubor GEDCOM uložený se značkou BOM nebo v UTF-16 (tak ho ukládají některé programy
+  ve Windows) se čte jako rodokmen; rodokmen jiného výzkumu se převezme jako cizí.
+- **Živé sledování končí čistě** na každém systému, i ve Windows, a aplikace Strom se dozví, že skončilo.
+- **Jeden strom na instalaci.** Jiný strom na stejném počítači (z npm nebo sestavený ze zdrojů) nikdy nepřevezme odkazy
+  aplikace Strom ani kanál aktualizací.
+- **Co je nového.** Po `strom update` a u `strom --version` odkaz na tento přehled v jazyce výzkumu. Aplikace Strom
+  ukazuje body nové verze výzkumu ve svém okně „Co je nového“.
+
+## 1.14.0
+
+*11. 10. 2026 · patří k aplikaci Strom 3.11.0.*
+
+- **Podmínky každého archivu.** strom dodržuje, jak daleko každý archiv dovoluje automatický přístup: povoleno,
+  omezeně, jen ručně, nebo vůbec. Kde podmínky nejsou jasné, rozhodne jednou člověk. Odmítnutí archiv na den odloží.
+- **Co čeká, po místech.** Věci pro člověka jsou seřazené podle druhu a seskupené podle toho, kde se vyřizují: jeden
+  archiv, jeden úřad, rodina, jeden web. Dopis nebo dotaz jde označit jako odeslaný.
+- **Čtení starého písma.** Snímky ve velikosti, jakou každý pohled potřebuje, čtenář snímků na modelu, který si člověk
+  zvolil, a čtení vyladěné na vlastních doložených záznamech výzkumu.
+- **S aplikací Strom 3.11.0.** Rozpor mezi úpravou v aplikaci a záznamem se rozhoduje v aplikaci; hypotézy ukazují, co
+  by která varianta spojila.
+- **Menší podklady pro agenta, které vědí víc**, a míra uvažování je volbou člověka (`model.effort`).
+- **`strom grep`** prohledává podklady, poznámky a výstupy výzkumu, i bez ohledu na diakritiku.

package/CHANGELOG.de.md

@@ -0,0 +1,49 @@
+# Was ist neu in Strom Ahnenforschung
+
+[English](CHANGELOG.md) · [Čeština](CHANGELOG.cs.md) · Deutsch
+
+Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Installationszeilen stehen bei
+[GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (auf Englisch).
+
+## 1.15.0
+
+*Gehört zur Strom-App 3.12.0.*
+
+- **Ein Strom-Archiv nach Wahl, auch mit einem KI-Agenten.** Die Einrichtung fragt, ob neue Stammbäume Forschungen mit
+  dem Agenten sind oder nur ein Strom-Archiv; in den Einstellungen lässt sich das für einen Stammbaum oder für die
+  neuen ändern.
+- **Eine Forschung wartet auf ihren Agenten.** Ein Stammbaum, dessen KI-Agent nicht auf diesem Computer ist, speichert,
+  was die Strom-App sendet, wie ein Strom-Archiv. Sobald der Agent installiert ist, geht die Forschung von selbst weiter.
+- **Ein Buch eines Archivs, einmal geladen.** Ein Buch, das schon in der Forschung ist, wird genannt, statt neu
+  eingetragen und wieder geladen zu werden – ein Archiv wird nie zweimal um dieselben Bilder gebeten.
+- **Schneller lesen.** Fünf Leser lesen die Scans gleichzeitig (die Einstellung `read.parallel`, 1 bis 10), und ein
+  langer Download zeigt, wie weit er ist („40/109 Bilder“). Die Leser beginnen schon, während ein Buch lädt: seine
+  Bilder werden zu zehnt registriert, und was nicht kam, wird genau gesagt; Strg+C behält, was schon kam. Ein Archiv
+  bekommt dieselben Anfragen im selben Tempo wie bisher. Ein Buch kann auch im Hintergrund laden, während der Agent
+  weiterarbeitet (`strom fetch --background`), nie aus einem Archiv, das nur das Tempo eines Menschen erlaubt. Die
+  Suche nach einem Eintrag kann beim Fund enden (`strom read --until-found`): die gelesenen Bilder werden genau gesagt,
+  und nur sie gelten als durchsucht.
+- **Stammbäume aus anderen Programmen.** Eine GEDCOM-Datei mit Byte-Order-Mark oder in UTF-16 (so speichern sie manche
+  Windows-Programme) wird als Stammbaum gelesen; der Stammbaum einer anderen Forschung wird als fremder übernommen.
+- **Die Live-Ansicht endet sauber** auf jedem System, auch unter Windows, und die Strom-App erfährt, dass sie endete.
+- **Ein strom pro Installation.** Ein anderer strom auf demselben Computer (aus npm oder aus den Quellen gebaut)
+  übernimmt nie die Links der Strom-App oder den Update-Kanal.
+- **Was ist neu.** Nach `strom update` und bei `strom --version` ein Link zu dieser Übersicht in der Sprache der
+  Forschung. Die Strom-App zeigt die Punkte einer neuen Forschungsversion in ihrem Fenster „Was ist neu“.
+
+## 1.14.0
+
+*11.10.2026 · gehört zur Strom-App 3.11.0.*
+
+- **Die Bedingungen jedes Archivs.** strom hält sich daran, wie weit jedes Archiv automatischen Zugriff erlaubt:
+  erlaubt, eingeschränkt, nur von Hand oder gar nicht. Wo die Bedingungen unklar sind, entscheidet einmal der Mensch.
+  Eine Ablehnung pausiert ein Archiv für einen Tag.
+- **Was wartet, nach Orten.** Die Dinge für den Menschen sind nach Art sortiert und danach gruppiert, wo sie erledigt
+  werden: ein Archiv, ein Amt, die Familie, eine Website. Ein Brief oder eine Frage lässt sich als verschickt markieren.
+- **Alte Handschrift lesen.** Scans in der Größe, die jede Ansicht braucht, ein Leser der Scans auf dem Modell, das der
+  Mensch gewählt hat, und das Lesen abgestimmt auf die eigenen belegten Einträge der Forschung.
+- **Mit der Strom-App 3.11.0.** Ein Widerspruch zwischen einer Änderung in der App und einem Eintrag wird in der App
+  entschieden; Hypothesen zeigen, was jede Variante verbinden würde.
+- **Kleinere Unterlagen für den Agenten, die mehr wissen**, und der Denkaufwand ist die Wahl des Menschen
+  (`model.effort`).
+- **`strom grep`** durchsucht die Unterlagen, Notizen und Ausgaben der Forschung, auch über Akzente hinweg.

package/CHANGELOG.md

@@ -0,0 +1,45 @@
+# What's new in Strom Research
+
+English · [Čeština](CHANGELOG.cs.md) · [Deutsch](CHANGELOG.de.md)
+
+The changes of each version in short. The full notes and the install lines are on
+[GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases).
+
+## 1.15.0
+
+*Goes with the Strom app 3.12.0.*
+
+- **A Strom archive by choice, with an AI agent too.** The setup asks whether new family trees are researches with the
+  agent or only a Strom archive; the settings change it for one family tree or for the new ones.
+- **A research waiting for its agent.** A family tree whose AI agent is not on this computer keeps what the Strom app
+  sends, as a Strom archive does. Once the agent is installed, the research goes on by itself.
+- **One book of an archive, fetched once.** A book already in the research is named instead of being registered and
+  fetched again, so an archive is never asked twice for the same images.
+- **Faster reading.** Five readers read the scans at the same time (the setting `read.parallel`, 1 to 10), and a long
+  download says how far it is ("40/109 images"). The readers begin while a book is still downloading: its images are
+  registered ten at a time, and what did not come is said exactly; Ctrl-C keeps what came. An archive gets the same
+  requests at the same pace. A book can also be fetched in the background while the agent works on (`strom fetch
+  --background`), never from an archive that allows only a person's pace. A search for one entry can stop at the find
+  (`strom read --until-found`): the images read are said exactly, and only they count as searched.
+- **Family trees from other programs.** A GEDCOM file saved with a byte order mark or in UTF-16 (as some Windows
+  programs save it) is read as a family tree; a family tree of another research is taken in as a foreign one.
+- **The live view ends cleanly** on every system, Windows too, and the Strom app learns that it ended.
+- **One strom per installation.** Another strom on the same computer (from npm, or built from the sources) never takes
+  over the links of the Strom app or the update channel.
+- **What's new.** After `strom update` and with `strom --version`, a link to this list in the research language. The
+  Strom app shows the points of a new research version in its own “What's new” window.
+
+## 1.14.0
+
+*2026-10-11 · goes with the Strom app 3.11.0.*
+
+- **Each archive's terms.** strom keeps to how far each archive allows automated access: allowed, restricted, by hand
+  only, or not at all. Where the terms are unclear, the person decides once. A refusal pauses an archive for a day.
+- **What waits, in places.** Things for the person are sorted by kind and grouped by where they are done: one archive,
+  one office, the family, one site. A letter or a question can be marked as sent.
+- **Reading old handwriting.** Scans at the size each view needs, a reader of scans on the person's model, and the
+  reading tuned on the research's own proven records.
+- **With the Strom app 3.11.0.** A conflict between an edit in the app and a record is decided in the app; hypotheses
+  show what each variant would connect.
+- **A smaller brief that knows more**, and the reasoning effort is the person's choice (`model.effort`).
+- **`strom grep`** searches the research's inputs, notes and output, through accents too.

package/README.md

@@ -48,7 +48,9 @@ Next time: run `strom`, or double-click the "Strom research" shortcut.
 Updates: strom looks for a new version at most once a day and says so;
 `strom update` installs it (checked like the installer does), and with it the
 newest security release of its Node line. Installed with
-npm: `npm install -g strom-research@latest`.
+npm: `npm install -g strom-research@latest`. What is new in each version:
+[CHANGELOG.md](CHANGELOG.md) ([čeština](CHANGELOG.cs.md), [Deutsch](CHANGELOG.de.md));
+`strom --version` and `strom update` link to it in the research language.
 
 ## Features
 

package/assets/lang/cs.json

@@ -250,6 +250,7 @@
   "ui.tune.book.weak": "zápory na slabých skenech {n} z {of}",
   "ui.tune.book.requests": "požadavky {n}",
   "ui.tune.book.unread": "staženo a nepřečteno {n} z {of}",
+  "ui.tune.book.background": "na pozadí: nepřečteno {n} z {of}",
   "ui.tune.hosts": "Archivy:",
   "ui.tune.host": "  {host}: sezení {sessions} · požadavky {requests} ({perSession} na sezení, {perImage} na snímek) · čekání {wait} min · limit vyčerpán {later}×",
   "ui.tune.web": "Webové nástroje agenta:",
@@ -754,6 +755,7 @@
   "ui.update.downloading": "Stahuji strom {version}…",
   "ui.update.failed": "Aktualizace se nepovedla: {detail}. strom zůstává, jak byl.",
   "ui.update.done": "✓ strom je aktualizovaný: {previous} → {version}.",
+  "ui.update.whatsnew": "Co je nového: {url}",
   "ui.update.restart": "strom je aktualizovaný — tahle nabídka ale ještě běží ve staré verzi. Po novém spuštění stromu (nebo zástupce „{shortcut}“) poběží nová verze.",
   "ui.o.update": "aktualizace",
   "ui.o.update.new": "vyšla {version} (tato je {current}) – řekni to uživateli; strom update ji s jeho souhlasem nainstaluje",

package/assets/lang/de.json

@@ -250,6 +250,7 @@
   "ui.tune.book.weak": "Negativbefunde auf schwachen Scans {n} von {of}",
   "ui.tune.book.requests": "Anfragen {n}",
   "ui.tune.book.unread": "geladen und nie gelesen {n} von {of}",
+  "ui.tune.book.background": "im Hintergrund: nie gelesen {n} von {of}",
   "ui.tune.hosts": "Archive:",
   "ui.tune.host": "  {host}: Sitzungen {sessions} · Anfragen {requests} ({perSession} pro Sitzung, {perImage} pro Bild) · gewartet {wait} min · Limit erschöpft {later}×",
   "ui.tune.web": "Eigene Webwerkzeuge des Agenten:",
@@ -754,6 +755,7 @@
   "ui.update.downloading": "strom {version} wird heruntergeladen…",
   "ui.update.failed": "Die Aktualisierung hat nicht geklappt: {detail}. strom bleibt, wie er war.",
   "ui.update.done": "✓ strom ist aktualisiert: {previous} → {version}.",
+  "ui.update.whatsnew": "Was ist neu: {url}",
   "ui.update.restart": "strom ist aktualisiert — dieses Menü läuft aber noch in der alten Version. Nach einem Neustart von strom (oder der Verknüpfung „{shortcut}“) läuft die neue Version.",
   "ui.o.update": "Update",
   "ui.o.update.new": "{version} ist da (diese ist {current}) – sag es dem Benutzer; strom update installiert sie mit seiner Zustimmung",

package/assets/method/core.md

@@ -102,6 +102,9 @@ conclusion so the next researcher can follow it.
   number by one or two images, never a batch of ten; an entry: its image ±1
   (it may run over a page). An archive that allows automation: batches as
   usual (about ±5 around the target, an index in batches) — fewer turns.
+  `strom read` may follow a fetch at work: sooner, never more images.
+  Images you will read later in the session: `--background` fetches them
+  while you work on, `strom read` reads them as they come.
 <!-- end -->
 - **What strom or the tree denies stays denied.** Never offer the user to
   change your permissions or settings, strom's or the tree's, to get round it:

package/assets/method/reading.md

@@ -65,6 +65,13 @@ never open again a view cleared from your context — your notes hold it.
   and headings only, one surname's entries, one entry whole — and transcribes
   nothing else. Record each report as it comes back, before the next readers.
   Only the entries that will be cited need your own eyes, at full resolution.
+<!-- for link verify enrich -->
+- **`--until-found` only for ONE particular entry** (one person's baptism,
+  marriage or burial whose details you know): no more readers begin once one
+  reports it. Never for every entry of a place or surname, nor where a
+  namesake may follow. Record only the images it names as read, `--result
+  partial`; if the find is not the one, read the rest.
+<!-- end -->
 - **Report image by image, as you go**: the image and page, what was found (or
   nothing), what was illegible and where, the hand, how sure each name is.
 - **Cite the image, and where the entry is on it**: `strom source add …

package/dist/brief/brief.js

@@ -39,6 +39,7 @@ import { ENRICH_PAGES, STORY_SOURCES_ORIGIN } from "../core/stories.js";
 import { sandboxOf, WITHOUT_READERS } from "../core/sandbox.js";
 import { WEB_SOFT } from "../core/metrics.js";
 import { indexBriefLines } from "../core/indexfirst.js";
+import { activeFetches, endedFetches } from "../core/fetching.js";
 /** The hosts of a connector, as its manifest names them (a wildcard without its star). */
 function connectorHosts(shared, name) {
     try {
@@ -627,6 +628,15 @@ function imagesLines(tree, b, route, shape, finder, noSharper = false, waiting)
                         : ""),
     ].filter(Boolean);
 }
+/** The fetches at work for the research (each book: how far), and those in the background that ended lately with images left. */
+function fetchingLines(root) {
+    const active = activeFetches(root);
+    const out = active.map((m) => `- ${m.recordset}: ${m.registered}/${m.images.length} images registered (${m.background ? `in the background${m.task ? `, for ${m.task}` : ""}` : "in the foreground"}) — strom read ${m.recordset} --images ${runs(m.images)} reads them as they come; not fetched again`);
+    for (const e of endedFetches(root))
+        if (e.missed.length && !active.some((m) => m.recordset === e.recordset))
+            out.push(`- ${e.recordset}: a fetch in the background ended with images ${runs(e.missed)} not fetched${e.stopped ? ` (stopped: ${e.stopped})` : ""} — strom fetch ${e.connector} ${shellArg(e.book)} --images ${runs(e.missed)} --recordset ${e.recordset} if they are needed`);
+    return out;
+}
 /** What the user put in the shared inbox, waiting to be registered — by folder (one download each). */
 function inboxLines(shared) {
     if (!shared)
@@ -1197,6 +1207,15 @@ export function buildBrief(tree, opts) {
                 '  strom media add --inbox "<folder>" --recordset B…   · a document (certificate, letter): strom intake <file>',
             ].join("\n"),
         });
+    // 7c. images being fetched for the research now (strom fetch --background of an earlier session, or another strom),
+    // and what fetches in the background left unfetched lately: read as they come, never fetched twice
+    const fetching = fetchingLines(tree.root);
+    if (fetching.length)
+        sections.push({
+            name: "fetching",
+            pointer: "strom fetch --status",
+            text: ["## Images being fetched now (strom fetch --status)", ...fetching].join("\n"),
+        });
     // 8. method for this kind of task
     // (budgeted first, with the record sets and the commands: when the brief is long, the lists are cut before how to work)
     // only the parts the level uses — of getting images, those of how this task's record sets get them (none named:

package/dist/brief/sheet.js

@@ -29,8 +29,8 @@ const RARE = {
     "task add": ["research", "anyway"],
     "media view": ["scale", "max", "grey", "png", "image"],
     read: ["context", "batch", "model", "minutes", "max"],
-    // a book the research has already: the refusal says --again where it applies
-    fetch: ["take", "result", "again"],
+    // a book the research has already: the refusal says --again where it applies; --status and --stop: the method and the brief name them
+    fetch: ["take", "result", "again", "status", "stop"],
     "source add": ["translation", "media"],
     "source edit": ["translation", "media"],
     "recordset add": ["images", "again"],

package/dist/cli/commit.js

@@ -13,7 +13,9 @@ export function commitMessage(summaries, command) {
 /** Commit the changes of this command. Returns what blocked the commit, if anything did. */
 export function autoCommit(ctx, def) {
     const tree = ctx.current();
-    if (!tree || tree.dryRun || tree.written.length === 0)
+    // what an earlier commit of the same command holds already (strom fetch commits each batch of images) is not again
+    const ops = tree?.uncommitted() ?? [];
+    if (!tree || tree.dryRun || ops.length === 0)
         return undefined;
     // Incremental gate: records were validated when written; here only what
     // changed since the last commit is checked, so the cost stays flat.
@@ -30,11 +32,11 @@ export function autoCommit(ctx, def) {
             problems: errors.map((f) => ({ ...(f.id ? { id: f.id } : {}), ...(f.file ? { file: f.file } : {}), message: f.message })),
         };
     }
-    const message = commitMessage(tree.written.map((o) => o.summary), `strom ${def.path.join(" ")}`);
+    const message = commitMessage(ops.map((o) => o.summary), `strom ${def.path.join(" ")}`);
     // Only the files this command wrote, plus the free-form folders the agent
     // may edit — `git add` then never has to scan the whole data/ tree.
     const written = new Set(["data/_counters.json"]);
-    for (const op of tree.written)
+    for (const op of ops)
         for (const f of op.files)
             written.add(f.path);
     for (const f of tree.opsFilesTouched())
@@ -43,6 +45,7 @@ export function autoCommit(ctx, def) {
     // commit of something else (found on Windows: strom mode committed a file of the user's) — nor by the switch itself
     const free = isArchive(tree) || def.path[0] === "mode" ? ["inputs", "output"] : ["notes", "tools", "inputs", "output"];
     tree.withTreeLock(() => tree.commit(message, [...written, ...free]));
+    tree.markCommitted();
     tree.settle();
     return undefined;
 }

package/dist/cli/execute.js

@@ -346,9 +346,9 @@ export function severalRecords(def, args) {
     return RECORD_SHOWS.has(def.path.join(" ")) && args.length > 1 && args.every(isRecordRef);
 }
 /** Required and surplus positional arguments; `fix`: the line as it is meant (parseOptions), said under a surplus one. */
-export function checkArgs(def, args, fix, program = "strom") {
+export function checkArgs(def, args, fix, program = "strom", opts = {}) {
     const declared = def.args ?? [];
-    const required = declared.filter((a) => a.required);
+    const required = declared.filter((a) => a.required && !a.unless?.some((o) => opts[o] !== undefined && opts[o] !== false));
     if (args.length < required.length) {
         const missing = required[args.length];
         throw new UsageError(`missing <${missing.name}>: ${missing.description}`, { hint: `strom help ${def.path.join(" ")}`, code: "arg.missing", params: { arg: missing.name, cmd: def.path.join(" ") }, usage: usageOf(def) });

package/dist/cli/main.js

@@ -23,7 +23,7 @@ import { prependPath } from "../runners/runner.js";
 import { shimDir } from "../commands/session.js";
 import { isAgent } from "../core/which.js";
 import { appUrlShown, noticeStromApp } from "../core/stromapp.js";
-import { lastChannelOf, pendingTransition, updateChannel } from "../core/update.js";
+import { lastChannelOf, pendingTransition, updateChannel, whatsNewUrl } from "../core/update.js";
 import { backupBefore, backupSaid } from "./backups.js";
 import { guestOf, installation, ownFolder, refreshTreeShim } from "../core/self.js";
 import { refreshGlobal } from "../agents/global.js";
@@ -133,6 +133,21 @@ function asOwnCommand(io, name, json, argv) {
     const text = (s) => asCommand(s, name, words);
     return { ...io, stdout: (s) => io.stdout(json ? asCommandJson(s, name, words) : text(s)), stderr: (s) => io.stderr(text(s)) };
 }
+/**
+ * strom --version: the version on its first line (what a script reads), then where to read what is new in it — the
+ * changelog in the research language, on the branch of the installation's channel. --json gives the version alone.
+ */
+function versionSaid(env, cwd, io, values = {}) {
+    const first = `strom ${VERSION}\n`;
+    try {
+        const lang = Context.fromOptions({ env, cwd, io, json: false, values }).uiLang();
+        return `${first}${ui(lang, "ui.update.whatsnew", { url: whatsNewUrl(VERSION, updateChannel(env), lang) })}\n`;
+    }
+    catch {
+        // no settings to read: the version alone
+        return first;
+    }
+}
 export async function main(argv, io, env, cwd) {
     const json = argv.includes("--json");
     const own = ownCommand(env);
@@ -157,7 +172,7 @@ export async function main(argv, io, env, cwd) {
         if (argv.length === 0 && io.tty && !isAgent(env) && env.STROM_NONINTERACTIVE !== "1")
             argv = ["menu"];
         if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
-            io.stdout(json ? toJson({ version: VERSION }) : `strom ${VERSION}\n`);
+            io.stdout(json ? toJson({ version: VERSION }) : versionSaid(env, cwd, io));
             return EXIT.ok;
         }
         let resolved;
@@ -185,7 +200,7 @@ export async function main(argv, io, env, cwd) {
             return EXIT.ok;
         }
         if (v.version) {
-            io.stdout(json ? toJson({ version: VERSION }) : `strom ${VERSION}\n`);
+            io.stdout(json ? toJson({ version: VERSION }) : versionSaid(env, cwd, io, v));
             return EXIT.ok;
         }
         const ctx = Context.fromOptions({ env, cwd, io, json, values: v });
@@ -337,13 +352,14 @@ export async function main(argv, io, env, cwd) {
         // several IDs to a show command of one record (person show P0001 P0002): each shown in turn, as strom show does
         const shows = severalRecords(def, args) ? match(["show"])?.def : undefined;
         if (!shows)
-            checkArgs(def, args, parsed.fix, own);
+            checkArgs(def, args, parsed.fix, own, parsed.values);
         if (def.writes && v["dry-run"])
             ctx.dryRun = true;
         const work = async () => {
             // Never write on top of data that was changed outside strom.
+            // (a command that locks only while it writes looks under the lock too: another strom may be in the middle of a write)
             if (def.writes && def.tree)
-                assertIntact(ctx.tree());
+                def.lock === "sections" ? ctx.tree().withTreeLock(() => assertIntact(ctx.tree())) : assertIntact(ctx.tree());
             let result;
             try {
                 result = await (shows ?? def).run(ctx, { args, opts: v, ...(passthrough.length ? { extra: passthrough } : {}), ...(parsed.seq ? { seq: parsed.seq } : {}) });

package/dist/cli/ui.js

@@ -227,6 +227,7 @@ export const UI = {
     "ui.tune.book.weak": "negatives on weak scans {n} of {of}",
     "ui.tune.book.requests": "requests {n}",
     "ui.tune.book.unread": "fetched and never read {n} of {of}",
+    "ui.tune.book.background": "in the background: never read {n} of {of}",
     "ui.tune.hosts": "Archives:",
     "ui.tune.host": "  {host}: sessions {sessions} · requests {requests} ({perSession} per session, {perImage} per image) · waited {wait} min · limit used up {later}×",
     "ui.tune.web": "The agent's own web tools:",
@@ -681,6 +682,7 @@ export const UI = {
     "ui.update.downloading": "Downloading strom {version}…",
     "ui.update.failed": "The update did not work: {detail}. strom stays as it was.",
     "ui.update.done": "✓ strom is updated: {previous} → {version}.",
+    "ui.update.whatsnew": "What's new: {url}",
     "ui.update.restart": "strom is updated — this menu still runs the old version. Start strom again (or the shortcut \"{shortcut}\"), and the new version is at work.",
     "ui.o.update": "update",
     "ui.o.update.new": "{version} is out (this is {current}) — tell the user; strom update installs it with their yes",

package/dist/commands/batch.js

@@ -217,7 +217,7 @@ register({
                 // one line cannot be a dry run while the others write: the whole batch is one or neither
                 if (parsed.values["dry-run"])
                     throw new UsageError("--dry-run applies to the whole batch: strom batch --dry-run …");
-                checkArgs(def, parsed.positionals, parsed.fix, "");
+                checkArgs(def, parsed.positionals, parsed.fix, "", parsed.values);
                 const before = tree.written.length;
                 const r = await def.run(ctx, { args: parsed.positionals, opts: parsed.values });
                 if (r.exitCode)

package/dist/commands/calibrate.js

@@ -164,6 +164,7 @@ function report(ctx, tree, askedKey, whoAsked) {
         b.weakNegatives ? t("ui.tune.book.weak", { n: b.weakNegatives, of: b.negatives }) : undefined,
         b.requests ? t("ui.tune.book.requests", { n: b.requests }) : undefined,
         b.unread ? t("ui.tune.book.unread", { n: b.unread, of: b.fetched }) : undefined,
+        b.background ? t("ui.tune.book.background", { n: b.background.unread, of: b.background.fetched }) : undefined,
     ]
         .filter(Boolean)
         .join(" · "));