strom-research 1.13.2-beta.2 → 1.13.2-beta.3

package/assets/lang/cs.json

@@ -130,6 +130,13 @@
   "ui.setup.model.opus": "Opus – nejlépe čte staré rukopisy (doporučeno)",
   "ui.setup.model.sonnet": "Sonnet – rychlejší; tištěné dokumenty a běžná práce",
   "ui.setup.model.own": "Nechat na agentovi",
+  "ui.setup.model.agent": "Který model má v {agent} dělat výzkum? Nejsilnější nejlépe čtou staré rukopisy – rychleji spotřebují předplatné nebo stojí víc.",
+  "ui.setup.model.recommended": "{model} (doporučeno)",
+  "ui.setup.model.own.is": "Nechat na agentovi (teď {model})",
+  "ui.setup.model.now": "{model} (zvoleno teď)",
+  "ui.chat.app.model.chosen": "V aplikaci {app} zvolit pro výzkum model {model} (zvolený v nastavení).",
+  "ui.settings.model": "Model výzkumu ({agent}): {model}",
+  "ui.settings.model.own": "vlastní model agenta",
   "ui.setup.level": "Co smí agent dělat bez ptaní?",
   "ui.setup.level.ask": "Ptát se mě na všechno mimo výzkum",
   "ui.setup.level.auto": "Pracovat samostatně – ptát se jen u riskantních kroků (doporučeno)",
@@ -213,6 +220,7 @@
   "ui.run.stop.resets": " (obnoví se {at})",
   "ui.run.stop.auth": "agent není přihlášený – jednou spustit {command} a přihlásit se",
   "ui.run.stop.failed": "agent selhal: {detail}",
+  "ui.run.stop.model": "{agent} nepřijímá model {model} – zvolit jiný: strom config set model.lead <model> (nebo pro jeden běh: strom run --model <model>)",
   "ui.run.finishing": "■ Ctrl-C: sezení {session} dostalo žádost skončit – agent zapíše, co našel, a sezení uzavře, pak běh skončí (další sezení nezačne). Další Ctrl-C ho zastaví hned.",
   "ui.run.stopping": "■ zastavuji – sezení se zavře a jeho úkol se vrátí do fronty; další Ctrl-C skončí hned",
   "ui.run.gone": "· {session} zavřeno – jeho běh se zastavil{back}",
@@ -356,6 +364,9 @@
   "review.conflicts.what": "Rozhodnout, co zůstalo otevřené u osoby {name}: {list}{more}",
   "review.conflicts.why": "rozpory mezi prameny a soupeřící hypotézy čekají na rozhodnutí ({research})",
   "review.conflicts.done": "každý vyřešený nebo rozhodnutý se zdůvodněním (strom conflict resolve, strom hypothesis decide) – nebo úkol říká, co by rozhodlo",
+  "hypothesis.links.what": "Doplnit, co by spojovaly verze hypotéz {list}",
+  "hypothesis.links.why": "tyto hypotézy jmenují své osoby jen slovy svých verzí; aplikace Strom ukáže, co by verze spojila – i kde strom končí – jen z jejích vazeb",
+  "hypothesis.links.done": "každá verze přečtená (strom hypothesis show {first} …) a řečeno, co by spojila: strom hypothesis link H… <písmeno> --child P… --of F… (nebo --parents P… [P…], --same, --partners, --siblings); verze, která nic jasného nespojuje, zůstane bez vazeb",
   "review.marriage.what": "Sňatek: {name} a {partner}{at} (před prvním dítětem, {year})",
   "review.marriage.why": "jejich děti jsou zapsané, jejich sňatek ne; zápis dá rodiče obou, věk a domy ({research})",
   "review.marriage.done": "zápis nalezen a zapsán i se svědky – nebo roky {years} prohledány bez něj",
@@ -597,6 +608,7 @@
   "ui.stats.sessions": "Sezení agenta: {n} · poslední {last}",
   "ui.stats.cost": " · dosavadní cena {cost}",
   "ui.stats.cost.partial": " (bez přerušených sezení, která cenu neřekla: {n})",
+  "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}",
@@ -995,6 +1007,7 @@
   "ui.archives.agentbrowser.on": "Dát agentovi prohlížeč v každém sezení?",
   "ui.archives.agentbrowser.off": "Vrátit prohlížeč jen pro archivy přes prohlížeč?",
   "ui.consent.remote": "Spouštět sezení Claude Code, která strom otevírá, se vzdáleným ovládáním (Remote Control), aby je šlo sledovat a řídit z claude.ai nebo z aplikace Claude v telefonu?",
