strom-research 1.26.0-beta.7 → 1.26.0

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.26.0
 
-*Připravuje se: bety do 1.26.0-beta.7. Oddíl bude úplný s vydáním.*
+*4. 11. 2026 · patří k aplikaci Strom 3.22.0.*
 
 - **Linie výzkumu z aplikace Strom: založit, upravit, pozastavit, seřadit.** Linii jde v aplikaci založit nebo upravit
   (osoba, směr, otázka, meze), pozastavit, ukončit nebo znovu spustit; pořadí linií je pořadí práce a stránka telefonu
@@ -28,6 +28,14 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 - Velký rodokmen převzatý ve Windows (zhruba 1 500 osob a víc) už neskončí chybou gitu o příliš dlouhém příkazu
   (ENAMETOOLONG) bez jediného zapsaného údaje: vše převzaté se zapíše.
 
+- Na velkém výzkumu (stovky úkolů ve frontě, hodně věcí k vyřízení) už aplikace Strom neříká, že výzkum neodpovídá,
+  když jeho agent pracuje: spojení s aplikací spočítá stav výzkumu jednou pro každou změnu, stranou, a aplikaci mezitím
+  odpovídá hned – i během denního úklidu, hledání oprav strom, čtení historie po každé změně a přípravy přehledu pro
+  widget na ploše.
+
+- Vyprávění i poznámka přijdou do aplikace Strom s mezerami, jak jsou napsané: dvě mezery mezi slovy, nezlomitelná
+  ani úzká mezera už se nemění na jednu obyčejnou.
+
 - **Co rozhoduje uživatel, zůstává jeho.** Rozpor výzkumu s úpravou z aplikace Strom, schválení vyprávění nebo jeho nové
   verze a odpověď u větve, která roste, rozhoduje jen uživatel – v aplikaci nebo v Co čeká; agenta strom odmítne a ten
   jen řekne, že to čeká. Vzít zpět, co aplikace poslala nebo co se synchronizovalo (`strom sync undo`), a zahodit strom,

package/CHANGELOG.de.md

@@ -7,7 +7,7 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.26.0
 
-*In Vorbereitung: die Betas bis 1.26.0-beta.7. Der Abschnitt ist mit dem Release vollständig.*
+*4.11.2026 · gehört zur Strom-App 3.22.0.*
 
 - **Die Linien der Forschung aus der Strom-App: anlegen, ändern, pausieren, ordnen.** Eine Linie lässt sich in der App
   anlegen oder ändern (Person, Richtung, Frage, Grenzen), pausieren, beenden oder wieder aufnehmen; die Reihenfolge der
@@ -31,6 +31,15 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 - Ein großer Stammbaum, unter Windows übernommen (etwa 1 500 Personen und mehr), scheitert nicht mehr in git an einer zu
   langen Befehlszeile (ENAMETOOLONG), ohne dass etwas davon bleibt: alles Übernommene wird geschrieben.
 
+- Bei einer großen Forschung (Hunderte Aufgaben in der Warteschlange, vieles wartet) meldet die Strom-App nicht mehr,
+  dass die Forschung nicht antwortet, während ihr Agent arbeitet: die Verbindung berechnet den Stand der Forschung einmal
+  je Änderung, nebenher, und antwortet der App inzwischen sofort – auch während des täglichen Aufräumens, der Suche nach
+  den Korrekturen von strom, dem Lesen der Historie nach jeder Änderung und der Übersicht für das Widget auf dem
+  Schreibtisch.
+
+- Eine Erzählung und eine Notiz kommen mit ihren Leerzeichen in die Strom-App, wie sie geschrieben sind: zwei
+  Leerzeichen zwischen Wörtern, ein geschütztes oder schmales Leerzeichen werden nicht mehr zu einem einfachen.
+
 - **Was der Nutzer entscheidet, bleibt seine Sache.** Einen Widerspruch zwischen der Forschung und einer Änderung in der
   Strom-App, die Freigabe einer Erzählung oder ihrer neuen Fassung und die Antwort zu einem wachsenden Zweig entscheidet
   allein der Nutzer – in der App oder unter Was wartet; der Agent wird abgewiesen und sagt nur, dass es wartet. Auch was

package/CHANGELOG.md

@@ -7,7 +7,7 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 1.26.0
 
-*In preparation: the betas up to 1.26.0-beta.7. The section is complete with the release.*
+*2026-11-04 · goes with the Strom app 3.22.0.*
 
 - **The lines of the research from the Strom app: created, changed, paused, put in order.** A line is created or changed
   in the app (its person, direction, question, limits), paused, ended or taken up again; the order of the lines is the
@@ -29,6 +29,14 @@ The changes of each version in short. The full notes and the install lines are o
 - A big family tree taken in on Windows (some 1 500 people and more) no longer fails in git over a command line too long
   (ENAMETOOLONG) with nothing of it kept: everything taken in is written.
 
+- On a large research (hundreds of tasks in the queue, much waiting) the Strom app no longer says the research does
+  not answer while its agent works: the connection works out the state of the research once for each change, on its
+  own, and answers the app at once meanwhile – also while it keeps its order once a day, finds strom's fixes, reads
+  the history after each change and makes the overview for the desktop widget.
+
+- A story or a note comes to the Strom app with its spaces as written: two between words, a no-break or a narrow
+  space are no longer made one plain space.
+
 - **What is the user's to decide stays the user's.** A disagreement between the research and an edit made in the Strom
   app, the approval of a story or of its new version, and the answer for a branch that grows are decided by the user
   alone – in the app or in What waits; the agent is refused and only says that it waits. Taking back what the app sent

package/CHANGELOG.pl.md

@@ -7,7 +7,7 @@ Zmiany każdej wersji w skrócie. Pełne informacje o wydaniach i polecenia inst
 
 ## 1.26.0
 
-*W przygotowaniu: bety do 1.26.0-beta.7. Sekcja będzie kompletna z wydaniem.*
+*4.11.2026 · współpracuje z aplikacją Strom 3.22.0.*
 
 - **Linie badania z aplikacji Strom: założyć, zmienić, wstrzymać, uporządkować.** Linię można w aplikacji założyć lub
   zmienić (osoba, kierunek, pytanie, granice), wstrzymać, zakończyć lub wznowić; kolejność linii to kolejność pracy, a
@@ -29,6 +29,14 @@ Zmiany każdej wersji w skrócie. Pełne informacje o wydaniach i polecenia inst
 - Duże drzewo przejęte w systemie Windows (około 1500 osób i więcej) nie kończy się już błędem gita o zbyt długim
   poleceniu (ENAMETOOLONG) bez żadnej zapisanej danej: wszystko, co przejęte, zostaje zapisane.
 
