strom-research 1.13.2-beta.8 → 1.13.2-beta.9

package/assets/lang/cs.json

@@ -382,7 +382,9 @@
   "ui.consent.connector.direct": "Pozor: jeho kód se připojuje k síti sám, mimo omezovač stromu.",
   "ui.consent.connector.unfenced": "Pozor: spouští program, který strom neohraničí ({run}) – může číst a měnit všechny soubory tohoto uživatele, spouštět jiné programy a připojit se kamkoli. Po každé změně jeho kódu se dotaz zopakuje.",
   "ui.consent.connector.terms": "Podmínky užití archivu: {terms}",
-  "ui.consent.host.unblock": "{host} nás odmítl. Povolit znovu – jen pokud archiv řekl, že je to v pořádku?",
+  "ui.consent.host.unblock": "Na {host} se nesahá (odmítl požadavky, nebo řekl, že je jeho limit vyčerpán). Zrušit to hned – jen pokud archiv řekl, že je to v pořádku?",
+  "ui.host.unblocked": "{host}: už se na něj zase smí – strom se ho bude znovu ptát, pomalu",
+  "ui.host.unblock.kept": "Nic se nezměnilo: na {host} se dál nesahá.",
   "ui.menu.otheragent": "Tentokrát mluvit s jiným agentem nebo jinde",
   "ui.o.title": "strom {version} — nástroj pro genealogický výzkum s AI agenty",
   "ui.o.rule": "Tady jsou doklady výzkumu; měnit je jen příkazy strom. Nový agent: strom guide",
@@ -490,6 +492,8 @@
   "ui.doc.innode": "strom {version} v Node {node}",
   "ui.doc.fence": "stahovače v ohrádce",
   "ui.doc.fence.net": "Node {node}: stahovače běží v ohrádce, ale síť jim zavře až Node 25 nebo novější",
+  "ui.doc.shim": "strom pro agenty",
+  "ui.doc.shim.codepage": "složka instalace má písmena mimo ASCII: hooky agentů a jejich strom přes výzkum závisí na kódové stránce konzole — složka instalace bez nich tomu předejde",
   "ui.doc.oldnode": "Node {node} je příliš starý (potřeba 22.18 nebo novější)",
   "ui.doc.missing": "chybí",
   "ui.doc.notsetup": "zatím nenastaveno",

package/assets/lang/de.json

@@ -382,7 +382,9 @@
   "ui.consent.connector.direct": "Achtung: sein Code greift selbst auf das Netz zu, am Begrenzer von strom vorbei.",
   "ui.consent.connector.unfenced": "Achtung: er startet ein Programm, das strom nicht eingrenzt ({run}) – es kann alle Dateien dieses Benutzers lesen und ändern, andere Programme starten und jede Adresse erreichen. Nach jeder Änderung seines Codes wird erneut gefragt.",
   "ui.consent.connector.terms": "Nutzungsbedingungen des Archivs: {terms}",
-  "ui.consent.host.unblock": "{host} hat uns abgewiesen. Wieder erlauben – nur wenn das Archiv gesagt hat, dass es in Ordnung ist?",
+  "ui.consent.host.unblock": "{host} wird in Ruhe gelassen (Anfragen abgewiesen, oder sein Limit ist laut ihm aufgebraucht). Jetzt aufheben – nur wenn das Archiv gesagt hat, dass es in Ordnung ist?",
+  "ui.host.unblocked": "{host}: nicht mehr in Ruhe gelassen – strom fragt wieder an, langsam",
+  "ui.host.unblock.kept": "Nichts geändert: {host} wird weiter in Ruhe gelassen.",
   "ui.menu.otheragent": "Diesmal mit einem anderen Agenten oder woanders sprechen",
   "ui.o.title": "strom {version} — genealogische Forschung mit KI-Agenten",
   "ui.o.rule": "Hier liegen die Belege der Forschung; ändern NUR mit strom-Befehlen. Neuer Agent: strom guide",
@@ -490,6 +492,8 @@
   "ui.doc.innode": "strom {version} in Node {node}",
   "ui.doc.fence": "Downloader eingegrenzt",
   "ui.doc.fence.net": "Node {node}: Downloader laufen eingegrenzt, aber erst Node 25 oder neuer hält sie auch vom Netz fern",
+  "ui.doc.shim": "strom für die Agenten",
+  "ui.doc.shim.codepage": "der Ordner der Installation hat Buchstaben außerhalb von ASCII: die Hooks der Agenten und ihr strom über die Forschung hängen von der Codepage der Konsole ab — ein Installationsordner ohne sie vermeidet das",
   "ui.doc.oldnode": "Node {node} ist zu alt (nötig: 22.18 oder neuer)",
   "ui.doc.missing": "fehlt",
   "ui.doc.notsetup": "noch nicht eingerichtet",

package/assets/method/enrich.md

@@ -20,6 +20,10 @@ recorded, also in vain (`strom search add … --method web|catalog|full-text`).
 - **Within the brief's budget of pages** fetched or read; then record what
   was searched and close. Printed pages go to the user's model for print
   where you can hand work to one (the brief names it) — never handwriting.
+  The budget is the task's whole: pages through a connector count in it.
+  More pages of one site than the web rule allows go through its connector,
+  built right away when the task needs that site (`strom connector new
+  <site>`, then `strom fetch`).
 - **The history of a place once in a research**: what is written of it (the
   brief says) is reused, never searched again.
 - **Read the source itself** — the page, the scan. A snippet, an OCR line,

package/dist/agents/files.js

