strom-research 1.19.0-beta.2 → 1.19.0-beta.4

package/CHANGELOG.cs.md

@@ -7,7 +7,7 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 
 ## 1.19.0
 
-*Připravuje se: bety do 1.19.0-beta.2. Oddíl bude úplný s vydáním.*
+*Připravuje se: bety do 1.19.0-beta.4. Oddíl bude úplný s vydáním.*
 
 - **Na archiv, který zmlkl, se čeká, místo opakovaných dotazů.** Když archiv přestane odpovídat, strom ho nechá na
   pokoji hodinu — a když týž den mlčí dál, dvě a pak čtyři hodiny — a agent se dozví, do kdy: mezitím dělá
@@ -22,6 +22,10 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 - **Ostřejší část snímku se opravdu čte.** Když z archivu přišla část snímku v lepším rozlišení, agent i jeho čtenáři
   se na to místo dívají v ní — i když vyznačené místo kousek přesahuje, zbytek se řekne —, ne na celý zmenšený snímek;
   ostřejší část, která místo pokrývá jen zčásti, se uvede i s tím, jak se na ni podívat.
+- **Dokument se přečte spolehlivěji.** Čtenář zapisuje čtení do své zprávy průběžně, a čtení dvou čtenářů, kde četl
+  jen jeden, to tak řekne — nikdy, že se shodují.
+- **Propojení s telefonem čeká na výzkum, neříká se jako chyba.** Než se po spuštění počítače spustí výzkum, `strom
+  phone` i nastavení řeknou, že propojení je zapnuté a jeho server se znovu spustí se spuštěním výzkumu.
 
 ## 1.18.0
 

package/CHANGELOG.de.md

@@ -7,7 +7,7 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.19.0
 
-*In Vorbereitung: die Betas bis 1.19.0-beta.2. Der Abschnitt ist mit dem Release vollständig.*
+*In Vorbereitung: die Betas bis 1.19.0-beta.4. Der Abschnitt ist mit dem Release vollständig.*
 
 - **Auf ein verstummtes Archiv wird gewartet, statt es immer wieder zu fragen.** Antwortet ein Archiv nicht mehr,
   lässt strom es eine Stunde in Ruhe — zwei, dann vier, wenn es am selben Tag still bleibt — und der Agent erfährt, bis
@@ -25,6 +25,11 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   sehen der Agent und seine Leser diese Stelle darin an — auch wenn die markierte Stelle etwas darüber hinausreicht,
   der Rest wird genannt — statt des ganzen, verkleinerten Scans; ein schärferer Teil, der die Stelle nur zum Teil
   zeigt, wird mit dem Weg genannt, ihn anzusehen.
+- **Ein Dokument wird verlässlicher gelesen.** Ein Leser schreibt seine Lesung laufend in seinen Bericht, und eine
+  Lesung zweier Leser, bei der nur einer las, sagt das so — nie, dass sie übereinstimmen.
+- **Die Verbindung mit dem Telefon wartet auf die Forschung, nicht als Fehler genannt.** Bevor die Forschung nach dem
+  Neustart des Computers startet, sagen `strom phone` und die Einstellungen, dass die Verbindung an ist und ihr Server
+  mit der Forschung wieder startet.
 
 ## 1.18.0
 

package/CHANGELOG.md

@@ -7,7 +7,7 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 1.19.0
 
-*In preparation: the betas up to 1.19.0-beta.2. The section is complete with the release.*
+*In preparation: the betas up to 1.19.0-beta.4. The section is complete with the release.*
 
 - **An archive that went silent is waited for, not asked again and again.** When an archive stops answering, strom
   leaves it alone for an hour — two, then four when it stays silent the same day — and the agent hears until when:
@@ -24,6 +24,10 @@ The changes of each version in short. The full notes and the install lines are o
   agent and its readers look at that place in it — also when the place they mark reaches a little past it, the rest
   said — instead of the whole scan, reduced; a sharper part that holds only some of the place is named with the way
   to look at it.