+  "ui.consent.addons": "Dovolit agentovi při samostatné práci načíst osobní doplňky z jeho nastavení (skilly, pluginy, MCP servery – třeba i poštu nebo dokumenty) jako v chatu? Pracuje přitom bez dozoru.",
   "ui.consent.edits.user": "Mají mít úpravy v aplikaci Strom přednost před tím, co říká záznam? Údaj ze záznamu se pak stáhne s důvodem (synchronizace jde vrátit).",
   "ui.consent.review.off": "Zapisovat, co pošle aplikace Strom, hned, bez ptaní u každého poslání? Přidané se zapíše, vodítka se opraví, změna údaje doloženého záznamem bude rozpor k rozhodnutí; strom sync undo poslání vrátí.",
   "ui.consent.mode.archive": "Udělat z výzkumu „{name}“ archiv? Data přicházejí z aplikace Strom a zapisují se, jak přijdou; žádný agent na něm nepracuje, jeho úkoly počkají odložené. Práci s agentem jde zase zapnout.",
@@ -1336,6 +1349,13 @@
   "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.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.",
+  "ui.alone.addons.on": "Zapnout?",
+  "ui.alone.addons.off": "Vypnout? (agent při samostatné práci pak načte i osobní doplňky)",
+  "ui.setup.addons": "Bez osobních doplňků agenta (skilly, pluginy, MCP servery)?",
+  "ui.setup.addons.yes": "Ano (doporučeno)",
+  "ui.setup.addons.no": "Ne – i při samostatné práci s doplňky",
   "ui.waiting.long": "Na odpověď sem je to dlouhé (nejvýš {n} znaků) – stačí odkaz nebo věta, zbytek stačí říct agentovi v rozhovoru.",
   "ui.settings.remote.chats": "rozhovory ano, samostatná práce ne",
   "ui.settings.remote.own": "Rozhovory s agentem už z telefonu sledovat jde – zapíná to sám Claude Code (jeho vlastní nastavení). Samostatnou práci agenta (volba 2 v menu) až po zapnutí i tohohle.",

package/assets/lang/de.json

@@ -130,6 +130,13 @@
   "ui.setup.model.opus": "Opus – liest alte Handschriften am besten (empfohlen)",
   "ui.setup.model.sonnet": "Sonnet – schneller; gedruckte Dokumente und alltägliche Arbeit",
   "ui.setup.model.own": "Dem Agenten überlassen",
+  "ui.setup.model.agent": "Welches Modell soll in {agent} die Forschung machen? Die stärksten lesen alte Handschriften am besten – sie verbrauchen ein Abo schneller oder kosten mehr.",
+  "ui.setup.model.recommended": "{model} (empfohlen)",
+  "ui.setup.model.own.is": "Dem Agenten überlassen (jetzt {model})",
+  "ui.setup.model.now": "{model} (jetzt gewählt)",
+  "ui.chat.app.model.chosen": "In {app} für die Forschung das Modell {model} wählen (das in den Einstellungen gewählte).",
+  "ui.settings.model": "Modell der Forschung ({agent}): {model}",
+  "ui.settings.model.own": "das eigene des Agenten",
   "ui.setup.level": "Was darf der Agent tun, ohne nachzufragen?",
   "ui.setup.level.ask": "Mich bei allem außerhalb der Forschung fragen",
   "ui.setup.level.auto": "Selbstständig arbeiten – nur bei riskanten Schritten fragen (empfohlen)",
@@ -213,6 +220,7 @@
   "ui.run.stop.resets": " (erneuert sich {at})",
   "ui.run.stop.auth": "der Agent ist nicht angemeldet – einmal {command} starten und anmelden",
   "ui.run.stop.failed": "der Agent ist gescheitert: {detail}",
+  "ui.run.stop.model": "{agent} nimmt das Modell {model} nicht an – ein anderes wählen: strom config set model.lead <model> (oder für einen Lauf: strom run --model <model>)",
   "ui.run.finishing": "■ Strg-C: Sitzung {session} ist gebeten aufzuhören – der Agent schreibt auf, was er gefunden hat, und schließt sie, dann endet der Lauf (keine nächste Sitzung). Noch einmal Strg-C stoppt ihn sofort.",
   "ui.run.stopping": "■ wird angehalten – die Sitzung wird geschlossen und ihre Aufgabe kehrt in die Warteschlange zurück; nochmals Strg-C beendet sofort",
   "ui.run.gone": "· {session} geschlossen – ihr Lauf war abgebrochen{back}",
@@ -356,6 +364,9 @@
   "review.conflicts.what": "Entscheiden, was bei {name} offen geblieben ist: {list}{more}",
   "review.conflicts.why": "Widersprüche zwischen Quellen und konkurrierende Hypothesen warten auf eine Entscheidung ({research})",
   "review.conflicts.done": "jeder gelöst oder entschieden mit Begründung (strom conflict resolve, strom hypothesis decide) – oder eine Aufgabe sagt, was entscheiden würde",