@@ -19,10 +19,12 @@ import { CHROME_ALLOW, CHROME_DENY, chromeDomain } from "../core/browser.js";
 import { claudeScanReader, opencodeScanReader, SCAN_READER, scanReaderModel, treeReading } from "./scanreader.js";
 import { claudeWebHooks, grokWebHooks, webRuleLines } from "../core/web.js";
 import { claudeDelegateHooks } from "../core/delegate.js";
-import { writeShim } from "../core/self.js";
+import { powershellUtf8Rule, putShim } from "../core/self.js";
 export const MARKER = "<!-- strom: generated above this line (strom agents sync); your own notes below are kept -->";
-function agentsMd(tree) {
+export function agentsMd(tree, platform = process.platform) {
     const lang = langName(tree.config.lang);
+    // (Windows only: written on the computer the agent works on, as its other files)
+    const ps = powershellUtf8Rule("`", platform);
     // the Strom app's address as strom app opens it now (the beta its beta, strom.app.url where it says another)
     const app = agentAppUrl(tree.env);
     return `# Family research: ${tree.config.name}
@@ -56,7 +58,7 @@ the researcher; \`strom\` is your only way to read and change the research.
    number) — never read a big file in pieces.
 7. Run strom commands on their own — no pipes (\`| head\`, \`| grep\`): output is
    already short, listings take \`--limit\` and \`--page\`, and piped commands may
-   be refused by your permissions.
+   be refused by your permissions.${ps ? `\n   ${ps}` : ""}
 8. Other agents may work on this tree too (Claude Code, Codex, Antigravity,
    OpenCode, Grok — the user's choice). \`strom\` shows who is working now; never take a task
    another one has started.
@@ -400,7 +402,11 @@ export const GROK_HOOKS = path.join(".grok", "hooks", "strom.json");
 /** Claude Code's subagent for reading scans, in the tree. */
 export const CLAUDE_SCAN_READER = path.join(".claude", "agents", `${SCAN_READER}.md`);
 export const AGENT_FILES = ["AGENTS.md", "CLAUDE.md", path.join(".claude", "settings.json"), CLAUDE_SCAN_READER, "opencode.json", path.join(".grok", "config.toml"), path.join(".grok", "rules", "strom.md"), GROK_HOOKS];
-export function syncAgentFiles(tree) {
+/**
+ * strom's files of the agents written for the tree (only what changed: the files written, to commit). `said.shim`: the
+ * shim in .strom/bin was written now (never committed: not among the files).
+ */
+export function syncAgentFiles(tree, said = {}) {
     // an archive: no agent works on it, and nothing of one shows in its folder (Milan's decision, 2026-10-03) — strom's own
     // files of the agents go (what a person wrote in them stays); research switched on writes them again
     if (isArchive(tree))
@@ -433,7 +439,7 @@ export function syncAgentFiles(tree) {
     // the strom the agent hooks name (the tree's .strom/bin, never committed) — there also for a conversation strom did not start
     if (!tree.dryRun) {
         try {
-            writeShim(tree.root);
+            said.shim = putShim(tree.root).changed.length > 0;
         }
         catch {
             // a hook that finds no strom lets the call go

package/dist/brief/brief.js

@@ -1090,7 +1090,8 @@ export function buildBrief(tree, opts) {
             first: true,
             pointer: "strom find <place>",
             text: [
-                `## Beyond the registers: about ${ENRICH_PAGES} pages fetched or read, then record the searches and close`,
+                `## Beyond the registers: about ${ENRICH_PAGES} pages fetched or read in all (the task's whole budget, strom fetch too), then record the searches and close`,
+                `- over ${Math.min(WEB_SOFT, new Settings(tree.env, {}).webPerHost(tree.config))} pages of one site: through its connector, built right away when the task needs that site (strom connector new <site> --url https://<host>/, then strom fetch)`,
                 print ? `- print: a subagent on ${print} (model.text), never handwriting` : "",
                 written.length ? `- of the places, written already (reuse): ${written.join(" · ")}` : "",
             ].filter(Boolean).join("\n"),

package/dist/cli/execute.js

@@ -255,7 +255,19 @@ export function parseOptions(def, rest, program = "strom") {
     const cmd = `${program} ${def.path.join(" ")}`.trim();
     try {
         const r = parseArgs({ args: rest, options, allowPositionals: true, strict: true, tokens: true });
-        return foldSurplus(def, defs, r.tokens, r.values, r.positionals);
+        const folded = foldSurplus(def, defs, r.tokens, r.values, r.positionals);
+        // where the values of a repeatable option were typed among the arguments (a command of several arguments only)
+        if (!def.args?.some((a) => a.variadic))
+            return folded;
+        const after = {};
+        let seen = 0;
+        for (const t of r.tokens) {
+            if (t.kind === "positional")
+                seen++;
+            else if (t.kind === "option" && defs.find((d) => d.name === t.name)?.multiple)
+                (after[t.name] ??= []).push(seen);
+        }
+        return { ...folded, after };
     }
     catch (err) {
         const e = err;
@@ -273,6 +285,12 @@ export function parseOptions(def, rest, program = "strom") {
                     hint: `a status is a fact's (E…) only, never a name's or a family's: strom cite E… S… --status probable|proven, strom event edit E… --status …`,
                     code: "option.unknown", hintCode: "option.unknown.status", params: { opt, cmd, options: own.join(" "), path: def.path.join(" ") }, usage,
                 });
+            // a name agents type meaning another option (--timeout for --minutes): that one, with what it takes
+            const meant = optionsOf(def).find((o) => o.mistaken?.includes(opt.replace(/^-+/u, "")));
+            if (meant) {
+                const near = `--${meant.name}${meant.value ? ` ${meant.value}` : ""}`;
+                throw new UsageError(`unknown option ${opt} for ${cmd}`, { hint: `meant: ${near} — ${meant.description}`, code: "option.near", params: { opt, cmd, near }, usage });
+            }
             const near = suggest(opt, optionsOf(def).filter((o) => !o.hidden).map((o) => `--${o.name}`));
             const help = `strom help${def.path.length ? ` ${def.path.join(" ")}` : ""}`;
             throw new UsageError(`unknown option ${opt} for ${cmd}`, {

package/dist/cli/main.js

@@ -20,7 +20,7 @@ import { isAgent } from "../core/which.js";
 import { appUrlShown, noticeStromApp } from "../core/stromapp.js";
 import { lastChannelOf, pendingTransition, updateChannel } from "../core/update.js";
 import { backupBefore, backupSaid } from "./backups.js";
-import { installation } from "../core/self.js";
+import { installation, refreshTreeShim } from "../core/self.js";
 import { refreshGlobal } from "../agents/global.js";
 import { expandFromLine, refreshLinks } from "../core/links.js";
 import { clockLine, FINISH_LINE, finishLimitLine, finishOf } from "../core/clock.js";
@@ -274,6 +274,9 @@ export async function main(argv, io, env, cwd) {
                 catch {
                     // another computer's seal, a tree at work: its bridge's start settles it
                 }
+                // …and the strom its agents' hooks and conversations start (.strom/bin) leads to this one — an older strom's, or one
+                // whose mark went with the program folder an update replaced; only where a research has one, never an archive
+                refreshTreeShim(k.root, env);
                 // the bridges the Strom app follows go on with this version at their addresses: one of an older strom started
                 // again, one the installer ended to replace the program (Windows: its files are held while it runs) back
                 try {
@@ -301,7 +304,7 @@ export async function main(argv, io, env, cwd) {
                 assertIntact(ctx.tree());
             let result;
             try {
-                result = await (shows ?? def).run(ctx, { args, opts: v, ...(passthrough.length ? { extra: passthrough } : {}) });
+                result = await (shows ?? def).run(ctx, { args, opts: v, ...(passthrough.length ? { extra: passthrough } : {}), ...(parsed.after ? { after: parsed.after } : {}) });
             }
             catch (err) {
                 // A writing command is a transaction: on failure nothing it wrote remains.

package/dist/cli/ui.js

@@ -44,7 +44,9 @@ export const UI = {
     "ui.consent.connector.direct": "Warning: its code reaches the network itself, past strom's limiter.",
     "ui.consent.connector.unfenced": "Warning: it runs a program strom does not fence in ({run}) — it may read and change any file of this user, start other programs and reach any address. Asked again after every change of its code.",
     "ui.consent.connector.terms": "The archive's terms of use: {terms}",
-    "ui.consent.host.unblock": "{host} refused us. Allow it again — only if the archive said it is fine?",
+    "ui.consent.host.unblock": "{host} is left alone (it refused the requests, or said its limit is used up). Lift it now — only if the archive said it is fine?",
+    "ui.host.unblocked": "{host}: no longer left alone — strom will ask it again, slowly",
+    "ui.host.unblock.kept": "Nothing changed: {host} is still left alone.",
     "ui.consent.elsewhere.connector": "Run the downloader \"{name}\"? An agent asks for it from outside the research's folder ({cwd}).",
     "ui.consent.elsewhere.run": "Start the agent working alone on the research \"{tree}\"? An agent asks for it from outside the research's folder ({cwd}); the work costs money.",
     "ui.consent.connectors.off": "Let downloaders run without asking first?",
@@ -463,6 +465,8 @@ export const UI = {
     "ui.doc.innode": "strom {version} in Node {node}",
     "ui.doc.fence": "downloaders fenced in",
     "ui.doc.fence.net": "Node {node}: downloaders run fenced in, but only Node 25 or newer also keeps them off the network",
+    "ui.doc.shim": "strom for the agents",
+    "ui.doc.shim.codepage": "the installation's folder has letters outside ASCII: the agents' hooks and their strom through the research rely on the console's code page — an installation folder without them avoids it",
     "ui.doc.oldnode": "Node {node} is too old (22.18 or newer)",
     "ui.doc.missing": "missing",
     "ui.doc.notsetup": "not set up yet",

package/dist/commands/connectors.js

@@ -657,10 +657,13 @@ register({
         // (strom connector discard) — in the research's own .strom, never in the plugin's folder
         const tree = ctx.hasTree() ? ctx.tree() : undefined;
         const session = tree ? currentSession(tree, ctx.env) : undefined;
+        // whether its agent may take it away again (strom connector discard), else it is the user's to remove
+        let discardable = false;
         if (tree) {
             const marker = madeMarker(tree.root, name);
             const folder = folderId(dir);
             if (session && folder) {
+                discardable = true;
                 const made = { session: session.id, tree: tree.config.id, ...(session.research ? { research: session.research } : {}), at: new Date().toISOString(), folder };
                 fs.mkdirSync(path.dirname(marker), { recursive: true });
                 fs.writeFileSync(marker, JSON.stringify(made) + "\n");
@@ -671,7 +674,7 @@ register({
         const rel = ctx.display(dir);
         return {
             text: lines(`connector ${name} started in ${rel}`, "", "next:", `  1. your agent reads ${path.join(rel, "DISCOVERY.md")} and the contract (README.md one folder up),`, "     and finds out what the portal allows — before any code", "  2. it writes connector.json (policy) and connector.ts, and tests with a few requests:", `     strom connector test ${name} --find "<place>"`, consentRequired(ctx.env) ? `  3. the first test needs your consent, in your terminal: strom allow connector ${name}` : undefined, ofSite
-                ? `\nnote: the connector ${ofSite} is here already for ${webDomain(url.hostname)} (its hosts: ${listConnectors(shared(ctx)).find((c) => c.name === ofSite)?.manifest.hosts.join(", ") ?? "?"}) — more pages of that site go through it (strom connector show ${ofSite}); keep this one only for another portal of the site, else take it away: strom connector discard ${name}`
+                ? `\nnote: the connector ${ofSite} is here already for ${webDomain(url.hostname)} (its hosts: ${listConnectors(shared(ctx)).find((c) => c.name === ofSite)?.manifest.hosts.join(", ") ?? "?"}) — more pages of that site go through it (strom connector show ${ofSite}); keep this one only for another portal of the site, else take it away: ${discardable ? `strom connector discard ${name}` : `the user, in their terminal: strom connector remove ${name}`}`
                 : undefined),
             data: { name, dir, ...(ofSite ? { site: { domain: webDomain(url.hostname), connector: ofSite } } : {}) },
         };
@@ -1137,7 +1140,7 @@ register({
     args: [{ name: "host", description: "e.g. digi.example.org", required: true }],
     options: [
         { name: "revoke", type: "boolean", description: "take the consent back" },
-        { name: "unblock", type: "boolean", description: "lift a refusal (401/403) early — only after the archive said it is fine" },
+        { name: "unblock", type: "boolean", description: "lift a refusal (401/403), or a limit the host said is used up, early — only after the archive said it is fine" },
         { name: "pace", type: "string", value: "<seconds|auto>", description: `your own pause between two requests to the host (at least ${MIN_INTERVAL_MS / 1000} s); auto: the service's again` },
         { name: "per-hour", type: "string", value: "<n|none|auto>", description: "your own hourly cap for the host; none: no cap; auto: the service's again (strom sets none by itself)" },
     ],
@@ -1176,7 +1179,7 @@ register({
             const now = paceAt(ctx, host, c);
             return { text: `${host}: ${paceText(now)}${s.own ? " — yours" : " — the service's again"}`, data: { host, pace: { minIntervalMs: now.minIntervalMs, perHour: Number.isFinite(now.perHour) ? now.perHour : null }, own: s.own ?? null } };
         }
-        const how = ctx.requireHuman(`${opts.revoke ? "Take back" : opts.unblock ? "Lift the refusal of" : "Allow"} automated access to ${host}?`, `strom allow host ${host}${opts.revoke ? " --revoke" : opts.unblock ? " --unblock" : ""}`, `host:${host}`, ui(lang, opts.revoke ? "ui.consent.host.revoke" : opts.unblock ? "ui.consent.host.unblock" : "ui.consent.host", { host }));
+        const how = ctx.requireHuman(`${opts.revoke ? "Take back" : opts.unblock ? "Lift the refusal or the used-up limit of" : "Allow"} automated access to ${host}?`, `strom allow host ${host}${opts.revoke ? " --revoke" : opts.unblock ? " --unblock" : ""}`, `host:${host}`, ui(lang, opts.revoke ? "ui.consent.host.revoke" : opts.unblock ? "ui.consent.host.unblock" : "ui.consent.host", { host }));
         const all = loadConsents(ctx.env);
         if (opts.revoke) {
             delete all.hosts[host];
@@ -1184,10 +1187,11 @@ register({
             return { text: `${host}: consent taken back — no connector reaches it now`, data: { host, allowed: false } };
         }
         if (opts.unblock) {
-            if (how === "terminal" && !(await ctx.confirm(`${host} refused us. Lift it now (only if the archive said it is fine)?`, false)))
-                return { text: "nothing changed" };
+            // the person's question and answer, in their language (a refusal, or a limit the host said is used up)
+            if (how === "terminal" && !(await ctx.confirm(ui(lang, "ui.consent.host.unblock", { host }), false)))
+                return { text: ui(lang, "ui.host.unblock.kept", { host }) };
             clearBlock(netDir(ctx), host);
-            return { text: `${host}: the refusal is lifted — strom will ask it again, slowly`, data: { host, unblocked: true } };
+            return { text: ui(lang, "ui.host.unblocked", { host }), data: { host, unblocked: true } };
         }
         const c = listConnectors(ctx.settings.shared()?.value).find((x) => x.manifest.hosts.some((h) => hostAllowed(host, [h])));
         const ok = await askHost(ctx, host, c, how === "window");
@@ -1570,10 +1574,16 @@ async function fetchWith(ctx, c, request, recordset) {
         throw new UsageError(`${c.manifest.title} does not allow automated download (its terms, as the connector read them)`, {
             hint: `the user saves them by hand: strom task wait T… --images B…:${request.cmd === "part" ? request.image : runs(request.images)} --on "<the book, its link, which images>" (the link: strom fetch ${c.name} ${request.book} --list)`,
         });
+    // an archive marked manual (browser only) refuses downloads, not finding books in its catalogue and their links;
+    // one marked forbidden refuses every automated request
     const repo = forbiddenBy(ctx, c);
-    if (repo)
-        throw new UsageError(`${repo.id} ${repo.name} is marked automation ${repo.automation} in this tree — no downloads through a connector`, {
-            hint: `strom repo show ${repo.id} — change it only if the archive allows it: strom repo edit ${repo.id} --automation allowed`,
+    if (repo?.automation === "forbidden")
+        throw new UsageError(`${repo.id} ${repo.name} is marked automation forbidden in this tree — no requests through a connector`, {
+            hint: `strom repo show ${repo.id} — the user saves what the research needs by hand`,
+        });
+    if (repo && (request.cmd === "fetch" || request.cmd === "part"))
+        throw new UsageError(`${repo.id} ${repo.name} is marked automation manual in this tree — no images downloaded through a connector`, {
+            hint: `the user saves them by hand: strom task wait T… --images B…:${request.cmd === "part" ? request.image : runs(request.images)} --on "<the book, its link, which images>" (finding books and their links still works — the link: strom fetch ${c.name} ${request.book} --list)`,
         });
     if (recordset && request.cmd === "fetch") {
         // what is registered already is not asked for again (a part of an image is not the image)

package/dist/commands/grep.js

@@ -17,11 +17,12 @@ register({
     description: "Searches the text files of inputs/ and notes/ (output/ too with --in output or --in all) — never data/ (the\n" +
         "records: strom find), .git or anything outside the tree, never through a symbolic link; images, PDFs and other\n" +
         "binary files are left out. A text is found as it reads: in any case, with accents or without (mlynar finds\n" +
-        "Mlynář), a run of spaces as one. Several texts: a line with any of them (spellings of one name). --regex: a\n" +
+        "Mlynář), a run of spaces as one. Several texts: a line with ANY of them (spellings of one name) by default;\n" +
+        "--all: a line with EVERY one of them, in any order (a year and a name: 1803 \"Pag. 11\"). --regex: a\n" +
         "JavaScript regular expression, in any case, Unicode (\\p{L} a letter of any script). A line found is shown\n" +
         "file:line: text, a line round it (--context) file-line- text; a long line is cut round its find.\n" +
         `Listings are paged (--limit, --page); the search stops at ${GREP_MAX_HITS} lines and says so.`,
-    args: [{ name: "text", description: "what to find (accents and capitals optional); several = a line with any of them", required: true, variadic: true }],
+    args: [{ name: "text", description: "what to find (accents and capitals optional); several = a line with any of them (--all: with every one)", required: true, variadic: true }],
     options: [
         {
             name: "in",
@@ -31,12 +32,14 @@ register({
             description: `${GREP_FOLDERS.join(" | ")} | all | a file or folder inside them | an input I… (default: ${GREP_DEFAULT.join(" and ")})`,
         },
         { name: "context", type: "string", value: "<n>", description: `lines shown before and after each line found (0–${MAX_CONTEXT}, default 0)` },
+        { name: "all", type: "boolean", description: "several texts: a line with every one of them (default: with any)" },
         { name: "regex", type: "boolean", description: "the text is a regular expression (JavaScript, in any case, Unicode)" },
         { name: "files", type: "boolean", description: "only the files and how many lines each has found" },
     ],
     examples: [
         'strom grep "mlynář"',
         "strom grep Novák Nowak --in inputs --context 2",
+        'strom grep 1803 "Pag. 11" --all --in I0002',
         'strom grep "Lhota" --in inputs/rodokmen.md --context 3',
         'strom grep "Nov[aá]k(ov[aá])?" --regex --in notes',
         "strom grep Novák --in I0002 --files",
@@ -64,7 +67,7 @@ register({
             throw new UsageError(error, { hint: `strom grep ${patterns.map(shellArg).join(" ")} --in ${GREP_FOLDERS.join("|")}|all` });
         let match;
         try {
-            match = grepMatcher(patterns, regex);
+            match = grepMatcher(patterns, regex, !!opts.all);
         }
         catch (e) {
             throw new UsageError(`not a regular expression: ${e.message}`, { hint: "strom grep <text> — without --regex the text is found as it reads" });
@@ -77,6 +80,7 @@ register({
             ...wanted.map((w) => `--in ${shellArg(w)}`),
             ...(context ? [`--context ${context}`] : []),
             ...(regex ? ["--regex"] : []),
+            ...(opts.all ? ["--all"] : []),
             ...(opts.files ? ["--files"] : []),
         ].join(" ");
         const tooBig = found.tooBig.length ? `left out, over 64 MB: ${found.tooBig.join(", ")}` : undefined;
@@ -86,7 +90,9 @@ register({
                 data: { total: 0, searched: found.searched, hits: [], ...(found.tooBig.length ? { tooBig: found.tooBig } : {}) },
             };
         const total = `${found.hits.length}${found.capped ? "+" : ""}`;
-        const head = `${total} line(s) in ${found.counts.size} of ${found.searched} text file(s) of ${where}${found.capped ? ` — stopped at ${GREP_MAX_HITS}: a narrower text or --in` : ""}`;
+        // several texts: whether a line has any or every one of them, said (agents expect every one)
+        const mode = patterns.length > 1 ? (opts.all ? " with every text" : " with any of the texts (every one: --all)") : "";
+        const head = `${total} line(s)${mode} in ${found.counts.size} of ${found.searched} text file(s) of ${where}${found.capped ? ` — stopped at ${GREP_MAX_HITS}: a narrower text or --in` : ""}`;
         if (opts.files) {
             const files = [...found.counts].map(([file, n]) => ({ file, lines: n }));
             const page = paginate(files, ctx.limit, ctx.page);

package/dist/commands/guide.js

@@ -5,8 +5,10 @@
 import { langName } from "../core/lang.js";
 import { appSite } from "../core/stromapp.js";
 import { WEB_PER_HOST, webRuleLines } from "../core/web.js";
+import { powershellUtf8Rule } from "../core/self.js";
 /** The guide; appUrl: the Strom app's address it names — the one `strom app` opens (appUrlShown); perHost: web.perHost here. */
-export function guideText(lang, appUrl, perHost = WEB_PER_HOST) {
+export function guideText(lang, appUrl, perHost = WEB_PER_HOST, platform = process.platform) {
+    const ps = powershellUtf8Rule("", platform);
     const language = lang
         ? `The research language of this tree is ${langName(lang)} (${lang}): talk to the user in ${langName(lang)} and write notes, tasks and stories in ${langName(lang)}. Keep transcripts of records in their original language.`
         : "Talk to the user in their language. Set it as the research language: strom setup --lang <code> (cs, en, de, pl, …).";
@@ -231,7 +233,7 @@ THE STROM APP — where the user sees the result
 
 OUTPUT AND ERRORS
 - One line per record, IDs first. Read the text; add --json only to parse.
-- Listings are paged (--limit, --page). Do not pipe strom output.
+- Listings are paged (--limit, --page). Do not pipe strom output.${ps ? `\n- ${ps}` : ""}
 - People can be named by ID (P0001) or name ("Jan Novák", no diacritics ok).
   An ambiguous name lists candidates (exit 2) — then use the ID.
 - Every error ends with "→ <what to run next>".

package/dist/commands/media.js

@@ -9,7 +9,7 @@ import { register } from "../cli/registry.js";
 import { lines, moreLine, paginate, runs, shellArg, table, truncate } from "../cli/format.js";
 import { UsageError } from "../core/errors.js";
 import { makeNote } from "../core/actions.js";
-import { clipText, collectFiles, coveringPart, fileSha256, findImage, imageNumbers, imageOfRef, inboxFolders, inputPath, isWhole, mimeOf, onlyParts, otherCopies, parseImageList, regionText, sharperPart, storeShared, wholeSizeOf } from "../core/media.js";
+import { clipText, collectFiles, coveringPart, fileSha256, findImage, imageNumbers, imageOfRef, imageRange, inboxFolders, inputPath, isWhole, mimeOf, onlyParts, otherCopies, parseImageList, regionText, sharperPart, storeShared, wholeSizeOf } from "../core/media.js";
 import { create, normId, requireRecord, update } from "../core/records.js";
 import { imageSizeOfFile } from "../image/index.js";
 import { imageOf, pageOf } from "../core/calibration.js";
@@ -305,11 +305,46 @@ function refsText(wants) {
     }
     return out.join(" ");
 }
+/** A number of an image or page after a record set (B0001 --page 112 113): it belongs to the image named before it. */
+const isNumberArg = (a) => /^\d+(?:\s*(?:[-–]|\.\.\.?)\s*\d+)?(?:\s*,\s*\d+(?:\s*(?:[-–]|\.\.\.?)\s*\d+)?)*$/u.test(a.trim());
+/**
+ * Crops typed among several images (B0001:2 --crop A B0001:3 --crop B): each crop is of the image named before it —
+ * never every crop of every image (N0275: 16 views where 4 were meant). Crops all after the last image, or of one
+ * image, are of every image as always (undefined).
+ */
+function cropGroups(args, opts, after) {
+    const crops = opts.crop === undefined ? [] : Array.isArray(opts.crop) ? opts.crop.map(String) : [String(opts.crop)];
+    if (!crops.length || !after || after.length !== crops.length)
+        return undefined;
+    const refs = args.map((a, i) => (isNumberArg(a) ? -1 : i)).filter((i) => i >= 0);
+    if (refs.length < 2 || after.every((n) => n >= args.length))
+        return undefined;
+    const form = `strom media view ${args[refs[0]]} --crop ${crops[0]} ${args[refs[1]]} --crop …`;
+    if (after.some((n) => n === 0))
+        throw new UsageError("a --crop before any image: each --crop is of the image named before it", {
+            hint: `${form} (the same crops of every image: all of them after the last image)`,
+            code: "view.crop-first",
+        });
+    const groups = refs.map((r, k) => ({ args: args.slice(r, refs[k + 1] ?? args.length), crops: [] }));
+    crops.forEach((c, i) => {
+        // the image named last before it (a number after a record set is its page or image)
+        let k = refs.length - 1;
+        while (k > 0 && refs[k] >= after[i])
+            k--;
+        groups[k].crops.push(c);
+    });
+    const bare = groups.find((g) => !g.crops.length);
+    if (bare)
+        throw new UsageError(`${bare.args[0]} has no --crop of its own: each --crop is of the image named before it`, {
+            hint: `${form} (the same crops of every image: all of them after the last image)`,
+            code: "view.crop-missing",
+        });
+    return groups;
+}
 /** The images a call names, at most VIEW_MAX_IMAGES and `maxViews` views of them; images not registered said. */
-function resolveTargets(tree, shared, all, args, opts, parts, maxViews = VIEW_MAX_VIEWS) {
-    const numbers = (a) => /^\d+(?:\s*[-–]\s*\d+)?(?:\s*,\s*\d+(?:\s*[-–]\s*\d+)?)*$/u.test(a.trim());
-    const nums = args.filter(numbers);
-    const refs = args.filter((a) => !numbers(a)).map((a) => a.trim());
+function resolveTargets(tree, shared, all, args, opts, parts, maxViews = VIEW_MAX_VIEWS, several = false) {
+    const nums = args.filter(isNumberArg);
+    const refs = args.filter((a) => !isNumberArg(a)).map((a) => a.trim());
     const pages = listOf(opts.page);
     const images = listOf(opts.image);
     if (pages.length && images.length)
@@ -320,6 +355,10 @@ function resolveTargets(tree, shared, all, args, opts, parts, maxViews = VIEW_MA
     const pageList = pages.length ? [...pages, ...nums] : [];
     const imageList = pages.length ? [] : [...images, ...nums];
     const list = (s, what) => {
+        // a range from the higher number, or of hundreds of images: said as such
+        for (const p of s.join(",").split(","))
+            if (/^\s*\d+\s*(?:[-–]|\.\.\.?)\s*\d+\s*$/u.test(p))
+                imageRange(p.trim(), what === "images" ? "image" : what);
         const n = parseImageList(s.join(","));
         if (n)
             return n;
@@ -377,7 +416,7 @@ function resolveTargets(tree, shared, all, args, opts, parts, maxViews = VIEW_MA
             const parts = onlyParts(all, w.b.id, image);
             const m = parts.length > 1 && (opts.crop !== undefined || opts.half !== undefined || opts.split !== undefined) ? findImage(all, w.b.id, image) : imageOfRef(all, w.b.id, image);
             if (!m) {
-                if (wants.length === 1)
+                if (wants.length === 1 && !several)
                     throw new UsageError(`image ${image} of ${w.b.id} is not registered`, { hint: `strom media list --recordset ${w.b.id} · strom media add <files> --recordset ${w.b.id}` });
                 missing.push(`${w.b.id}:${image}`);
                 continue;
@@ -393,7 +432,7 @@ function resolveTargets(tree, shared, all, args, opts, parts, maxViews = VIEW_MA
         seen.add(t.key);
         targets.push(t);
     }
-    if (!targets.length) {
+    if (!targets.length && !several) {
         const b = missing[0].split(":")[0];
         throw new UsageError(`none of these images is registered: ${missing.join(", ")}`, { hint: `strom media list --recordset ${b} · strom media add <files> --recordset ${b}` });
     }
@@ -726,7 +765,7 @@ register({
     path: ["media", "view"],
     summary: "Make views of images to look at: a crop, a half page, enlarged, more contrast, a grid — several in one call",
     group: "sources",
-    sheet: `at most ${VIEW_MAX_IMAGES} images a call; several crops of an image: --crop … --crop … (no loop); a whole view finds, only a crop is read; a book read through: strom read`,
+    sheet: `at most ${VIEW_MAX_IMAGES} images a call; several crops of an image: --crop … --crop … (no loop), of each image: IMG --crop … IMG --crop …; a whole view finds, only a crop is read; a book read through: strom read`,
     tree: true,
     description: `Writes the views to .strom/views/ and prints their paths: open those files with your image reader. A whole image\n` +
         `is at most ${OVERVIEW_MAX} px on the long side, enough to find an entry; a half, a crop and the parts of --split at most\n` +
@@ -737,11 +776,13 @@ register({
         "Several views in one call, then open all the files it lists together: several images (B0001:57 B0001:58, a range\n" +
         "B0001:57-60, B0001 --page 112 113), several parts of each (--half left --half right; --half both = the two pages\n" +
         "of a double page overlapping at the gutter, where they are sharper than one view of it, else the image whole;\n" +
-        "--crop repeated; --split 2x3 = a grid of overlapping parts), each view with its image, page and --clip. At most\n" +
+        "--crop repeated; --split 2x3 = a grid of overlapping parts), each view with its image, page and --clip. A --crop\n" +
+        "typed after an image among others is of that image alone (B0001:2 --crop … B0001:7 --crop …); crops after the last\n" +
+        "image are of every image. At most\n" +
         `${VIEW_MAX_IMAGES} images and ${VIEW_MAX_VIEWS} views in one call: every view stays in the context that opens it.`,
     args: [{ name: "image", description: "M0012, B0001:57 (record set:image), a range B0001:57-60, B0001 with --page, or an input I0002; several = several images", required: true, variadic: true }],
     options: [
-        { name: "crop", type: "string", multiple: true, value: "<x,y,w,h>", description: "part of the image: fractions (0.1,0.35,0.4,0.2) or pixels; repeated = several parts" },
+        { name: "crop", type: "string", multiple: true, value: "<x,y,w,h>", description: "part of the image: fractions (0.1,0.35,0.4,0.2) or pixels; repeated = several parts; after one image of several: of that image alone" },
         { name: "half", type: "string", multiple: true, value: "<side>", description: "left or right page of a double page (top, bottom); both = the two pages, overlapping at the gutter" },
         { name: "split", type: "string", value: "<c>x<r>", description: "the image (or each half or crop) as a grid of overlapping parts, e.g. 2x3" },
         { name: "scale", type: "string", value: "<f>", description: "size of the result: 2 = twice the original pixels" },
@@ -750,7 +791,7 @@ register({
         { name: "grey", type: "boolean", description: "greyscale" },
         { name: "grid", type: "boolean", description: "overlay a grid of tenths with labels, to point at a place" },
         { name: "rotate", type: "string", value: "<deg>", description: "90, 180 or 270" },
-        { name: "image", type: "string", multiple: true, value: "<n>", description: "image number(s) with a record set ID: 57, 57-60" },
+        { name: "image", type: "string", multiple: true, value: "<n>", description: "image number(s) with a record set ID: 57, 57-60, 57..60" },
         { name: "page", type: "string", multiple: true, value: "<n>", description: "page(s) or folio(s), with a calibrated record set ID: 112, 112 113, 112-115" },
         { name: "png", type: "boolean", description: "lossless PNG instead of JPEG" },
     ],
@@ -761,13 +802,15 @@ register({
         "strom media view B0001 --page 112",
         "strom media view B0001:1-3 --half both",
         "strom media view B0001:2 --crop 0.05,0.10,0.45,0.30 --crop 0.05,0.40,0.45,0.30",
+        "strom media view B0001:2 --crop 0.05,0.10,0.45,0.30 B0001:3 --crop 0.50,0.60,0.45,0.20",
         "strom media view B0001 --page 112 113 --split 2x2",
     ],
-    run(ctx, { args, opts }) {
+    run(ctx, { args, opts, after }) {
         const tree = ctx.tree();
         const shared = sharedDir(ctx);
         const all = tree.list("media");
         const parts = viewParts(opts);
+        const groups = cropGroups(args, opts, after?.crop);
         // a whole image to find the entry on; a part of it (a half, a crop, a grid's part) as big as the model takes it
         const own = agentViewSizes(ctx, tree);
         // what strom tuned for this agent and model (core/tune.ts) — as at the start of the session at work: the numbers
@@ -775,7 +818,33 @@ register({
         const since = currentSession(tree, ctx.env)?.started;
         const tuned = treeTuning(tree, ctx.settings);
         const reading = readingOf(ctx.settings.config, own.key, { since, on: tuningOn(ctx.settings), root: tree.root });
-        const { targets, missing } = resolveTargets(tree, shared, all, args, opts, parts, reading.viewsPerCall);
+        // each image with its own crops (cropGroups), else every part of every image
+        const partsOf = new Map();
+        let targets = [];
+        let missing = [];
+        if (!groups)
+            ({ targets, missing } = resolveTargets(tree, shared, all, args, opts, parts, reading.viewsPerCall));
+        else {
+            for (const g of groups) {
+                const own = { ...opts, crop: g.crops };
+                const gp = viewParts(own);
+                const r = resolveTargets(tree, shared, all, g.args, own, gp, reading.viewsPerCall, true);
+                for (const t of r.targets)
+                    partsOf.set(t, gp);
+                targets.push(...r.targets);
+                missing.push(...r.missing);
+            }
+            if (!targets.length) {
+                const b = missing[0].split(":")[0];
+                throw new UsageError(`none of these images is registered: ${missing.join(", ")}`, { hint: `strom media list --recordset ${b} · strom media add <files> --recordset ${b}` });
+            }
+            const views = targets.reduce((n, t) => n + partsOf.get(t).reduce((m, p) => m + (p.both ? 2 : 1) * (p.split ? p.split[0] * p.split[1] : 1), 0), 0);
+            if (targets.length > VIEW_MAX_IMAGES || views > reading.viewsPerCall)
+                throw new UsageError(`${targets.length} image(s), ${views} views — at most ${VIEW_MAX_IMAGES} images and ${reading.viewsPerCall} views in one call: every view stays in the context that opens it`, {
+                    hint: "fewer images now — write down what they gave before the next call",
+                });
+        }
+        const partsFor = (t) => partsOf.get(t) ?? parts;
         const spec = viewSpec({ ...opts, half: undefined, crop: undefined });
         // a book read worse than the others: its views bigger (never above what the model takes)
         const sizesOf = (t) => bookViewSizes(own, tuned, t.media?.recordset, since);
@@ -785,7 +854,7 @@ register({
         // where the size came from, for the record of the views (core/metrics.ts)
         const capFromOf = (t) => (spec.max !== undefined || spec.scale !== undefined ? "option" : sizesOf(t).tuned ? `tuned:${sizesOf(t).tuned}` : own.calibrated ? "calibrated" : "default");
         // the old call: one image, one view — said as it always was
-        if (targets.length === 1 && !missing.length && parts.length === 1 && !parts[0].both && !parts[0].split) {
+        if (!groups && targets.length === 1 && !missing.length && parts.length === 1 && !parts[0].both && !parts[0].split) {
             const t = targets[0];
             const r = oneView(ctx, tree, shared, all, t, { ...spec, max: maxOf(parts[0], t), half: parts[0].half, crop: parts[0].crop }, { capFrom: capFromOf(t) }, noSharperOf(t));
             return {
@@ -799,7 +868,7 @@ register({
         let first;
         for (const t of targets)
             try {
-                for (const p of parts)
+                for (const p of partsFor(t))
                     for (const s of partSpecs(t, p, capOf(t), !!sizesOf(t).halves))
                         made.push({
                             t,

package/dist/commands/read.js

@@ -46,10 +46,13 @@ function partCovering(parts, crop) {
 }
 /** "40-69" → [40, 69] */
 function range(v) {
-    const m = /^(\d+)(?:-(\d+))?$/.exec(v.trim());
+    const m = /^(\d+)(?:\s*(?:[-–]|\.\.\.?)\s*(\d+))?$/u.exec(v.trim());
     if (!m)
         throw new UsageError(`invalid --images "${v}"`, { hint: "e.g. 40-69" });
-    return [Number(m[1]), Number(m[2] ?? m[1])];
+    const [lo, hi] = [Number(m[1]), Number(m[2] ?? m[1])];
+    if (hi < lo)
+        throw new UsageError(`--images ${v.trim()}: a range from the lower number`, { hint: `--images ${hi}-${lo}` });
+    return [lo, hi];
 }
 export async function pool(items, size, fn) {
     const results = new Array(items.length);
@@ -93,7 +96,7 @@ register({
         { 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: "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 },
+        { name: "minutes", type: "string", value: "<n>", description: READER_MINUTES_HELP, mistaken: ["timeout", "time", "time-limit", "max-minutes"] },
     ],
     examples: [
         'strom read B0001 --images 40-69 --question "Every baptism of the surname Novák (Nowak, Nowack) in 1820–1824: the child, date, house, both parents and their parents"',