+- Przy dużym badaniu (setki zadań w kolejce, wiele spraw czekających) aplikacja Strom nie zgłasza już, że badanie nie
+  odpowiada, gdy pracuje jego agent: połączenie oblicza stan badania raz dla każdej zmiany, osobno, a aplikacji
+  odpowiada w tym czasie od razu – także podczas codziennego porządkowania, szukania poprawek strom, czytania historii
+  po każdej zmianie i przygotowania przeglądu dla widżetu na pulpicie.
+
+- Opowieść i notatka trafiają do aplikacji Strom ze spacjami takimi, jak zostały zapisane: dwie spacje między
+  słowami ani spacja nierozdzielająca lub wąska nie zamieniają się już w jedną zwykłą.
+
 - **To, o czym decyduje użytkownik, pozostaje jego decyzją.** O sprzeczności badania ze zmianą z aplikacji Strom,
   o zatwierdzeniu opowieści lub jej nowej wersji i o odpowiedzi dla rosnącej gałęzi decyduje tylko użytkownik – w
   aplikacji albo w Co czeka; agent zostaje odrzucony i mówi tylko, że to czeka. Cofnięcie tego, co wysłała aplikacja lub

package/dist/core/live.js

@@ -9,6 +9,12 @@
 //
 //   GET <token>/status     the tree, its researches, who is at work, what waits; what the research takes from
 //                          the app (accepts). ?poll=1: the app asking now and then — the bridge's idle time goes on.
+//                          Made once for a state of the research on a thread of its own (core/livestatus.ts) and
+//                          answered from it while the state lasts. ?parts=1 (feature status.parts): without the parts
+//                          that weigh (waiting; queue, queueMore, queueCounts; offLine; researches), with parts {name:
+//                          rev} instead — the same rev, the same part.
+//   GET <token>/status/<part>  one of those parts: {part, rev, head, …its fields as /status carries them}; 404
+//                          status.part for another name.
 //                          A queue item off the lines of a research with several (core/offline.ts) says offLine:
 //                          "occasional" (now and then one), "last" (after the lines' work) or "never" (not taken) — its
 //                          branch's choice, else queue.offLine; one that helps a line says how (helps: question | joins |
@@ -292,6 +298,8 @@ import os from "node:os";
 import http from "node:http";
 import path from "node:path";
 import crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
 import { spawn, spawnSync } from "node:child_process";
 import { configDir, userHome } from "./paths.js";
 import { newerTree, now, SEAL_FOREIGN, sealedHere, Tree, TREE_FILE, VERSION } from "./tree.js";
@@ -307,7 +315,8 @@ import { foundByLine } from "./found.js";
 import { orderMode, orderNumbers, workOrder } from "./order.js";
 import { phrase } from "./phrases.js";
 import { excerptLevel, excerptSizes, INPUT_MARK, LEVELS, turned } from "./excerpt.js";
-import { endWork, excerptAnswer, excerptOnThread, gedOnThread } from "./liveged.js";
+import { endWork, excerptAnswer, excerptOnThread, fixesOnThread, gedOnThread, widgetOnThread } from "./liveged.js";
+import { isStatusPart, splitStatus, StatusKeeper, STATUS_PARTS } from "./livestatus.js";
 import { adoptedAt, adoptedEmpty, adoptionWait, noteAdoptAsked, markSentAgain, undoneSend, undoneSince, failReceived, inboxTrees, markAdopted, noteAdoptFailed, noteNothingSent, pendingAdoption, receiveAdopted, receivedAll, receivedPending, receiveTree, recentSends, stampAppVersion, syncConflicts, SYNC_INBOX, SYNC_MAX_BYTES, namesOf } from "./sync.js";
 import { isArchive, modeOf, settleArchive } from "./mode.js";
 import { actsAsArchive, kindOf, stateOf } from "./state.js";
@@ -1093,7 +1102,7 @@ function idsOf(applied, known) {
     return Object.keys(ids.persons).length || Object.keys(ids.sources).length ? { ids } : {};
 }
 /** What the bridge does that an app may ask about (each added once, never taken away). */