+  "hypothesis.links.what": "Angeben, was die Varianten von {list} verbinden würden",
+  "hypothesis.links.why": "diese Hypothesen nennen ihre Personen nur in den Worten ihrer Varianten; die Strom-App zeigt, was eine Variante verbinden würde – und wo der Stammbaum endet – nur aus ihren Verknüpfungen",
+  "hypothesis.links.done": "jede Variante gelesen (strom hypothesis show {first} …) und angegeben, was sie verbinden würde: strom hypothesis link H… <Buchstabe> --child P… --of F… (oder --parents P… [P…], --same, --partners, --siblings); eine Variante, die nichts Klares verbindet, bleibt ohne Verknüpfungen",
   "review.marriage.what": "Heirat: {name} und {partner}{at} (vor dem ersten Kind, {year})",
   "review.marriage.why": "ihre Kinder sind erfasst, ihre Heirat nicht; der Eintrag nennt die Eltern beider, Alter und Häuser ({research})",
   "review.marriage.done": "der Eintrag gefunden und mit den Zeugen erfasst – oder {years} ohne ihn durchsucht",
@@ -597,6 +608,7 @@
   "ui.stats.sessions": "Sitzungen des Agenten: {n} · die letzte {last}",
   "ui.stats.cost": " · Kosten bisher {cost}",
   "ui.stats.cost.partial": " (ohne abgebrochene Sitzungen, die ihre Kosten nicht nannten: {n})",
+  "ui.stats.cost.readers": ", davon Leser der Scans {cost}",
   "ui.stats.stories": "Geschichten: {n}",
   "ui.status.data": "Personen: {persons} · Familien: {families}",
   "ui.status.directions": " · Richtungen der Forschung: {n}",
@@ -995,6 +1007,7 @@
   "ui.archives.agentbrowser.on": "Dem Agenten den Browser in jeder Sitzung geben?",
   "ui.archives.agentbrowser.off": "Zurück zum Browser nur für Archive über den Browser?",
   "ui.consent.remote": "Die Claude-Code-Sitzungen, die strom öffnet, mit Remote Control starten, damit sie sich auf claude.ai oder in der Claude-App auf dem Telefon verfolgen und steuern lassen?",
+  "ui.consent.addons": "Dem allein arbeitenden Agenten erlauben, die persönlichen Erweiterungen aus seinen Einstellungen zu laden (Skills, Plugins, MCP-Server – auch E-Mail oder Dokumente), wie im Chat? Er arbeitet dabei unbeaufsichtigt.",
   "ui.consent.edits.user": "Sollen eigene Änderungen in der Strom-App vor dem gelten, was ein Eintrag sagt? Die Angabe aus dem Eintrag wird dann mit Begründung zurückgezogen (ein Abgleich lässt sich zurücknehmen).",
   "ui.consent.review.off": "Was die Strom-App sendet, gleich übernehmen, ohne bei jeder Sendung zu fragen? Hinzugefügtes wird übernommen, Hinweise korrigiert, eine Änderung einer durch einen Eintrag belegten Angabe wird ein Widerspruch zur Entscheidung; strom sync undo nimmt eine Sendung zurück.",
   "ui.consent.mode.archive": "Die Forschung „{name}“ zu einem Archiv machen? Die Daten kommen aus der Strom-App und werden übernommen, wie sie gesendet werden; kein Agent arbeitet daran, ihre Aufgaben warten zurückgestellt. Die Arbeit mit einem Agenten lässt sich wieder einschalten.",
@@ -1336,6 +1349,13 @@
   "ui.dirs.active.now": "▶ „{name}“ läuft wieder: ihre Aufgaben ({n}) sind zurück in der Warteschlange.",
   "ui.research.resume": "Diese Forschung gibt es schon, {state}: „{name}“. Wieder aufnehmen?",
   "ui.alone.gate.bad": "Bitte eine Zahl von Punkten zwischen 0 und 100 (z. B. 10).",
+  "ui.alone.addons": "Ohne die persönlichen Erweiterungen des Agenten (Skills, Plugins, MCP-Server): {state}",
+  "ui.alone.addons.about": "Allein arbeitend lädt der Agent nur die Werkzeuge der Forschung. Die Verbindung zur Strom-App und der Browser funktionieren weiter. Im Chat mit dem Agenten werden die Erweiterungen immer geladen.",
+  "ui.alone.addons.on": "Einschalten?",
+  "ui.alone.addons.off": "Ausschalten? (der allein arbeitende Agent lädt dann auch die persönlichen Erweiterungen)",
+  "ui.setup.addons": "Ohne die persönlichen Erweiterungen des Agenten (Skills, Plugins, MCP-Server)?",
+  "ui.setup.addons.yes": "Ja (empfohlen)",
+  "ui.setup.addons.no": "Nein – auch allein arbeitend mit den Erweiterungen",
   "ui.waiting.long": "Das ist für eine Antwort hier zu lang (höchstens {n} Zeichen) – ein Link oder ein Satz; das Übrige dem Agenten im Gespräch sagen.",
   "ui.settings.remote.chats": "Gespräche ja, allein arbeiten nein",
   "ui.settings.remote.own": "Gespräche mit dem Agenten lassen sich schon vom Telefon verfolgen – das macht Claude Code selbst (seine eigene Einstellung). Die Arbeit des Agenten allein (Punkt 2 im Menü) erst, wenn auch dies eingeschaltet ist.",