+- **A document read more surely.** A reader writes its reading into its report as it goes, and a reading of two readers where
+  only one read says so, never that they agree.
+- **The phone connection waits for the research, not said as an error.** Before the research starts after the computer
+  started again, `strom phone` and the settings say the connection is on and its server starts again with the research.
 
 ## 1.18.0
 

package/assets/lang/cs.json

@@ -1298,6 +1298,7 @@
   "ui.phone.window.no": "Zrušit",
   "ui.phone.on": "propojení s telefonem: zapnuto, v místní síti na {urls}",
   "ui.phone.starting": "propojení s telefonem: zapnuto, jeho server se spouští",
+  "ui.phone.waiting": "propojení s telefonem: zapnuto, jeho server se znovu spustí se spuštěním výzkumu",
   "ui.phone.error": "propojení s telefonem: zapnuto, ale telefon se k němu nedostane: {why}",
   "ui.phone.why.no-lan": "počítač není v žádné místní síti (Wi-Fi ani kabel)",
   "ui.phone.why.port-busy": "porty 47800–47819 mají obsazené jiné programy",

package/assets/lang/de.json

@@ -1298,6 +1298,7 @@
   "ui.phone.window.no": "Abbrechen",
   "ui.phone.on": "Verbindung mit dem Telefon: an, im lokalen Netz unter {urls}",
   "ui.phone.starting": "Verbindung mit dem Telefon: an, ihr Server startet",
+  "ui.phone.waiting": "Verbindung mit dem Telefon: an, ihr Server startet wieder, sobald die Forschung startet",
   "ui.phone.error": "Verbindung mit dem Telefon: an, aber ein Telefon erreicht sie nicht: {why}",
   "ui.phone.why.no-lan": "der Computer ist in keinem lokalen Netz (weder WLAN noch Kabel)",
   "ui.phone.why.port-busy": "die Ports 47800–47819 belegen andere Programme",

package/dist/cli/menu-settings.js

@@ -180,7 +180,7 @@ async function phoneStep(ctx, run, lang) {
         await pause(ctx, lang);
         return;
     }
-    const i = await ctx.choose(t(s.state === "on" ? "ui.phone.on" : "ui.phone.error", { urls: s.addresses.map((a) => a.url).join(", "), why: t(`ui.phone.why.${s.error?.code ?? "bind-failed"}`) }), [{ label: t("ui.phone.menu.off") }, ...s.phones.map((p) => ({ label: t("ui.phone.menu.remove", { name: p.name || p.id, date: p.pairedAt.slice(0, 10) }) }))], 0, { back: t("ui.browse.back") });
+    const i = await ctx.choose(t(s.state === "on" ? "ui.phone.on" : s.error?.waiting ? "ui.phone.waiting" : "ui.phone.error", { urls: s.addresses.map((a) => a.url).join(", "), why: t(`ui.phone.why.${s.error?.code ?? "bind-failed"}`) }), [{ label: t("ui.phone.menu.off") }, ...s.phones.map((p) => ({ label: t("ui.phone.menu.remove", { name: p.name || p.id, date: p.pairedAt.slice(0, 10) }) }))], 0, { back: t("ui.browse.back") });
     if (i === undefined)
         return;
     if (i === 0)

package/dist/cli/ui.js