-export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes", "hypothesis.links", "status.recent", "spend.readers", "hypothesis.intree", "archive.permission", "task.check", "waiting.groups", "waiting.sent", "waiting.note", "batch.kept", "live.end", "whats.new", "terminal.choice", "person.marriedSurname", "phone", "read.now", "read.sync", "excerpt.get", "log.sources", "material.assign", "material.thumb", "seal.foreign", "tree.state", "disk.full", "tree.notDownloaded", "sync.removed", "tree.kind", "experiments", "experiments.off", "experiments.link", "experiments.split", "history.events", "history.hide", "experiments.pace", "history.first", "history.regions", "history.hide.all", "history.skip", "history.map", "history.delete", "history.delete.restore", "stories.history", "history.place", "surnames.suggest", "surnames.read", "lineage.read", "duplicates.judge", "quality.dismiss", "quality.read", "person.primary", "fixes.list", "fixes.towns", "history.back", "places.identify", "places.answer", "places.undo", "tasks.offLine", "status.busy", "history.kinds", "history.align", "places.nameKinds", "directions.edit", "directions.order", "directions.found", "directions.people", "offLine.branches", "queue.own", "story.sources", "queue.page"];
+export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes", "hypothesis.links", "status.recent", "spend.readers", "hypothesis.intree", "archive.permission", "task.check", "waiting.groups", "waiting.sent", "waiting.note", "batch.kept", "live.end", "whats.new", "terminal.choice", "person.marriedSurname", "phone", "read.now", "read.sync", "excerpt.get", "log.sources", "material.assign", "material.thumb", "seal.foreign", "tree.state", "disk.full", "tree.notDownloaded", "sync.removed", "tree.kind", "experiments", "experiments.off", "experiments.link", "experiments.split", "history.events", "history.hide", "experiments.pace", "history.first", "history.regions", "history.hide.all", "history.skip", "history.map", "history.delete", "history.delete.restore", "stories.history", "history.place", "surnames.suggest", "surnames.read", "lineage.read", "duplicates.judge", "quality.dismiss", "quality.read", "person.primary", "fixes.list", "fixes.towns", "history.back", "places.identify", "places.answer", "places.undo", "tasks.offLine", "status.busy", "history.kinds", "history.align", "places.nameKinds", "directions.edit", "directions.order", "directions.found", "directions.people", "offLine.branches", "queue.own", "story.sources", "queue.page", "status.parts"];
 /** /status busy: how many sessions and runs work now. */
 function busyOf(tree) {
     const b = busyIn(tree);
@@ -1179,6 +1188,52 @@ function returnOf(ops) {
 export function history(root, tree, range = [`-n${LOG_MAX}`]) {
     return rendered(tree, rawCommits(root, range));
 }
+/**
+ * What the bridge works out for a state of the research (/log for a head, /fixes for their stamp), one at a time: an ask
+ * for the state being made waits for it; an ask for another waits for the next, made once for the state as it is when
+ * that one starts. (An agent's commits a second apart each made one more, side by side on a busy computer: each took
+ * longer, and the answers came ten seconds late and later — found 2026-11-04.)
+ */
+export class OneAtATime {
+    making;
+    next;
+    keyNow;
+    make;
+    constructor(keyNow, make) {
+        this.keyNow = keyNow;
+        this.make = make;
+    }
+    ask(key) {
+        if (!this.making)
+            return this.start(key);
+        if (this.making.key === key)
+            return this.making.done;
+        this.next ??= this.making.done
+            .catch(() => undefined)
+            .then(() => {
+            this.next = undefined;
+            return this.start(this.keyNow());
+        });
+        return this.next;
+    }
+    start(key) {
+        let done;
+        try {
+            done = this.make(key);
+        }
+        catch (e) {
+            done = Promise.reject(e);
+        }
+        const now = { key, done };
+        this.making = now;
+        const over = () => {
+            if (this.making === now)
+                this.making = undefined;
+        };
+        done.then(over, over);
+        return done;
+    }
+}
 /**
  * The history a bridge gives again and again (/log, each change): what git says of a commit is kept by its hash, so
  * after a new commit git is asked about the new ones only — the same entries, in the same order, as history() gives.
@@ -1193,11 +1248,15 @@ export class HistoryCache {
     }
     /** The last LOG_MAX commits up to `h`, newest first (as history(root, tree) at h). */
     log(tree, h) {
+        return rendered(tree, this.raws(h));
+    }
+    /** What git says of the last LOG_MAX commits up to `h`, newest first: asked about the ones it does not know only. */
+    raws(h) {
         if (!h)
             return [];
         const listed = runGit(this.root, ["rev-list", `-n${LOG_MAX}`, h]);
         if (listed.status !== 0)
-            return history(this.root, tree, [`-n${LOG_MAX}`, h]);
+            return rawCommits(this.root, [`-n${LOG_MAX}`, h]);
         const order = listed.stdout.split("\n").filter(Boolean);
         // the newest ones it has not seen; anything else unknown (a history written anew): all of it again
         let k = 0;
@@ -1209,9 +1268,9 @@ export class HistoryCache {
         this.read = k;
         if (fresh.length !== k || fresh.some((c, i) => c.head !== order[i])) {
             this.read = order.length;
-            return this.keep(tree, rawCommits(this.root, [`-n${LOG_MAX}`, h]));
+            return this.keep(rawCommits(this.root, [`-n${LOG_MAX}`, h]));
         }
-        return this.keep(tree, order.map((x, i) => (i < k ? fresh[i] : this.known.get(x))));
+        return this.keep(order.map((x, i) => (i < k ? fresh[i] : this.known.get(x))));
     }
     /** The commits after `from` up to `to` (a change the app hears), newest first; kept for the next /log. */
     since(tree, range) {
@@ -1226,10 +1285,10 @@ export class HistoryCache {
         }
         return rendered(tree, raws);
     }
-    keep(tree, raws) {
+    keep(raws) {
         // oldest first, as since() adds the newer ones after them
         this.known = new Map([...raws].reverse().map((c) => [c.head, c]));
-        return rendered(tree, raws);
+        return raws;
     }
 }
 /**
@@ -1735,7 +1794,11 @@ export function saidAppVersion(req) {
     return said && isAppVersion(said) ? said : undefined;
 }
 /** What the app shows beside the tree. */
-function status(root, env, version, seen) {
+/**
+ * /status worked out (on the bridge's thread of /status, core/livestatus.ts: it reads the whole research — never on the
+ * bridge's own thread, which answers everything else meanwhile).
+ */
+export function status(root, env, version, seen) {
     // a research a newer strom wrote (a beta's, this strom back on the releases): said, never opened
     const refused = newerTree(root, env);
     if (refused) {
@@ -1856,6 +1919,16 @@ function historyRevNow(tree, settings, h, fresh) {
     historyRevs.set(tree.root, { at: Date.now(), head: h, rev });
     return rev;
 }
+/** What this thread knows of the history's rev (the bridge's tick, GET /history): told to the thread of /status. */
+export function historyRevKnown(root) {
+    return historyRevs.get(root);
+}
+/** The history's rev the bridge's thread found, taken by the thread of /status when newer than its own. */
+export function historyRevLearn(root, known) {
+    const had = historyRevs.get(root);
+    if (known && (!had || had.at < known.at))
+        historyRevs.set(root, known);
+}
 /** A tree the app is told the history of: with the experiment on, or one that has anything of it (its history/ folder). */
 function historyShown(tree, settings) {
     return historyOn(tree, settings) || fs.existsSync(path.join(tree.root, "history"));
@@ -1957,6 +2030,13 @@ export function serveLive(root, env) {
     /** The excerpts the tree's file of that head leaves out, though the research has them (the same for every app): /excerpts. */
     let left;
     let log;
+    // /log worked out for one head at a time (the asks for it wait for it together, those for a newer one for the next)
+    const logs = new OneAtATime(() => head(root), (h) => log?.head === h
+        ? Promise.resolve(log.text)
+        : keeper.log(h).then((text) => {
+            log = { head: h, text };
+            return text;
+        }));
     // what git said of each commit, kept: a new commit costs only itself (/log, the changes heard)
     const histories = new HistoryCache(root);
     /** A request that failed: said to the app, written into the log — the bridge goes on. */
@@ -1993,6 +2073,29 @@ export function serveLive(root, env) {
     const receiver = { root, env, note: (text) => noteLive(root, text), track, head: () => head(root), safely };
     // the documents the app asks to be read (live-read.ts): their queue read one at a time, each by a strom of its own
     const reads = new AppReadings({ root, env, settings: () => new Settings(env, {}), note: (text) => noteLive(root, text), safely });
+    // /status made on a thread of its own, kept for the state it was made for (core/livestatus.ts): the state is the commit
+    // and what changes beside it — the day, who is at work, the tree's settings, this computer's, the choices off the lines
+    const stamp = (file) => {
+        try {
+            return String(fs.statSync(file).mtimeMs);
+        }
+        catch {
+            return "-";
+        }
+    };
+    const keeper = new StatusKeeper({
+        root,
+        env,
+        git: gitProgram() ?? "git",
+        stateNow: () => [now().slice(0, 10), JSON.stringify(liveWorkers(root)), stamp(path.join(root, TREE_FILE)), stamp(configFile(env)), stamp(path.join(root, ...OFFLINE_FILE.split("/"))), historyRevs.get(root)?.rev ?? "", JSON.stringify(agentsHere(env)), diskVersion(env)?.version ?? ""].join("|"),
+        known: () => historyRevKnown(root),
+        inline: (version, key) => splitStatus(status(root, env, version, reads.seen), key),
+        logHere: (h) => JSON.stringify({ entries: histories.log(Tree.open(root, env), h) }),
+        note: (text) => noteLive(root, text),
+    });
+    // the app's version of the last /status asked: made for it again before it asks, when a commit comes
+    // (a bridge that takes over from one of an older strom: the version the app asked that one with)
+    let statusVersion = env.STROM_LIVE_STATUS_FOR || undefined;
     /**
      * What changes something (a send, an adoption, an original, a batch, the app saying nothing came): one line in the
      * log of how it went — its answer's code, marks and why, so the research keeps a trace of each (found on Windows: a
@@ -2176,15 +2279,38 @@ export function serveLive(root, env) {
     // strom's fixes as the app was last told them, while nothing they are found by changed (fixesStamp) and the research
     // is as much of an archive as then
     let fixesKept;
+    const fixesNow = (m) => {
+        const tree = Tree.open(root, env);
+        const settings = new Settings(env, {});
+        const archive = actsAsArchive(tree);
+        return { tree, settings, archive, key: `${m.fixesStamp(tree, m.fixEnvOf(settings, env, tree))}|${archive}` };
+    };
+    let fixes;
+    const fixesOf = (m) => (fixes ??= new OneAtATime(() => fixesNow(m).key, (key) => {
+        if (fixesKept?.key === key)
+            return Promise.resolve(fixesKept.text);
+        // the thread failed (or is turned off): found here, as before
+        const here = () => {
+            const now = fixesNow(m);
+            return { key: now.key, text: JSON.stringify(m.fixesForApp(now.tree, now.settings, env, { archive: now.archive })) };
+        };
+        const found = env.STROM_LIVE_STATUS_THREAD === "0" ? Promise.resolve().then(here) : fixesOnThread({ root, env }).catch(here);
+        return found.then((made) => {
+            // kept for the stamp the research was read at (a commit since: another)
+            fixesKept = made;
+            return made.text;
+        });
+    }));
     const giveFixes = (req, res) => {
         import("../commands/fixchecks.js").then((m) => safely(req, res, () => {
-            const tree = Tree.open(root, env);
-            const settings = new Settings(env, {});
-            const archive = actsAsArchive(tree);
-            const key = `${m.fixesStamp(tree, m.fixEnvOf(settings, env, tree))}|${archive}`;
-            if (fixesKept?.key !== key)
-                fixesKept = { key, text: JSON.stringify(m.fixesForApp(tree, settings, env, { archive })) };
-            res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }).end(fixesKept.text);
+            const { key } = fixesNow(m);
+            const answer = (text) => {
+                if (!req.destroyed)
+                    res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }).end(text);
+            };
+            if (fixesKept?.key === key)
+                return answer(fixesKept.text);
+            fixesOf(m).ask(key).then(answer, (e) => failed(req, res, e));
         }), (e) => failed(req, res, e));
     };
     const afterQuiet = (fn) => {
@@ -2244,6 +2370,9 @@ export function serveLive(root, env) {
         }
         const origin = allowedOrigin(req.headers.origin);
         const version = appVersionOf(req, new Settings(env, {}));
+        // what the app sends may change what /status says without a commit (a send waiting, a reading, a batch): made again
+        if (req.method !== "GET" && req.method !== "OPTIONS")
+            res.once("finish", () => keeper.forget());
         if (origin) {
             res.setHeader("Access-Control-Allow-Origin", origin);
             res.setHeader("Vary", "Origin");
@@ -2604,10 +2733,20 @@ export function serveLive(root, env) {
                 const got = groupNote(decoded(sub));
                 res.writeHead(got.code, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }).end(JSON.stringify(got.body));
             }
-            else if (what === "status") {
-                // what is answered is made first: a read that fails can still answer 500
-                const text = JSON.stringify(status(root, env, version, reads.seen));
-                res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }).end(text);
+            else if (what === "status" && !sub) {
+                // made on its thread, kept for the state of the research (core/livestatus.ts); parts=1: without the parts that
+                // weigh, their revs instead (feature status.parts: the app asks a part only when its rev changed)
+                const lite = new URLSearchParams((req.url ?? "").split("?")[1] ?? "").get("parts") === "1";
+                statusVersion = version;
+                keeper.get(version).then((made) => res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }).end(lite ? made.lite : made.full), (e) => failed(req, res, e));
+            }
+            else if (what === "status" && sub && !act) {
+                // one part of /status that weighs (feature status.parts): {part, rev, head, …its fields as /status carries them}
+                const part = decoded(sub);
+                if (!isStatusPart(part))
+                    res.writeHead(404, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }).end(JSON.stringify(refusal(`no such part of /status: ${Object.keys(STATUS_PARTS).join(", ")}`, "status.part")));
+                else
+                    keeper.get(version).then((made) => res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }).end(made.parts[part].text), (e) => failed(req, res, e));
             }
             else if (what === "whats-new") {
                 // what is new in this strom, from the changelog shipped with it (the app's window "What's new")
@@ -2626,22 +2765,33 @@ export function serveLive(root, env) {
                     recentChanges(root, env, hours).then((r) => (r ? json(200, r) : json(404, { error: "the research has no commit yet" })), (e) => failed(req, res, e));
             }
             else if (what === "log") {
+                // on the thread of /status: git asked of the commits it does not know (a hundred at first: a second), each read
+                // as the app reads it (every session, each name and task: a second on a large research, at each change)
                 const h = head(root);
-                if (!log || log.head !== h)
-                    log = { head: h, text: JSON.stringify({ entries: histories.log(Tree.open(root, env), h) }) };
-                res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }).end(log.text);
+                const answer = (text) => {
+                    if (!req.destroyed)
+                        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }).end(text);
+                };
+                if (log?.head === h)
+                    answer(log.text);
+                else
+                    logs.ask(h).then(answer, (e) => failed(req, res, e));
             }
             else if (what === "tree.ged" || what === "images.ged") {
                 // made when the commits stop coming (an agent's commands one after another): once for them all
                 afterQuiet(() => giveGed(res, version).catch((e) => failed(req, res, e)));
             }
             else if (what === "events") {
-                const hello = JSON.stringify(status(root, env, version, reads.seen));
-                res.writeHead(200, { "Content-Type": "text/event-stream; charset=utf-8", "Cache-Control": "no-store", Connection: "keep-alive" });
-                res.write(`event: hello\ndata: ${hello}\n\n`);
-                streams.add(res);
-                req.on("close", () => streams.delete(res));
-                res.on("error", () => streams.delete(res));
+                statusVersion = version;
+                keeper.get(version).then((made) => {
+                    if (req.destroyed)
+                        return;
+                    res.writeHead(200, { "Content-Type": "text/event-stream; charset=utf-8", "Cache-Control": "no-store", Connection: "keep-alive" });
+                    res.write(`event: hello\ndata: ${made.full}\n\n`);
+                    streams.add(res);
+                    req.on("close", () => streams.delete(res));
+                    res.on("error", () => streams.delete(res));
+                }, (e) => failed(req, res, e));
             }
             else
                 res.writeHead(404).end();
@@ -4915,7 +5065,12 @@ export function serveLive(root, env) {
             if (!up)
                 resolve();
         });
-        server.listen(wanted, "127.0.0.1");
+        // taking over from the bridge of an older strom (it answers meanwhile): /status made first, so the app's first ask
+        // here waits for no thread's start (a few seconds on a slow computer) — at most a while
+        if (env.STROM_LIVE_RENEWED)
+            void keeper.ready(statusVersion, Number(env.STROM_LIVE_READY_MS ?? 10_000)).then(() => server.listen(wanted, "127.0.0.1"));
+        else
+            server.listen(wanted, "127.0.0.1");
         server.once("listening", () => {
             up = true;
             const port = server.address().port;
@@ -4978,7 +5133,16 @@ export function serveLive(root, env) {
             let workers = safe("the start", () => JSON.stringify(atWork(seen))) ?? "";
             // the research on the desktop (the Strom Widget of a Mac, the widget of Windows 11): the tree's overview written
             // while the bridge runs (core/widget.ts; none but on macOS and Windows) — the first a moment after the start, never in its way
-            const widget = widgetWriter(root, env);
+            // (worked out on a thread of its own: a second and more on a large research, every check; off: here, as before —
+            // the thread ended with the bridge says nothing)
+            let widgetEnds = false;
+            const widget = widgetWriter(root, env, process.platform, Date.now, env.STROM_LIVE_STATUS_THREAD === "0"
+                ? undefined
+                : (now) => widgetOnThread({ root, env, now }).catch((e) => {
+                    if (!widgetEnds)
+                        noteLive(root, `the widget failed (tried again): ${errorText(e)}`);
+                    throw e;
+                }));
             if (widget)
                 setTimeout(() => safe("the widget", () => widget.tick(true)), 1000).unref?.();
             const send = (event, data) => {
@@ -5006,7 +5170,34 @@ export function serveLive(root, env) {
             // something the app sent written now: its body coming, a strom of the bridge's writing it (a send, an adoption, an
             // original, a batch, the person's answer)
             const writesNow = () => incoming > 0 || writing !== undefined || adopting || kids.size > 0;
-            const busy = () => writesNow() || retryAt !== undefined;
+            const busy = () => writesNow() || retryAt !== undefined || tidying;
+            // the order kept on a thread of its own (core/livetidy-worker.ts): seconds on a large research, the bridge answers
+            // meanwhile; a thread that cannot start: kept here, as before
+            let tidying = false;
+            const tidyOffThread = () => {
+                let w;
+                try {
+                    const env1 = Object.fromEntries(Object.entries(env).filter((e) => typeof e[1] === "string"));
+                    w = new Worker(new URL(`./livetidy-worker${path.extname(fileURLToPath(import.meta.url))}`, import.meta.url), { workerData: { root, env: env1 }, env: env1 });
+                }
+                catch (e) {
+                    noteLive(root, `keeping order not on its thread (${errorText(e)}): here`);
+                    return safe("keeping order", () => autoTidy(Tree.open(root, env)));
+                }
+                tidying = true;
+                w.unref();
+                const from = Date.now();
+                const done = (why) => {
+                    if (!tidying)
+                        return;
+                    tidying = false;
+                    noteLive(root, why ? `keeping order: ${why}` : `kept in order on its thread (${Date.now() - from} ms)`);
+                    void w.terminate();
+                };
+                w.once("message", (m) => done(m.ok ? undefined : m.message));
+                w.once("error", (e) => done(errorText(e)));
+                w.once("exit", (code) => done(code ? `its thread ended (exit ${code})` : undefined));
+            };
             // The new bridge started while this one still answers: once it runs (its code loaded, a few seconds on a slow
             // computer) it asks this one to end through the stop file and takes the port at once, as a bridge wanted by
             // another strom does — the app waits a moment, not the new one's start (found: ~4.5 s without an answer when this
@@ -5031,7 +5222,7 @@ export function serveLive(root, env) {
                 };
                 let child;
                 try {
-                    child = spawnBridge(root, env, { STROM_LIVE_RENEWED: disk.version });
+                    child = spawnBridge(root, env, { STROM_LIVE_RENEWED: disk.version, STROM_LIVE_STATUS_FOR: statusVersion ?? "" });
                 }
                 catch (e) {
                     renewing = false;
@@ -5061,7 +5252,7 @@ export function serveLive(root, env) {
             let qualitySeen = qualityRev({ root }, "0000000");
             const HISTORY_MS = Number(env.STROM_LIVE_HISTORY_MS ?? 60_000);
             // the first a few minutes after it starts, then once a day
-            let tidied = Date.now() - Number(env.STROM_TIDY_MS ?? 24 * 3600_000) + 5 * 60_000;
+            let tidied = Date.now() - Number(env.STROM_TIDY_MS ?? 24 * 3600_000) + Number(env.STROM_TIDY_FIRST_MS ?? 5 * 60_000);
             const timer = setInterval(() => {
                 // its research gone (taken off the computer, a test's folder, moved; its .strom deleted): nothing to follow —
                 // even while handing over (found: bridges of a folder removed in the middle of it left running for hours)
@@ -5101,12 +5292,15 @@ export function serveLive(root, env) {
                 // what strom keeps beside the research in order, once a day (a tree tidied once; never while a send is written)
                 if (Date.now() - tidied > Number(env.STROM_TIDY_MS ?? 24 * 3600_000) && !busy()) {
                     tidied = Date.now();
-                    safe("keeping order", () => autoTidy(Tree.open(root, env)));
+                    tidyOffThread();
                 }
                 // the idle time runs only while nobody works in the tree (a run waiting for its gate works too): the app watching
                 // the tree without following it (/status?poll=1) still finds the bridge while an agent is at work
                 // the queue of the documents the app asked to be read (one at a time); what changed of the readings, for the event read
                 const readsChanged = safe("the readings", () => reads.tick()) ?? [];
+                // what /status says of the readings changed without a commit: made again at the next ask
+                if (readsChanged.length)
+                    keeper.forget();
                 if (streams.size || anyoneAtWork(root) || reads.active())
                     lastAsked = Date.now();
                 if (idleMs > 0 && Date.now() - lastAsked > idleMs)
@@ -5124,6 +5318,8 @@ export function serveLive(root, env) {
                         const entries = histories.since(Tree.open(root, env), seen ? [`-n${LOG_MAX}`, `${seen}..${h}`] : ["-1", h]);
                         send("change", { head: h, what: subjects(root, seen, h), at: at ?? new Date().toISOString(), entries });
                         seen = h;
+                        // the app asks /status after a change: made for the new commit before it asks
+                        keeper.warm(statusVersion);
                     }
                     for (const r of readsChanged)
                         send("read", r);
@@ -5198,7 +5394,9 @@ export function serveLive(root, env) {
                 clearInterval(keepAlive);
                 clearInterval(stopAsked);
                 // what a thread makes for the app is wanted no more
+                widgetEnds = true;
                 endWork();
+                keeper.end();
                 if (stopWaits)
                     safe("the stop's wait", () => fs.rmSync(liveBusyFile(root), { force: true }));
                 safe("the widget", () => widget?.end(reason === "gone"));

package/dist/core/liveged-worker.js

@@ -1,6 +1,6 @@
 // The bridge's thread for what takes long (core/liveged.ts): one job, its result said back, then it ends.
 import { parentPort, workerData } from "node:worker_threads";
-import { buildGed, excerptAnswer } from "./liveged.js";
+import { buildGed, excerptAnswer, fixesHere, widgetHere } from "./liveged.js";
 const job = workerData;
 let done;
 let move = [];
@@ -11,6 +11,12 @@ try {
         // the file's bytes handed over, not copied (a buffer of its own: buildGed)
         move = [made.bytes.buffer];
     }
+    else if (job.job === "widget") {
+        done = { ok: true, made: await widgetHere(job.ask) };
+    }
+    else if (job.job === "fixes") {
+        done = { ok: true, made: await fixesHere(job.ask) };
+    }
     else {
         const a = excerptAnswer(job.ask);
         done = { ok: true, made: { code: a.code, text: JSON.stringify(a.body) } };

package/dist/core/liveged.js

@@ -16,6 +16,7 @@ import { surnamesForExport } from "./surnames.js";
 import { lineMarks } from "./lineages.js";
 import { LINK_SCHEME, linkScheme } from "./links.js";
 import { refusal } from "./receive.js";
+import { actsAsArchive } from "./state.js";
 /** The tree for the app at a head, for a version of the app (made where it is called: on a thread of its own in the bridge). */
 export function buildGed(ask) {
     const { root, env, head: h, version } = ask;
@@ -156,6 +157,31 @@ export async function gedOnThread(ask) {
     // a buffer came over as its bytes (Uint8Array)
     return { ...made, bytes: Buffer.from(made.bytes.buffer, made.bytes.byteOffset, made.bytes.byteLength) };
 }
+/**
+ * strom's fixes of a research found on a thread of its own (they read every person, source and reading: seconds on a
+ * large research, after each of its commits, as the app asks for them at each new head — found 2026-11-04).
+ */
+export async function fixesOnThread(ask) {
+    return (await onThread({ job: "fixes", ask })).made;
+}
+/** strom's fixes of a research for the app, found here: the stamp they are found by, and what they say. */
+export async function fixesHere(ask) {
+    const m = await import("../commands/fixchecks.js");
+    const tree = Tree.open(ask.root, ask.env);
+    const settings = new Settings(ask.env, {});
+    const archive = actsAsArchive(tree);
+    const key = `${m.fixesStamp(tree, m.fixEnvOf(settings, ask.env, tree))}|${archive}`;
+    return { key, text: JSON.stringify(m.fixesForApp(tree, settings, ask.env, { archive })) };
+}
+/** The widget's overview of a research worked out on a thread of its own (undefined: an archive, nothing to show). */
+export async function widgetOnThread(ask) {
+    return (await onThread({ job: "widget", ask })).made ?? undefined;
+}
+/** The widget's overview of a research, worked out here (the thread's part). */
+export async function widgetHere(ask) {
+    const { widgetTree } = await import("./widget.js");
+    return widgetTree(ask.root, ask.env, { running: true, now: ask.now }) ?? null;
+}
 /** One source's excerpts made on a thread of its own: the status and the JSON text. */
 export async function excerptOnThread(ask) {
     const done = await onThread({ job: "excerpt", ask });

package/dist/core/livestatus-worker.js

@@ -0,0 +1,29 @@
+// The bridge's thread for /status (core/livestatus.ts): one for the bridge's life, each ask worked out in turn, what it
+// worked out before (the queue's order, the readings, the history's rev) kept between them.
+import { parentPort, workerData } from "node:worker_threads";
+import { HistoryCache, historyRevLearn, status } from "./live.js";
+import { Tree } from "./tree.js";
+import { ReadingsSeen } from "./live-read.js";
+import { splitStatus } from "./livestatus.js";
+const { root, env } = workerData;
+const seen = new ReadingsSeen(root, env);
+// what git said of the commits, kept: a /log asks it about the new ones only
+const histories = new HistoryCache(root);
+parentPort.on("message", (job) => {
+    let done;
+    try {
+        if ("log" in job) {
+            const made = JSON.stringify({ entries: histories.log(Tree.open(root, env), job.log) });
+            parentPort.postMessage({ id: job.id, ok: true, made });
+            return;
+        }
+        // the time it was asked: an ask made while this one was worked out is newer
+        const at = Date.now();
+        historyRevLearn(root, job.known);
+        done = { id: job.id, ok: true, made: splitStatus(status(root, env, job.version, seen), job.key, at) };
+    }
+    catch (e) {
+        done = { id: job.id, ok: false, message: e?.message ?? String(e), ...(e?.stack ? { stack: e.stack } : {}) };
+    }
+    parentPort.postMessage(done);
+});

package/dist/core/livestatus.js

@@ -0,0 +1,227 @@
+// The bridge's /status (core/live.ts) made on a thread of its own and kept for the state of the research it was made
+// for. Working it out reads the whole research — every task for the queue, what waits for the person, the places, the
+// lines — half a second on a research of a thousand tasks, seconds on a busy computer: made on the bridge's thread it
+// held every other answer meanwhile, and the app, asking now and then with a short patience, said the research does not
+// answer (found 2026-11-04 on a research of ~470 tasks in the queue while its agent wrote). Now:
+//   - made once for a state (the commit, who is at work, the tree's and this computer's settings, the day, the agents
+//     here, the history's rev, strom on disk) and answered from what was made while that state lasts; looked at again in
+//     the background after STATUS_FRESH_MS, waited for as a new state after STATUS_OLD_MS;
+//   - made on a thread of its own (livestatus-worker.ts, one for the bridge's life, keeping what it worked out), so the
+//     bridge answers everything else meanwhile; one making at a time, the asks for the same state wait for it together;
+//   - an ask while the research changes waits for the new state at most STATUS_WAIT_MS, else is answered what was made
+//     for the state before (never nothing: the app's patience is short) — the next ask has the new one;
+//   - the parts that weigh (what waits, the queue, the work off the lines, the lines) each with its rev: an app that
+//     says parts=1 is answered the rest and the revs, and asks a part (GET /status/<part>) only when its rev changed.
+import path from "node:path";
+import crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { execFile } from "node:child_process";
+import { Worker } from "node:worker_threads";
+/** The parts of /status that weigh, each with the fields of /status it carries (GET /status/<part>, feature status.parts). */
+export const STATUS_PARTS = {
+    waiting: ["waiting"],
+    queue: ["queue", "queueMore", "queueCounts"],
+    offLine: ["offLine"],
+    researches: ["researches"],
+};
+export function isStatusPart(name) {
+    return !!name && Object.hasOwn(STATUS_PARTS, name);
+}
+/** The rev of a part: what it says, in short (the same JSON, the same rev). */
+function revOf(text) {
+    return crypto.createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+/** /status as worked out, made into the answers (made where it is worked out: on the thread). */
+export function splitStatus(status, key, at = Date.now()) {
+    const parts = {};
+    const lite = { ...status };
+    const revs = {};
+    for (const [name, fields] of Object.entries(STATUS_PARTS)) {
+        const of = {};
+        for (const f of fields) {
+            if (status[f] !== undefined)
+                of[f] = status[f];
+            delete lite[f];
+        }
+        const said = JSON.stringify(of);
+        const rev = revOf(said);
+        revs[name] = rev;
+        parts[name] = { rev, text: JSON.stringify({ part: name, rev, head: status.head, ...of }) };
+    }
+    return { key, at, full: JSON.stringify(status), lite: JSON.stringify({ ...lite, parts: revs }), parts };
+}
+/** Where the thread's code is: next to this file, the same kind (the sources run as .ts, the package as .js). */
+const WORKER = new URL(`./livestatus-worker${path.extname(fileURLToPath(import.meta.url))}`, import.meta.url);
+/** How long what was made is answered without looking again (a background look after it). */
+export const STATUS_FRESH_MS = 5_000;
+/**
+ * How old what was made may be answered at once (made again in the background): what /status says beside the state
+ * (the phone, the spend, a newer strom) is at most that late. Older: made again, waited for as a new state.
+ */
+export const STATUS_OLD_MS = 60_000;
+/** How long an ask waits for the new state when what was made is of another state (then: what was made). */
+export const STATUS_WAIT_MS = 1_500;
+/** The commit the research is at: asked of git without holding the bridge (another process). */
+function headAsync(root, git) {
+    return new Promise((resolve) => {
+        execFile(git, ["rev-parse", "HEAD"], { cwd: root, encoding: "utf8", windowsHide: true, timeout: 10_000 }, (err, out) => resolve(err ? "" : String(out).trim()));
+    });
+}
+/** /status of one bridge: made on a thread, kept for its state, answered at once while that state lasts. */
+export class StatusKeeper {
+    o;
+    worker;
+    broken = false;
+    seq = 0;
+    waiting = new Map();
+    /** What was made last, for each version of the app. */
+    made = new Map();
+    /** What is being made, for each version and state. */
+    making = new Map();
+    /** Made again at the next ask whatever the state says (a write of the app's, written by the bridge). */
+    stale = false;
+    ended = false;
+    constructor(o) {
+        this.o = o;
+    }
+    /** The state of the research now: its commit and what changes beside it. */
+    async keyNow() {
+        const h = await headAsync(this.o.root, this.o.git ?? "git");
+        return `${h}\n${this.o.stateNow()}`;
+    }
+    /** What changed beside the state (the app wrote through the bridge): made again at the next ask. */
+    forget() {
+        this.stale = true;
+    }
+    /**
+     * /status for the app of that version: what was made for the state now (looked at again in the background once
+     * older than STATUS_FRESH_MS), else made now — waited for at most STATUS_WAIT_MS when something was made before.
+     */
+    async get(version) {
+        const v = version ?? "";
+        const key = await this.keyNow();
+        const had = this.made.get(v);
+        const age = had ? Date.now() - had.at : Infinity;
+        if (had && had.key === key && !this.stale && age <= STATUS_OLD_MS) {
+            if (age > STATUS_FRESH_MS)
+                this.make(version, key).catch(() => undefined);
+            return had;
+        }
+        this.stale = false;
+        const fresh = this.make(version, key);
+        if (!had)
+            return fresh;
+        let timer;
+        const late = new Promise((resolve) => {
+            timer = setTimeout(() => resolve(had), Number(this.o.env.STROM_LIVE_STATUS_WAIT_MS ?? STATUS_WAIT_MS));
+        });
+        try {
+            return await Promise.race([fresh, late]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /** Made before the app asks (a new commit heard): ready when it asks. */
+    warm(version) {
+        if (this.ended)
+            return;
+        this.keyNow()
+            .then((key) => (this.made.get(version ?? "")?.key === key ? undefined : this.make(version, key)))
+            .catch(() => undefined);
+    }
+    /** /status made for the state now before the bridge answers (it takes over from another): waited for at most ms. */
+    ready(version, ms) {
+        let timer;
+        return Promise.race([
+            this.get(version).then(() => undefined, () => undefined),
+            new Promise((resolve) => (timer = setTimeout(resolve, ms))),
+        ]).finally(() => clearTimeout(timer));
+    }
+    /** The thread ended with the bridge. */
+    end() {
+        this.ended = true;
+        const w = this.worker;
+        this.worker = undefined;
+        if (w)
+            void w.terminate();
+    }
+    make(version, key) {
+        const v = version ?? "";
+        const id = `${v}\n${key}`;
+        const had = this.making.get(id);
+        if (had)
+            return had;
+        const p = this.onThread(version, key)
+            .catch((e) => {
+            // a thread that fails: worked out here, as before threads (the answer matters more than the bridge's time)
+            this.o.note(`/status not made on its thread (${e.message}): made on the bridge's`);
+            return this.o.inline(version, key);
+        })
+            .then((m) => {
+            const before = this.made.get(v);
+            if (!before || before.at <= m.at)
+                this.made.set(v, m);
+            return m;
+        })
+            .finally(() => this.making.delete(id));
+        this.making.set(id, p);
+        return p;
+    }
+    /** /log at a commit (its JSON text): on the thread, in turn with /status; here when it cannot be. */
+    log(head) {
+        const here = () => this.o.logHere(head);
+        if (this.broken || this.o.env.STROM_LIVE_STATUS_THREAD === "0")
+            return Promise.resolve().then(here);
+        const w = this.thread();
+        const id = ++this.seq;
+        return new Promise((resolve, reject) => {
+            this.waiting.set(id, { resolve, reject });
+            w.postMessage({ id, log: head });
+        }).catch(here);
+    }
+    onThread(version, key) {
+        if (this.broken || this.o.env.STROM_LIVE_STATUS_THREAD === "0")
+            return Promise.resolve(this.o.inline(version, key));
+        const w = this.thread();
+        const id = ++this.seq;
+        return new Promise((resolve, reject) => {
+            this.waiting.set(id, { resolve, reject });
+            w.postMessage({ id, version, key, known: this.o.known?.() });
+        });
+    }
+    thread() {
+        if (this.worker)
+            return this.worker;
+        const env = Object.fromEntries(Object.entries(this.o.env).filter((e) => typeof e[1] === "string"));
+        const w = new Worker(WORKER, { workerData: { root: this.o.root, env }, env });
+        // nothing to wait for once the bridge ends
+        w.unref();
+        w.on("message", (done) => {
+            const asked = this.waiting.get(done.id);
+            if (!asked)
+                return;
+            this.waiting.delete(done.id);
+            if (done.ok)
+                asked.resolve(done.made);
+            else
+                asked.reject(Object.assign(new Error(done.message), done.stack ? { stack: done.stack } : {}));
+        });
+        const gone = (why) => {
+            if (this.worker === w)
+                this.worker = undefined;
+            // a thread that cannot start or dies: the next ones made here (once said)
+            if (!this.ended && !this.broken) {
+                this.broken = true;
+                this.o.note(`the thread of /status ended (${why}): /status made on the bridge's thread`);
+            }
+            for (const [, asked] of this.waiting)
+                asked.reject(new Error(why));
+            this.waiting.clear();
+        };
+        w.on("error", (e) => gone(e.message));
+        w.on("exit", (code) => gone(`exit ${code}`));
+        this.worker = w;
+        return w;
+    }
+}

package/dist/core/livetidy-worker.js

@@ -0,0 +1,14 @@
+// The bridge's order kept once a day (core/tidy.ts autoTidy) on a thread of its own: the summary of the reading of scans
+// it makes again reads every task and session of the research — seconds on a research of thousands of tasks, ~11 s on
+// one of 5 000 (found 2026-11-04) — and on the bridge's thread nothing else was answered meanwhile.
+import { parentPort, workerData } from "node:worker_threads";
+import { Tree } from "./tree.js";
+import { autoTidy } from "./tidy.js";
+const { root, env } = workerData;
+try {
+    autoTidy(Tree.open(root, env));
+    parentPort.postMessage({ ok: true });
+}
+catch (e) {
+    parentPort.postMessage({ ok: false, message: e?.message ?? String(e) });
+}

package/dist/core/tree.js

@@ -31,7 +31,7 @@ export const TREE_FILE = "strom.json";
 export const SEAL_FOREIGN = "seal.foreign";
 // 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.26.0-beta.7";
+export const VERSION = "1.26.0";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/dist/core/widget.js

@@ -450,8 +450,12 @@ export function dropWidgetTree(dir, key, last) {
     }
     writeWidgetIndex(dir);
 }
-/** The writer of a tree's bridge; none but on macOS and Windows. */
-export function widgetWriter(root, env, platform = process.platform, clock = Date.now) {
+/**
+ * The writer of a tree's bridge; none but on macOS and Windows. `make`: the overview worked out elsewhere (the bridge: on
+ * a thread of its own — it reads every task, person and finding: a second and more on a large research, every
+ * WIDGET_CHECK_MS, the bridge answering nothing meanwhile; found 2026-11-04); without it, here.
+ */
+export function widgetWriter(root, env, platform = process.platform, clock = Date.now, make) {
     const dir = widgetDir(env, platform);
     if (!dir)
         return undefined;
@@ -475,6 +479,27 @@ export function widgetWriter(root, env, platform = process.platform, clock = Dat
         said = c;
         written = now;
     };
+    // an overview being worked out elsewhere (`make`), and the bridge ended meanwhile (what comes after is written by nobody)
+    let making = false;
+    let ended = false;
+    const take = (t, now) => {
+        if (!t) {
+            // an archive now: nothing of it on the desktop
+            if (key)
+                dropWidgetTree(dir, key, last);
+            key = undefined;
+            last = undefined;
+            held = undefined;
+            said = "";
+            return;
+        }
+        key = t.treeKey;
+        last = t;
+        const c = content(t);
+        if (c === said && now - written < beatMs && !held)
+            return;
+        write(t, c, now);
+    };
     return {
         tick(force = false) {
             const now = clock();
@@ -483,26 +508,24 @@ export function widgetWriter(root, env, platform = process.platform, clock = Dat
                     write({ ...held.t, generatedAt: isoSecond(now), lastActiveAt: isoSecond(now) }, held.c, now);
                 return;
             }
-            checked = now;
-            const t = widgetTree(root, env, { running: true, now });
-            if (!t) {
-                // an archive now: nothing of it on the desktop
-                if (key)
-                    dropWidgetTree(dir, key, last);
-                key = undefined;
-                last = undefined;
-                held = undefined;
-                said = "";
-                return;
+            if (!make) {
+                checked = now;
+                return take(widgetTree(root, env, { running: true, now }), now);
             }
-            key = t.treeKey;
-            last = t;
-            const c = content(t);
-            if (c === said && now - written < beatMs && !held)
+            if (making)
                 return;
-            write(t, c, now);
+            checked = now;
+            making = true;
+            make(now).then((t) => {
+                making = false;
+                if (!ended)
+                    take(t, clock());
+            }, 
+            // (said by `make`): looked at again at the next check
+            () => (making = false));
         },
         end(gone) {
+            ended = true;
             if (!key)
                 return;
             // what the file says now is no longer what was written: the next look writes it again

package/dist/gedcom/lines.js

@@ -108,13 +108,17 @@ export class GedWriter {
         for (let i = first; i < value.length; i += next)
             this.raw(level + 1, "CONC", value.slice(i, i + next));
     }
-    /** A tag with free text of any length: CONT for line breaks, CONC for long lines. */
+    /**
+     * A tag with free text of any length: CONT for line breaks, CONC for long lines. The text as it is written, its
+     * spaces kept — two between words, a no-break or narrow one (found 2026-11-04: a story's two spaces came to the app
+     * as one); only a tab or a form feed is a space, and the spaces round a line go (a line's value starts after one).
+     */
     text(level, tag, text) {
         const paragraphs = text
             .normalize("NFC")
             .replace(/\r\n?/g, "\n")
             .split("\n")
-            .map((p) => p.replace(/\s+/g, " ").trim().replace(/@/g, "@@"));
+            .map((p) => p.replace(/[\t\v\f]/g, " ").trim().replace(/@/g, "@@"));
         paragraphs.forEach((para, i) => {
             if (i === 0)
                 this.long(level, tag, para);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.26.0-beta.7",
+  "version": "1.26.0",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "stromLayout": 2,
@@ -59,8 +59,5 @@
   "devDependencies": {
     "@types/node": "^22.20.4",
     "typescript": "^7.0.2"
-  },
-  "publishConfig": {
-    "tag": "beta"
   }
 }