package/assets/method/core.md

@@ -20,7 +20,9 @@ conclusion so the next researcher can follow it.
 - **Negative results are results.** Every search is recorded (`strom search add
   … --result negative`), with exactly what was covered. The most expensive
   mistake is to search the same book twice.
-- **Check the premise first.** Before opening anything: `strom searched <where>`.
+- **Check the premise first.** Before opening anything, read the brief's
+  *Already known* — the searches of the task's books, people and surnames;
+  `strom searched <where>` only for a book, place or years it does not list.
 - **Extract everything the first time** you open a record: names, ages, house
   numbers, occupations, godparents, witnesses, midwife, remarks in the margin.
   Opening the same page again later costs more than writing it down now.

package/assets/method/intake.md

@@ -3,8 +3,9 @@
 An input is material the user gave you: scans, photos, documents, notes, a
 family tree. Your job is to turn it into evidence without inventing anything.
 
-1. `strom input show I…` — read the file (images and PDFs directly, text is
-   shown). Identify who it is about and what kind of document it is.
+1. The brief's *The material* says what each input is, where its file is, and
+   shows its text: read the file (images and PDFs directly). Identify who it
+   is about and what kind of document it is.
 2. **What is it?** An original civil or church document (birth, marriage or
    death certificate, extract from a register, military papers) is a **source**
    and can prove facts: `strom source add … --input I… --form original
@@ -14,7 +15,7 @@ family tree. Your job is to turn it into evidence without inventing anything.
    `strom source add "<what it is>" --kind family-memory --form authored
    --information secondary --input I…`; a family tree is `--kind family-tree`.
    Many facts from one input: one `strom batch --file notes/<input>.txt`
-   (try it with `--dry-run` first).
+   (all or nothing: it says every failing line at once, nothing written).
 3. Record every person and every fact it states, with a citation to the source
    (`--cite S… --locator "…"`). Use the words of the record in `--quote`.
 4. Put names and places as they are written; normalise only dates.
@@ -26,8 +27,9 @@ family tree. Your job is to turn it into evidence without inventing anything.
    the tree says differently stays a lead or becomes a conflict, never a fact.
 6. Create the next tasks: where would the records that prove these leads be?
    (`locate` if the archive or book is unknown, `link` if it is known.)
-7. Close the task with what came out of it (`strom task done T… --result "…"`;
-   its input is marked processed with it).
+7. Close the task with what came out of it (`strom session close --done "…"
+   --next "…"`: the task and the session in one call; its input is marked
+   processed with it).
 
 ## A batch from the Strom app (many files at once)
 
@@ -36,9 +38,10 @@ lists about 25 of its files, with the path each had there
 (`Babička/Dopisy/1946.jpg` — the folders say much). They are kept unchanged
 outside the tree's history: what you do not record of them stays private.
 
-1. **Look over all of them first, cheaply**: `strom input show I…` for each —
-   the name, the path, the type; images in a small view (`strom media view
-   I… --grid`), not read whole. Sort each at once: `strom input sort I… [I…]
+1. **Look over all of them first, cheaply**: the brief lists each — the
+   name, the path, the type; images in a small view (`strom media view
+   I… I… I… --grid`: several in one call, opened together), not read
+   whole. Sort each at once: `strom input sort I… [I…]
    --as source|document|photo|unrelated --person P…`. Read in depth only what
    belongs to the people of the research.
 2. **Not of the family** (a tax form, a holiday photo of strangers, the same

package/assets/method/link.md

@@ -1,6 +1,7 @@
 # Method: proving a link (parents, marriage)
 
-1. **Premise:** `strom searched B… --years …` and `strom task show T…` — if the
+1. **Premise:** the brief's *Already known* and the task's notes (`strom
+   searched B… --years …` only for a book or years it does not list) — if the
    range was already covered completely, do not repeat it; say so and close.
 2. **Index before book.** Use an index to find the page, then read the entry in
    the register itself. An index entry alone is a lead — and so is its absence:

package/assets/method/reading.md

@@ -7,12 +7,20 @@ search depends on** (a surname, a birthplace, a parish) is read again on a
 crop at full resolution before it is recorded; what stays unsure is recorded
 as unsure and said so.
 
-An image you open stays in your context and is paid for again on every turn.
-Look at as few pixels as the question needs, and write down what you saw at once.
+Every image you open stays in your context to the end of the session: look at
+as few pixels as the question needs, write down what you saw at once, and after
+about 80 views write down what you found before you open more.
 
 - **Look only through views**: `strom media view B0001:57` (record set and
   image number) makes a file in `.strom/views/` — open that file. Whole images
   come reduced: good for "is our surname on this page?", not for reading.
+- **The views of a scan, or of a batch, in one call**, then open all the files
+  it lists together — not one call and one look per view:
+  `strom media view B0001:57-60 --half both` (the two pages of each double
+  page, where they are sharper than one view of it), `--crop … --crop …`
+  (several entries of one image), `--split 2x2` (a page in overlapping parts),
+  `strom media view B0001 --page 112 113`. Each file comes with its image, page
+  and `--clip`. At most 12 images and 24 views in one call.
 - **Find, then crop.** `--grid` overlays tenths with labels; read off where the
   entry is and ask for exactly that part: `--crop 0.05,0.40,0.45,0.18` (x, y,
   width, height as fractions) or `--half left|right` for one page of a spread.
@@ -24,8 +32,15 @@ Look at as few pixels as the question needs, and write down what you saw at once
   …` (one request). Then view the same crop again: it comes from the sharper
   part by itself.
 - **Browsing a book is a reader's job**: `strom read B0001 --images 40-69
-  --question "…"` — readers in batches of ten, each with the full question;
-  their reports stay in notes/readings/ for the next session, you get the finds.
+  --question "…"` — readers in batches of ten, each with the full question.
+  Their reports stay in notes/readings/; `strom read` ends with what they
+  found, compact: the found and unclear entries whole, what was illegible
+  where nothing was found (a possible match often hides there — look at it),
+  and the gaps in the book. Later, or in the next session: `strom readings`
+  (`--match <surname>` across all readings, `--list`); one image's whole
+  block: `strom readings B0001 --image 57`. Do not open the reports whole —
+  they are many times longer. Images read before are said before they are
+  read again: another question or a blind check is fine, the same one is not.
   It waits for its readers (often ten minutes or more): run it in the
   foreground and let it finish — your session ends with your turn, and
   whatever is left running in the background ends with it.
@@ -42,7 +57,10 @@ Look at as few pixels as the question needs, and write down what you saw at once
 - **Cite the image, and where the entry is on it**: `strom source add …
   --clip B0001:57@0.05,0.40,0.45,0.18 --locator "pag. 112, 2nd entry"` — the
   crop you read it in, as its view prints it; a searched range goes in
-  `strom search add … --pages 40-69`.
+  `strom search add … --pages 40-69`. Pages missing from the book (the
+  numbering jumps) were not searched: say so in `--note` (strom read puts the
+  gaps its readers saw there), or leave them out of the range
+  (`--pages 40-52,55-69`).
 - Page ↔ image: `strom recordset calibrate B0001 --point 57=112` (measured on
   the image, never guessed); then `strom media view B0001 --page 112` works.
 - **No images here yet:** a connector for that archive

package/assets/method/recording.md

@@ -1,8 +1,9 @@
 # Method: recording an entry
 
-Record a found entry in one batch: write the lines to a file in notes/, run
-`strom batch --file notes/<file> --dry-run`, fix what it reports, then run it
-without --dry-run. `#name` labels what a line creates, `@name` uses it later.
+Record a found entry in one batch: write the lines to a file in notes/ and run
+`strom batch --file notes/<file>` — all or nothing: when a line fails nothing is
+written and every failing line is said at once; fix them, run it again.
+`#name` labels what a line creates, `@name` uses it later.
 
     source add "Baptism of Jan Novák 1885" --kind baptism --recordset B0001 --clip B0001:57@0.05,0.40,0.45,0.18 --locator "pag. 112, entry 2" --language la --information primary --transcript @notes/entry.txt #s
     event add P0001 CHR --date "25 JUN 1885" --place "Týnec" --house 13 --cite @s --quote "baptizatus est" --with "godparent:Marie Dvořáková" --with "midwife:Anna Nová" --with "officiant:P. Josef Kříž" --status proven

package/assets/method/verify.md

@@ -6,7 +6,8 @@ first name) needs a second, independent reading.
 - The second reader must be **blind**: do not tell them the expected value, the
   name, the place or why it matters. Ask only what is written in that cell.
 - One cell, one second reader — not the whole page again.