@@ -1198,6 +1198,7 @@ export const UI = {
     "ui.phone.window.no": "Cancel",
     "ui.phone.on": "phone connection: on, on the local network at {urls}",
     "ui.phone.starting": "phone connection: on, its server is starting",
+    "ui.phone.waiting": "phone connection: on, its server starts again when the research starts",
     "ui.phone.error": "phone connection: on, but a phone cannot reach it: {why}",
     "ui.phone.why.no-lan": "this computer is on no local network (Wi-Fi or a cable)",
     "ui.phone.why.port-busy": "the ports 47800–47819 are taken by other programs",

package/dist/commands/document.js

@@ -246,7 +246,7 @@ async function readWith(ctx, tree, s, opts, only) {
     }
     const team = readers(ctx, tree, shared, "document", "1", opts, undefined, { stem: s.id });
     const views = s.pages.map((p) => viewsOf(tree, shared, p, team.viewMax));
-    s = { ...s, groups: groupsOf(views), state: "reading", since: now(), pid: process.pid, ...(team.model ? { model: team.model } : {}) };
+    s = { ...s, groups: groupsOf(views), state: "reading", since: now(), pid: process.pid, agent: team.agent, ...(team.model ? { model: team.model } : {}) };
     saveState(tree.root, s);
     const stop = new AbortController();
     const look = setInterval(() => {

package/dist/commands/phone.js

@@ -13,7 +13,9 @@ function stateLines(lang, s) {
             ? ui(lang, "ui.phone.on", { urls: s.addresses.map((a) => a.url).join(", ") })
             : ui(lang, "ui.phone.starting")
         : s.state === "error"
-            ? ui(lang, "ui.phone.error", { why: ui(lang, `ui.phone.why.${s.error?.code ?? "bind-failed"}`) })
+            ? s.error?.waiting
+                ? ui(lang, "ui.phone.waiting")
+                : ui(lang, "ui.phone.error", { why: ui(lang, `ui.phone.why.${s.error?.code ?? "bind-failed"}`) })
             : s.state === "confirm"
                 ? ui(lang, "ui.phone.confirm")
                 : s.state === "declined"

package/dist/commands/readers.js

@@ -189,5 +189,5 @@ export function readers(ctx, tree, shared, kind, first, opts, reportsAt, own = {
             fs.appendFileSync(report, r.text.trim() + "\n");
         return { report, text: fs.readFileSync(report, "utf8"), outcome: r.outcome, ...(r.metrics.costUsd !== undefined ? { costUsd: r.metrics.costUsd } : {}), ...(r.metrics.costPartial ? { costPartial: true } : {}), ...(r.resumeAt ? { resumeAt: r.resumeAt } : {}) };
     };
-    return { model, viewMax: sizes.read, parallel, stem, reportsDir, read, cost: () => cost, runs: () => runs, partial: () => partial, failed, progress };
+    return { agent: agentId, model, viewMax: sizes.read, parallel, stem, reportsDir, read, cost: () => cost, runs: () => runs, partial: () => partial, failed, progress };
 }

package/dist/core/document.js

@@ -1219,19 +1219,27 @@ export function buildResult(tree, s) {
         return out;
     };
     let entries = entriesOf(firsts, false);
+    const firstRead = entries.length > 0;
     const blindRan = blinds.some((r) => r);
-    // the first reader failed, the blind one read: its entries, untranslated
+    // the first reader failed, the blind one read: its entries, untranslated — never held against themselves
     if (!entries.length && blindRan)
         entries = entriesOf(blinds, false);
     let agree = null;
-    if (blindRan && s.readers > 1 && entries.length) {
+    if (blindRan && s.readers > 1 && firstRead) {
         const blindEntries = entriesOf(blinds, true);
         const c = compareReadings(entries, blindEntries);
         entries = c.entries;
         agree = c.agree;
     }
     entries = withTree(tree, entries);
-    const ran = (firsts.some((r) => r?.outcome === "ok") ? 1 : 0) + (blinds.some((r) => r?.outcome === "ok") ? 1 : 0);
+    // a reader ran when it ended well and its report says something (an answer in prose only is no reading)
+    const said = (r) => {
+        if (r?.outcome !== "ok")
+            return false;
+        const rep = read(r);
+        return !!rep && (rep.entries.length > 0 || rep.done || rep.doc.legible !== undefined);
+    };
+    const ran = (firsts.some(said) ? 1 : 0) + (blinds.some(said) ? 1 : 0);
     const usd = s.reports.reduce((n, r) => n + (r.usd ?? 0), 0);
     const partial = s.reports.some((r) => r.outcome !== undefined && (r.usd === undefined || r.partial));
     return {

package/dist/core/live-read.js

@@ -27,6 +27,8 @@ import { EXIT } from "./errors.js";
 import { forApp, refusal } from "./receive.js";
 import { stromLauncher } from "./self.js";
 import { normId } from "./records.js";
+import { metricsDir } from "./metrics.js";
+import { readJournal } from "./readstats.js";
 /** The readings the app may ask, unless the person set others (read.app). */
 export const APP_READ_DEFAULT = { hour: 20, day: 60 };
 /** Readings of the app waiting beside the one being read. */
@@ -213,12 +215,12 @@ export class ReadingsSeen {
         };
     }
 }
-/** /status reads: those at work, and those ended in the last week. */
-export function statusReads(seen, now = Date.now()) {
+/** /status reads: those at work (with the seconds each is expected to take: expectSecs), and those ended in the last week. */
+export function statusReads(seen, agentNow, now = Date.now()) {
     return seen
         .all()
-        .map((r) => r.read)
-        .filter((r) => !FINAL_STATES.includes(r.state) || Date.parse(r.since) > now - STATUS_DAYS * DAY_MS);
+        .filter((r) => !FINAL_STATES.includes(r.read.state) || Date.parse(r.read.since) > now - STATUS_DAYS * DAY_MS)
+        .map((r) => (r.state && !FINAL_STATES.includes(r.read.state) ? { ...r.read, expectSecs: expectOf(seen.root, r.state, agentNow) } : r.read));
 }
 /**
  * GET /reads: the last 90 days, and every reading no source of the research is of. inSource: a source of this tree —
@@ -268,6 +270,7 @@ export function readAccepts(tree, settings, env, seen, now = Date.now()) {
         max: READ_MAX_BYTES,
         pages: DOC_PAGES,
         langs: readLangs(),
+        ...(not ? {} : { expectSecs: expectSecs(tree.root, settings.agent(tree.config).value) }),
     };
 }
 function notReady(tree, settings, env, seen, now) {
@@ -296,6 +299,55 @@ function notReady(tree, settings, env, seen, now) {
     }
     return undefined;
 }
+// ── how long a reading takes ────────────────────────────────────────────────────────────────────────────────────
+/** A reading's seconds before any of this agent's readers ended here (measured 2026-10-20 and 21): Grok's take minutes. */
+export const READ_EXPECT_DEFAULT = { grok: 240 };
+export const READ_EXPECT_OTHERS = 60;
+/** The readers of documents a reading's time is learned from: the last so many of the agent that read to an end. */
+const EXPECT_LAST = 9;
+const expectSeen = new Map();
+/** How long this agent's readers of documents took here (.strom/metrics/readers.jsonl, nothing of the tree), oldest first. */
+function readerSecs(root, agent) {
+    const file = path.join(metricsDir(root), "readers.jsonl");
+    let key = "-";
+    try {
+        const st = fs.statSync(file);
+        key = `${st.mtimeMs}:${st.size}`;
+    }
+    catch {
+        return [];
+    }
+    let had = expectSeen.get(file);
+    if (had?.key !== key) {
+        const secs = new Map();
+        for (const r of readJournal(file)) {
+            const ms = typeof r.wallMs === "number" ? r.wallMs : typeof r.ms === "number" ? r.ms : NaN;
+            if (r.kind !== "document" || r.outcome !== "ok" || typeof r.agent !== "string" || !(ms >= 0))
+                continue;
+            secs.set(r.agent, [...(secs.get(r.agent) ?? []), ms / 1000].slice(-EXPECT_LAST));
+        }
+        had = { key, secs };
+        expectSeen.set(file, had);
+    }
+    return had.secs.get(agent) ?? [];
+}
+/**
+ * The seconds one reading is expected to take with this agent (`rounds`: its readers one after another, a long
+ * document's parts beyond the readers at work at once): the median of its last readers of documents here, else what
+ * the agent's readers took when measured — for the app to say a reading takes minutes, never a promise.
+ */
+export function expectSecs(root, agent, rounds = 1) {
+    const secs = readerSecs(root, agent).sort((a, b) => a - b);
+    const mid = secs.length >> 1;
+    const one = secs.length ? (secs.length % 2 ? secs[mid] : (secs[mid - 1] + secs[mid]) / 2) : (READ_EXPECT_DEFAULT[agent] ?? READ_EXPECT_OTHERS);
+    return Math.max(1, Math.round(one * Math.max(1, rounds)));
+}
+/** A reading at work or queued: how long it is expected to take from its start (since, when it is reading). */
+function expectOf(root, s, agentNow) {
+    // each part of the document read by the first reader and the blind one, as many at once as the readers asked, three at least
+    const jobs = Math.max(1, s.groups.length) * ((s.only === "blind" ? 0 : 1) + (s.readers > 1 ? 1 : 0));
+    return expectSecs(root, s.agent ?? agentNow, Math.ceil(jobs / Math.max(3, s.readers)));
+}
 const BODY_MAX = 16 * 1024;
 /** The names of files sent to be read kept until they are asked (the last ones). */
 const NAMES_KEPT = 200;
@@ -394,7 +446,10 @@ export class AppReadings {
             return this.json(res, n.code, n.body);
         }
         const r = resultForApp(got.result);
-        this.json(res, 200, { ...r, pages: r.pages.map((p) => ({ ...p, image: `read/${id}/page/${p.n}.jpg` })) });
+        // at work or queued: how long it is expected to take from its start
+        const s = FINAL_STATES.includes(got.result.state) ? undefined : loadState(this.b.root, id);
+        const expect = s ? { expectSecs: expectOf(this.b.root, s, this.b.settings().agent(got.tree.config).value) } : {};
+        this.json(res, 200, { ...r, ...expect, pages: r.pages.map((p) => ({ ...p, image: `read/${id}/page/${p.n}.jpg` })) });
     }
     /** GET /read/<id>/page/<n>.jpg: the page upright as a JPEG of 2000 px at most (a HEIC's, a PDF's page too). */
     page(res, id, rest) {

package/dist/core/live.js

@@ -1211,7 +1211,7 @@ function status(root, env, version, seen) {
         ...(intake ? { lastIntake: intake } : {}),
         accepts: accepts(tree, settings, env, seen),
         // the documents the app asked to be read and the research's own readings: at work, and ended in the last week
-        ...(archive || !seen ? {} : { reads: statusReads(seen) }),
+        ...(archive || !seen ? {} : { reads: statusReads(seen, settings.agent(tree.config).value) }),
         inbox: { trees: inboxTrees(root, env), material: materialWaiting(tree) },
         sends: recentSends(root, tree),
         batches: batchStatus(tree),

package/dist/core/phone.js

@@ -511,7 +511,7 @@ export function phoneState(env) {
         // just turned on: its server on the way
         if (c.since && Date.now() - Date.parse(c.since) < 15_000)
             return { ...base, state: "on", since: c.since, phones };
-        return { ...base, state: "error", since: c.since ?? null, error: { code: "bind-failed", detail: run?.ended ? `the server ended: ${run.ended.reason}` : "the server does not run" }, phones };
+        return { ...base, state: "error", since: c.since ?? null, error: { code: "bind-failed", detail: run?.ended ? `the server ended: ${run.ended.reason}` : "the server does not run", waiting: true }, phones };
     }
     const a = readAsk(env);
     if (asking(a))

package/dist/core/reader.js

@@ -226,11 +226,15 @@ export function parseReport(text) {
     }
     return out;
 }
-/** Claude Code settings for a reader: it may read these views and write its report — nothing else. */
+/**
+ * Claude Code settings for a reader: it may read these views and read and write its report — nothing else. Its report
+ * read too: Claude Code edits no file it has not read (found live 2026-10-21: every edit refused, the report kept only
+ * from the answer, a reader that answered in prose lost).
+ */
 export function readerSettings(views, report, toPermission) {
     return {
         permissions: {
-            allow: [...views.map((v) => `Read(${toPermission(v)})`), `Write(${toPermission(report)})`, `Edit(${toPermission(report)})`],
+            allow: [...views.map((v) => `Read(${toPermission(v)})`), `Read(${toPermission(report)})`, `Write(${toPermission(report)})`, `Edit(${toPermission(report)})`],
             deny: ["Bash", "WebFetch", "WebSearch"],
         },
     };

package/dist/core/tree.js

@@ -27,7 +27,7 @@ import { lastBackup } from "./backup.js";
 export const TREE_FILE = "strom.json";
 // between releases the candidate being made (a bridge run from the sources says what it is: the Strom app goes by it);
 // at a release the release's own (package.json)
-export const VERSION = "1.19.0-beta.2";
+export const VERSION = "1.19.0-beta.4";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/package.json

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