-- Before asking, check whether two readings already exist (`strom find`).
+- Before asking, check whether two readings already exist (`strom find`; what
+  readers wrote of an image: `strom readings B0001 --image 57`).
 - Certainty above "probable" only when two independent readings agree. When
   they disagree, record a conflict with both readings.
 - An independent reading of an entry you cited: `strom read M… --blind --crop

package/dist/agents/files.js

@@ -30,9 +30,10 @@ the researcher; \`strom\` is your only way to read and change the research.
 1. Start with \`strom\` — it says where things stand and what to do next.
    \`strom guide\` explains the work; \`strom help <command>\` any command.
 2. Work in sessions: \`strom session start\` gives you the brief for the next
-   task; finish with \`strom session close --summary "…" --next "…"\`. The
-   next step is strom's queue (\`strom\` names it, \`strom plan\` lists it):
-   what the user wants instead becomes a task first — never search outside a
+   task; finish with \`strom session close --done "<result>" --next "…"\`
+   (the task and the session in one call). The next step is strom's queue
+   (\`strom\` names it, \`strom plan\` lists it): what the user wants
+   instead becomes a task first — never search outside a
    session and its task.
 3. Never create, edit or delete anything in \`data/\`, \`strom.json\` or \`.git\`,
    never read the files in \`data/\` (strom shows them better and shorter), and
@@ -45,7 +46,8 @@ the researcher; \`strom\` is your only way to read and change the research.
    terminal — never do it yourself.
 6. You may read \`inputs/\`, \`output/\`, \`notes/\` and \`.strom/views/\`, and write
    your own working notes in \`notes/\`. Scans are looked at through views:
-   \`strom media view B0001:57 --half left\` writes one to \`.strom/views/\`.
+   \`strom media view B0001:57 --half left\` writes one to \`.strom/views/\`;
+   the views of a scan or a batch come in one call (\`B0001:57-60 --half both\`).
 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.

package/dist/agents/images.js

@@ -0,0 +1,54 @@
+// How big an image each agent's model takes in whole. An agent shrinks a bigger image itself before its model sees
+// it (and pays for the pixels it threw away in a slower read), so strom makes views no bigger than that:
+//   Claude Code   ≤ 2000 px for Opus 4.7+, Sonnet 5+, Fable and Mythos (the image limit of their model catalogue;
+//                 older models — Opus/Sonnet 4.6, Haiku — take 1568 on the API side)
+//   Codex         ≤ 2048 px and about 2.5 megapixels at its default detail
+//   OpenCode      ≤ 2000×2000 by default (attachment.image), the provider's model limit beyond it
+//   Grok Build    shrinks to a size it does not say; Antigravity counts tokens per image, not pixels
+// Unknown: 1568 px, what every vision model takes without shrinking it again.
+/** The long side of a view every vision model takes in whole. */
+export const IMAGE_MAX = 1568;
+/** What the newer models take in whole, and Claude Code, Codex and OpenCode pass on unshrunk. */
+export const IMAGE_MAX_LARGE = 2000;
+/** A Claude model name or alias ("opus", "claude-opus-4-7", "claude-sonnet-5-5[1m]", "us.anthropic.claude-…"): its family and version. */
+export function claudeModel(model) {
+    const m = /(opus|sonnet|haiku|fable|mythos)(?:[-.]?(\d{1,2})(?:[-.](\d{1,2})(?!\d))?(?!\d))?/.exec(model.toLowerCase());
+    if (!m)
+        return undefined;
+    // "claude-3-5-sonnet-…": the version before the family (an old model)
+    const before = /(\d{1,2})(?:[-.](\d{1,2}))?[-.](?:opus|sonnet|haiku)/.exec(model.toLowerCase());
+    if (!m[2] && before)
+        return { family: m[1], version: Number(before[1]) + Number(before[2] ?? 0) / 10 };
+    return { family: m[1], ...(m[2] ? { version: Number(m[2]) + Number(m[3] ?? 0) / 10 } : {}) };
+}
+/**
+ * The longest side of a view for this agent and model (the model strom starts it with; undefined = the agent's own
+ * default). Claude Code's own default is a model of the current line (Opus or Sonnet 5): 2000. A model given as a
+ * family alone ("opus", "sonnet", "fable") is that family's newest — haiku stays at 1568 (not among the larger ones).
+ */
+export function imageMax(agent, model) {
+    const m = model?.trim() || undefined;
+    switch (agent) {
+        case "claude": {
+            if (!m || m === "default" || m === "best")
+                return IMAGE_MAX_LARGE;
+            const c = claudeModel(m);
+            if (!c)
+                return IMAGE_MAX;
+            if (c.family === "fable" || c.family === "mythos")
+                return IMAGE_MAX_LARGE;
+            if (c.version === undefined)
+                return c.family === "haiku" ? IMAGE_MAX : IMAGE_MAX_LARGE;
+            if (c.family === "opus")
+                return c.version >= 4.7 ? IMAGE_MAX_LARGE : IMAGE_MAX;
+            if (c.family === "sonnet")
+                return c.version >= 5 ? IMAGE_MAX_LARGE : IMAGE_MAX;
+            return IMAGE_MAX;
+        }
+        case "codex":
+        case "opencode":
+            return IMAGE_MAX_LARGE;
+        default:
+            return IMAGE_MAX;
+    }
+}

package/dist/agents/models.js

@@ -0,0 +1,248 @@
+// The strong models an agent can do the research with — offered in the setup wizard and the settings, the person
+// picks one (or leaves it to the agent). Where the agent lists its models without a prompt (Antigravity's `agy
+// models`, OpenCode's `opencode models`, Grok Build's `grok models`, Codex's `codex debug models`: its catalog for
+// the account logged in), the strong ones are taken from that list; a list that cannot be had in a few seconds (offline,
+// not logged in, another version) leaves a small built-in one. Nothing here runs a prompt or costs anything.
+import fs from "node:fs";
+import path from "node:path";
+import { userHome } from "../core/paths.js";
+import { findAgent, withoutAgentMarks } from "../core/which.js";
+import { spawnAgent, stopTree } from "../runners/runner.js";
+import { PROFILES } from "./profiles.js";
+/** Claude Code: its aliases (always the newest of each line). */
+const CLAUDE = [{ id: "opus" }, { id: "sonnet" }];
+/**
+ * When the agent's own list cannot be had: strong models each agent took when this was written (Codex with a ChatGPT
+ * account: gpt-6-sol and gpt-6-astra are in its catalog, gpt-6.1-sol is refused; Antigravity: Gemini 3.1 Pro, Claude
+ * Opus 4.6). A model it no longer takes is said by strom run (the agent refuses it).
+ */
+export const BUILTIN_MODELS = {
+    claude: CLAUDE,
+    codex: [{ id: "gpt-6-astra" }, { id: "gpt-6-sol" }],
+    antigravity: [
+        { id: "gemini-3.1-pro-high", label: "Gemini 3.1 Pro (High)" },
+        { id: "claude-opus-4-6-thinking", label: "Claude Opus 4.6 (Thinking)" },
+    ],
+    opencode: [{ id: "openai/gpt-6-astra" }, { id: "openai/gpt-6-sol" }],
+    grok: [{ id: "grok-4.7" }, { id: "grok-4.6" }],
+};
+/** How each agent lists its models (none: Claude Code — its aliases are the list). */
+const LIST = {
+    codex: ["debug", "models"],
+    antigravity: ["models"],
+    opencode: ["models"],
+    grok: ["models"],
+};
+/** Words of a model's name (or its maker's description) that say it is the fast, cheap or small one. */
+const WEAK = new Set([
+    "flash", "mini", "nano", "haiku", "lite", "light", "small", "tiny", "instant", "fast", "ultrafast", "spark", "free", "oss",
+    // a lower reasoning effort of a model (Antigravity: gemini-3.1-pro-low)
+    "low", "medium",
+    // OpenAI's lighter lines beside sol and astra
+    "luna", "terra",
+    "review", "auto",
+]);
+/** Words of a maker's description of a lighter or older model (Codex's catalog). */
+const WEAK_ABOUT = new Set(["affordable", "easier", "efficient", "legacy", "older", "cheap", "lightweight", "balanced", "fast"]);
+/** The strongest line of a maker, then the one below it. */
+const TOP = new Set(["opus", "pro", "ultra", "astra", "max"]);
+const HIGH = new Set(["sonnet", "sol"]);
+function words(s) {
+    return s.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+}
+/** The version numbers in a model's name: gpt-6.1-sol → [6, 1], claude-opus-4-6 → [4, 6]. */
+function version(id) {
+    const m = /\p{N}+(?:[.-]\p{N}+)*/u.exec(id.slice(id.lastIndexOf("/") + 1));
+    return m ? m[0].split(/[.-]/).map(Number) : [];
+}
+function newer(a, b) {
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const d = (b[i] ?? -1) - (a[i] ?? -1);
+        if (d)
+            return d;
+    }
+    return 0;
+}
+/** The maker's line a model belongs to: openai/gpt-6-sol → openai/gpt, claude-opus-4-6 → claude. */
+function family(id) {
+    const slash = id.lastIndexOf("/");
+    return id.slice(0, slash + 1) + (words(id.slice(slash + 1))[0] ?? "");
+}
+/**
+ * The strong models of a list, in the order to offer them: never a fast, small or cheap one; the strongest line of a
+ * maker first (Opus, Pro, Astra), then the one below (Sonnet, Sol), then the rest; makers in the order the agent lists
+ * them (its own first), the newest version first, at most two of one line, three in all.
+ */
+export function strongModels(list, max = 3) {
+    const kept = list.filter((m) => !words(m.id).some((w) => WEAK.has(w)) && !words(m.label ?? "").some((w) => WEAK.has(w)) && !words(m.about ?? "").some((w) => WEAK_ABOUT.has(w)));
+    const tier = (m) => {
+        const w = [...words(m.id), ...words(m.label ?? "")];
+        return w.some((x) => TOP.has(x)) ? 2 : w.some((x) => HIGH.has(x)) ? 1 : 0;
+    };
+    const families = [];
+    for (const m of kept)
+        if (!families.includes(family(m.id)))
+            families.push(family(m.id));
+    const sorted = kept
+        .map((m, i) => ({ m, i, tier: tier(m), fam: families.indexOf(family(m.id)), v: version(m.id) }))
+        .sort((a, b) => b.tier - a.tier || a.fam - b.fam || newer(a.v, b.v) || a.i - b.i);
+    const out = [];
+    const perLine = new Map();
+    for (const { m, tier: t } of sorted) {
+        const line = `${family(m.id)}|${t}`;
+        if ((perLine.get(line) ?? 0) >= 2 || out.some((o) => o.id === m.id))
+            continue;
+        perLine.set(line, (perLine.get(line) ?? 0) + 1);
+        out.push(m.label ? { id: m.id, label: m.label } : { id: m.id });
+        if (out.length >= max)
+            break;
+    }
+    return out;
+}
+/** `agy models`: "<id>\t<name>" a line (after a line that says it fetches). */
+export function parseAntigravity(text) {
+    return text
+        .split(/\r?\n/)
+        .map((l) => l.split("\t"))
+        .filter((p) => p.length >= 2 && p[0].trim() && !/\s/.test(p[0].trim()))
+        .map((p) => ({ id: p[0].trim(), label: p[1].trim() }));
+}
+/** `opencode models`: "<provider>/<model>" a line. */
+export function parseOpencode(text) {
+    return text
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => /^[^\s/]+\/\S+$/.test(l))
+        .map((id) => ({ id }));
+}
+/** `grok models`: "  * <id> (default)" / "  - <id>", and "Default model: <id>". */
+export function parseGrok(text) {
+    const models = [];
+    let agentDefault;
+    for (const l of text.split(/\r?\n/)) {
+        const m = /^\s*[*-]\s+(\S+)(\s+\(default\))?\s*$/.exec(l);
+        if (m) {
+            models.push({ id: m[1] });
+            if (m[2])
+                agentDefault = m[1];
+        }
+        const d = /^\s*Default model:\s*(\S+)/i.exec(l);
+        if (d)
+            agentDefault = d[1];
+    }
+    return { models, ...(agentDefault ? { agentDefault } : {}) };
+}
+/** `codex debug models` (or its models_cache.json): the catalog for the account, hidden ones left out, in its order. */
+export function parseCodex(text) {
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        return [];
+    }
+    const list = data?.models;
+    if (!Array.isArray(list))
+        return [];
+    return list
+        .filter((m) => typeof m?.slug === "string")
+        .filter((m) => m.visibility !== "hide")
+        .sort((a, b) => (a.priority ?? 999) - (b.priority ?? 999))
+        .map((m) => ({ id: m.slug, ...(m.display_name ? { label: m.display_name } : {}), ...(m.description ? { about: m.description } : {}) }));
+}
+/** The model Codex takes when given none: `model = "…"` of its config.toml (before any [section]). */
+export function codexConfigModel(env) {
+    const dir = env.CODEX_HOME || path.join(userHome(env), ".codex");
+    let text;
+    try {
+        text = fs.readFileSync(path.join(dir, "config.toml"), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    for (const l of text.split(/\r?\n/)) {
+        if (/^\s*\[/.test(l))
+            break;
+        const m = /^\s*model\s*=\s*["']([^"']+)["']/.exec(l);
+        if (m)
+            return m[1];
+    }
+    return undefined;
+}
+/** Run an agent's list command: its output, or undefined when it fails or takes longer than `ms`. */
+function listOutput(program, args, env, ms) {
+    return new Promise((resolve) => {
+        let out = "";
+        let done = false;
+        const finish = (v) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            resolve(v);
+        };
+        let child;
+        try {
+            child = spawnAgent(program, args, { env: { ...withoutAgentMarks(env), NO_COLOR: "1" }, stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+        }
+        catch {
+            resolve(undefined);
+            return;
+        }
+        const timer = setTimeout(() => {
+            stopTree(child);
+            finish(undefined);
+        }, ms);
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", (d) => {
+            if (out.length < 4_000_000)
+                out += d;
+        });
+        child.on("error", () => finish(undefined));
+        child.on("close", (code) => finish(code === 0 ? out : undefined));
+    });
+}
+/**
+ * The strong models to offer for an agent: from its own list when it gives one within `ms` (default 6 s; never
+ * hanging the wizard), else strom's built-in list.
+ */
+export async function modelChoices(agent, env, ms = Number(env.STROM_MODELS_TIMEOUT_MS) || 6000) {
+    const builtin = BUILTIN_MODELS[agent] ?? [];
+    const configured = agent === "codex" ? codexConfigModel(env) : undefined;
+    const fallback = () => ({ models: builtin, source: "builtin", ...(configured ? { agentDefault: configured } : {}) });
+    const args = LIST[agent];
+    if (!args)
+        return fallback();
+    const program = findAgent(PROFILES[agent]?.command ?? agent, env);
+    if (!program)
+        return fallback();
+    const text = await listOutput(program, args, env, ms);
+    let list = [];
+    let agentDefault = configured;
+    if (text !== undefined) {
+        if (agent === "antigravity")
+            list = parseAntigravity(text);
+        else if (agent === "opencode")
+            list = parseOpencode(text);
+        else if (agent === "codex")
+            list = parseCodex(text);
+        else if (agent === "grok") {
+            const g = parseGrok(text);
+            list = g.models;
+            agentDefault = g.agentDefault;
+        }
+    }
+    // Codex keeps its catalog for the account beside its config: read when the command would not say it
+    if (!list.length && agent === "codex") {
+        try {
+            list = parseCodex(fs.readFileSync(path.join(env.CODEX_HOME || path.join(userHome(env), ".codex"), "models_cache.json"), "utf8"));
+        }
+        catch {
+            // none
+        }
+    }
+    const strong = strongModels(list);
+    if (!strong.length)
+        return fallback();
+    return { models: strong, source: "agent", ...(agentDefault ? { agentDefault } : {}) };
+}