strom-research 1.20.0 → 1.21.0-beta.2

package/CHANGELOG.cs.md

@@ -5,6 +5,20 @@
 Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou na
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (anglicky).
 
+## 1.21.0
+
+*Připravuje se: bety do 1.21.0-beta.2. Oddíl bude úplný s vydáním.*
+
+- **„Čeká“ říká, co aplikace Strom neukazuje.** Řádek v menu a `strom plan` řekne, kolik z čekajícího je jen tady
+  v terminálu a kolik čeká na odpověď; zbytek je číslo, které ukazuje aplikace Strom, takže se obě shodují.
+- **„Co čeká“ dává vlastní věci terminálu na začátek.** Co ukazuje jen terminál (rozpor vlastní úpravy, odeslání
+  z aplikace, otázka ke čtení skenů), je pod „Jen tady v terminálu“, zbytek pod „I v aplikaci Strom“.
+- **`strom input assign`, `hide` a `unskip` řeknou, co se změnilo**, v jazyce výzkumu: každý soubor, každý
+  uvolněný nebo nový úkol, lidi jménem a jak změnu vrátit. Jejich JSON zůstává stejný.
+- **Přehled výzkumu pro widget na ploše macOS.** Dokud běží most (`strom live`), drží se přehled každého stromu
+  v souboru pro widget na ploše Macu: co se právě dělá, nálezy za poslední den a co čeká, každý text i bez jmen
+  lidí. Mimo macOS se nic nezapisuje.
+
 ## 1.20.0
 
 *25. 10. 2026 · patří k aplikaci Strom 3.16.0.*

package/CHANGELOG.de.md

@@ -5,6 +5,23 @@
 Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Installationszeilen stehen bei
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (auf Englisch).
 
+## 1.21.0
+
+*In Vorbereitung: die Betas bis 1.21.0-beta.2. Der Abschnitt ist mit dem Release vollständig.*
+
+- **„Wartet“ sagt, was die Strom-App nicht zeigt.** Die Zeile im Menü und `strom plan` sagt, wie viel des Wartenden
+  nur hier im Terminal ist und wie viel auf Antwort wartet; der Rest ist die Zahl, die die Strom-App zeigt, sodass
+  beide übereinstimmen.
+- **„Was wartet“ stellt das Eigene des Terminals voran.** Was nur das Terminal zeigt (ein Widerspruch einer eigenen
+  Änderung, eine Sendung der App, eine Frage zum Lesen von Scans), steht unter „Nur hier im Terminal“, der Rest unter
+  „Auch in der Strom-App“.
+- **`strom input assign`, `hide` und `unskip` sagen, was sich geändert hat**, in der Sprache der Forschung: jede
+  Datei, jede freigegebene oder neue Aufgabe, Personen mit Namen und wie es rückgängig geht. Ihr JSON bleibt gleich.
+- **Eine Übersicht der Forschung für ein Widget auf dem macOS-Schreibtisch.** Solange die Brücke läuft
+  (`strom live`), wird die Übersicht jedes Stammbaums in einer Datei für ein Widget auf dem Mac-Schreibtisch
+  gehalten: was gerade läuft, die Funde des letzten Tages und was wartet, jeder Text auch ohne die Namen von
+  Personen. Außerhalb von macOS wird nichts geschrieben.
+
 ## 1.20.0
 
 *25.10.2026 · gehört zur Strom-App 3.16.0.*

package/CHANGELOG.md

@@ -5,6 +5,22 @@ English · [Čeština](CHANGELOG.cs.md) · [Deutsch](CHANGELOG.de.md)
 The changes of each version in short. The full notes and the install lines are on
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases).
 
+## 1.21.0
+
+*In preparation: the betas up to 1.21.0-beta.2. The section is complete with the release.*
+
+- **"Waiting" says what the Strom app does not show.** The line in the menu and `strom plan` says how many of the
+  waiting things are only here in the terminal and how many wait for a reply; the rest is the number the Strom app
+  shows, so the two agree.
+- **"What waits" puts the terminal's own first.** What only the terminal shows (a conflict of an own edit, a send of
+  the app, a question about the reading of scans) is listed under "Only here in the terminal", the rest under
+  "Also in the Strom app".
+- **`strom input assign`, `hide` and `unskip` say what changed** in the research's language: each file, each task
+  let go of or made, people by name, and how to take it back. Their JSON stays the same.
+- **An overview of the research for a widget on the macOS desktop.** While the bridge runs (`strom live`), each
+  tree's overview is kept in a file for a widget on the Mac's desktop: what is at work now, the finds of the last day
+  and what waits, each text also without the names of people. Nothing is written off macOS.
+
 ## 1.20.0
 
 *2026-10-25 · goes with the Strom app 3.16.0.*

package/assets/lang/cs.json

@@ -90,6 +90,9 @@
   "ui.menu.title": "Strom výzkum {version}",
   "ui.menu.tree": "Rodokmen: {name} · osob: {persons}",
   "ui.menu.waiting": "Čeká: {count}",
+  "ui.waiting.split.reply": "{n, plural, one {# čeká} few {# čekají} other {# čeká}} na odpověď",
+  "ui.waiting.split.here": "{n} jen tady v terminálu",
+  "ui.waiting.split": "{n} (z toho {parts})",
   "ui.menu.working": "Agent právě pracuje samostatně.",
   "ui.menu.chat": "Pokračovat ve výzkumu s agentem",
   "ui.menu.start": "Začít výzkum s agentem",
@@ -448,6 +451,8 @@
   "ui.wait.how1": "snímky patří do schránky (inbox), pro každou knihu vlastní složka, každý pojmenovaný číslem snímku, jak ho počítá prohlížeč",
   "ui.wait.how2": "(9.jpg; přiblížená část: 9a.jpg) – další běh je zaregistruje a úkol se sám vrátí do fronty",
   "ui.wait.todo.n": "k vyřízení {n}",
+  "ui.wait.app.head": "I v aplikaci Strom · {n}",
+  "ui.wait.only.head": "Jen tady v terminálu (v aplikaci Strom nejsou) · {n}",
   "ui.wait.sent.n": "čeká na odpověď {n}",
   "ui.wait.sent.title": "Čeká na odpověď",
   "ui.wait.filter": "filtr: {section}",
@@ -1368,6 +1373,12 @@
   "ui.phone.removed": "telefon {name} je odebraný ze spárovaných",
   "ui.phone.ended": "server telefonu skončil",
   "ui.phone.waiting.item": "Něco k vyřízení na počítači",
+  "ui.widget.person": "osoba",
+  "ui.widget.family": "rodina",
+  "ui.widget.up": "Předci osoby{span}",
+  "ui.widget.down": "Potomci osoby{span}",
+  "ui.widget.one": "Osoba{span}",
+  "ui.widget.question": "Otázka výzkumu",
   "ui.phone.qr": "QR kód ke spárování telefonu (jeden telefon, do {time}): fotoaparátem telefonu ve stejné Wi-Fi jako tento počítač.",
   "ui.phone.qr.url": "adresa pod kódem: {url}",
   "ui.phone.qr.more": "další adresa tohoto počítače: strom phone qr --address {url}",
@@ -1633,7 +1644,7 @@
   "ui.plan.images": " (nejdřív potřebuje snímky)",
   "ui.plan.more": "… a další úkoly: {n}",
   "ui.plan.stories": "Potom vyprávění: {n} ({names})",
-  "ui.plan.waiting": "Čeká: {n} (v menu: Co čeká)",
+  "ui.plan.waiting": "Čeká: {count} · v menu: Co čeká",
   "ui.plan.none": "Fronta je prázdná – nové úkoly agent navrhne po dalším sezení, nebo mu jde v rozhovoru říct, co hledat.",
   "ui.plan.steer": "Pořadí se mění v rozhovoru s agentem: stačí mu říct, co má přednost.",
   "ui.plan.session": "sezení z {day}",
@@ -1869,6 +1880,24 @@
   "ui.intake.scans.archive": "Ve složce {folder} {n, plural, one {je # obrázek. Uložit ho do Archivu Stromu jako rodinný dokument?} few {jsou # obrázky. Uložit je do Archivu Stromu jako rodinné dokumenty?} other {je # obrázků. Uložit je do Archivu Stromu jako rodinné dokumenty?}}",
   "ui.intake.book.archive": "{folder}: neuloženo.",
   "ui.intake.known": "Tyhle podklady už ve výzkumu jsou – nic nepřibylo.",
+  "ui.input.assign.add": "{id} – nově patří k: {who}",
+  "ui.input.assign.remove": "{id} – už nepatří k: {who}",
+  "ui.input.batch.add": "dávka {name} – nově patří k: {who}",
+  "ui.input.batch.remove": "dávka {name} – už nepatří k: {who}",
+  "ui.input.task.of": "úkol {task} – nově se týká i: {who}",
+  "ui.input.assign.kept": "{id}: {who} zůstává – patří k celé dávce (odebrat z dávky: strom input assign --batch {batch} --remove {person})",
+  "ui.input.assign.none": "Nic ke změně.",
+  "ui.input.hidden": "{id} skryto",
+  "ui.input.why.unrelated": "nic z rodiny",
+  "ui.input.why.duplicate": "totéž jako jiný soubor",
+  "ui.input.task.without": "úkol {task} – bez {files} (skryto)",
+  "ui.input.task.dropped": "úkol {task} zrušen – jeho soubory jsou skryté ({files})",
+  "ui.input.hide.back": "zobrazit znovu: strom input unskip {ids}",
+  "ui.input.hide.none": "Už skryto – nic se nezměnilo.",
+  "ui.input.shown.new": "{id} znovu zobrazeno (čeká na roztřídění)",
+  "ui.input.shown.processed": "{id} znovu zobrazeno (zpracováno)",
+  "ui.input.task.gather": "úkol {task}: {what}",
+  "ui.input.unskip.none": "Nic skrytého – nic se nezměnilo.",
   "ui.intake.done": "✓ Přidáno do výzkumu: {n}. Agent to projde při další práci.",
   "ui.intake.done.archive": "✓ Uloženo do Archivu Stromu: {n}.",
   "ui.intake.done.waiting": "✓ Uloženo do výzkumu: {n}. Agent to projde, až bude na počítači.",

package/assets/lang/de.json

@@ -90,6 +90,9 @@
   "ui.menu.title": "Strom Ahnenforschung {version}",
   "ui.menu.tree": "Stammbaum: {name} · Personen: {persons}",
   "ui.menu.waiting": "Wartet: {count}",
+  "ui.waiting.split.reply": "{n, plural, one {# wartet} other {# warten}} auf Antwort",
+  "ui.waiting.split.here": "{n} nur hier im Terminal",
+  "ui.waiting.split": "{n} (davon {parts})",
   "ui.menu.working": "Der Agent arbeitet gerade selbstständig.",
   "ui.menu.chat": "Die Forschung mit dem Agenten fortsetzen",
   "ui.menu.start": "Die Forschung mit dem Agenten beginnen",
@@ -448,6 +451,8 @@
   "ui.wait.how1": "Scans kommen in den Eingang (inbox), ein Ordner pro Buch, jeder benannt nach der Bildnummer, wie der Viewer sie zählt",
   "ui.wait.how2": "(9.jpg; ein vergrößerter Ausschnitt: 9a.jpg) – der nächste Lauf registriert sie und die Aufgabe kehrt von selbst zurück",
   "ui.wait.todo.n": "zu erledigen {n}",
+  "ui.wait.app.head": "Auch in der Strom-App · {n}",
+  "ui.wait.only.head": "Nur hier im Terminal (nicht in der Strom-App) · {n}",
   "ui.wait.sent.n": "wartet auf Antwort {n}",
   "ui.wait.sent.title": "Wartet auf Antwort",
   "ui.wait.filter": "Filter: {section}",
@@ -1368,6 +1373,12 @@
   "ui.phone.removed": "das Telefon {name} ist von den gekoppelten entfernt",
   "ui.phone.ended": "der Server des Telefons ist beendet",
   "ui.phone.waiting.item": "Etwas am Computer zu erledigen",
+  "ui.widget.person": "Person",
+  "ui.widget.family": "Familie",
+  "ui.widget.up": "Vorfahren einer Person{span}",
+  "ui.widget.down": "Nachkommen einer Person{span}",
+  "ui.widget.one": "Eine Person{span}",
+  "ui.widget.question": "Eine Frage der Forschung",
   "ui.phone.qr": "Ein QR-Code zum Koppeln eines Telefons (ein Telefon, bis {time}): mit der Kamera des Telefons im selben WLAN wie dieser Computer.",
   "ui.phone.qr.url": "die Adresse unter dem Code: {url}",
   "ui.phone.qr.more": "eine weitere Adresse dieses Computers: strom phone qr --address {url}",
@@ -1633,7 +1644,7 @@
   "ui.plan.images": " (braucht zuerst die Scans)",
   "ui.plan.more": "… und {n, plural, one {# weitere Aufgabe} other {# weitere Aufgaben}}",
   "ui.plan.stories": "Danach die Geschichten: {n} ({names})",
-  "ui.plan.waiting": "Wartet: {n} (im Menü: Was wartet)",
+  "ui.plan.waiting": "Wartet: {count} · im Menü: Was wartet",
   "ui.plan.none": "Die Warteschlange ist leer – neue Aufgaben schlägt der Agent nach der nächsten Sitzung vor, oder ihm im Gespräch sagen, was er suchen soll.",
   "ui.plan.steer": "Die Reihenfolge ändert sich im Gespräch mit dem Agenten: ihm sagen, was Vorrang hat.",
   "ui.plan.session": "Sitzung vom {day}",
@@ -1869,6 +1880,24 @@
   "ui.intake.scans.archive": "Im Ordner {folder} {n, plural, one {ist # Bild. Als Familiendokument im Strom-Archiv speichern?} other {sind # Bilder. Als Familiendokumente im Strom-Archiv speichern?}}",
   "ui.intake.book.archive": "{folder}: nicht gespeichert.",
   "ui.intake.known": "Diese Unterlagen sind schon in der Forschung – nichts hinzugefügt.",
+  "ui.input.assign.add": "{id} – gehört jetzt auch zu: {who}",
+  "ui.input.assign.remove": "{id} – gehört nicht mehr zu: {who}",
+  "ui.input.batch.add": "Stapel {name} – gehört jetzt auch zu: {who}",
+  "ui.input.batch.remove": "Stapel {name} – gehört nicht mehr zu: {who}",
+  "ui.input.task.of": "Aufgabe {task} – betrifft jetzt auch: {who}",
+  "ui.input.assign.kept": "{id}: {who} bleibt – gehört zum ganzen Stapel (vom Stapel entfernen: strom input assign --batch {batch} --remove {person})",
+  "ui.input.assign.none": "Nichts zu ändern.",
+  "ui.input.hidden": "{id} ausgeblendet",
+  "ui.input.why.unrelated": "nichts von der Familie",
+  "ui.input.why.duplicate": "dasselbe wie eine andere Datei",
+  "ui.input.task.without": "Aufgabe {task} – ohne {files} (ausgeblendet)",
+  "ui.input.task.dropped": "Aufgabe {task} aufgegeben – ihre Dateien sind ausgeblendet ({files})",
+  "ui.input.hide.back": "wieder zeigen: strom input unskip {ids}",
+  "ui.input.hide.none": "Bereits ausgeblendet – nichts geändert.",
+  "ui.input.shown.new": "{id} wieder sichtbar (wartet auf Sortierung)",
+  "ui.input.shown.processed": "{id} wieder sichtbar (verarbeitet)",
+  "ui.input.task.gather": "Aufgabe {task}: {what}",
+  "ui.input.unskip.none": "Nichts ausgeblendet – nichts geändert.",
   "ui.intake.done": "✓ Zur Forschung hinzugefügt: {n}. Der Agent sieht es bei der nächsten Arbeit durch.",
   "ui.intake.done.archive": "✓ Im Strom-Archiv gespeichert: {n}.",
   "ui.intake.done.waiting": "✓ In der Forschung aufbewahrt: {n}. Der Agent sieht es durch, sobald er auf diesem Computer ist.",

package/dist/cli/menu-waiting.js

@@ -3,7 +3,9 @@
 // an office, one message to the family. What is to do apart from what waits for a reply from outside (sent).
 //
 //   the overview  the places of what is to do, a page of 15 at a time (next, previous, a range, all), filtered by
-//                 section, "?" for what waits for a reply; a number opens a place — a place of one thing that thing
+//                 section, "?" for what waits for a reply; a number opens a place — a place of one thing that thing;
+//                 what the Strom app does not show (core/waiting.ts terminalOnly) first, under a heading of its own,
+//                 the app's after it under theirs
 //   a place       its things, then for all of them at once: the request texts joined, sent, a conversation
 //   a thing       what it is and waits for, then only what makes sense for its kind: the archive or the site, the
 //                 folder for images saved by hand, the request's text, sent (or back among what is to do), an answer
@@ -26,7 +28,7 @@ import { claimOf, isEditConflict, sideText } from "../core/conflicts.js";
 import { openForUser } from "../core/open.js";
 import { isArchive } from "../core/mode.js";
 import { listConnectors } from "../core/connector.js";
-import { requestFile, requestTexts, waitingFor } from "../core/waiting.js";
+import { inApp, requestFile, requestTexts, waitingFor } from "../core/waiting.js";
 import { SENDABLE } from "../core/waitkind.js";
 /** A person for the person reading: "Jan Novák (*1905) [P0001]". */
 const label = (p) => `${displayName(p)}${lifespan(p) ? ` (${lifespan(p)})` : ""} [${p.id}]`;
@@ -87,16 +89,25 @@ function short(tree, lang, w) {
 }
 const sentAtOf = (w) => String(w.item.sentAt ?? w.item.at);
 /** The places of a list, in its order (the items of one place stand together). */
-function placesOf(items) {
+function placesOf(items, only = false) {
     const by = new Map();
     for (const w of items) {
         let p = by.get(w.item.group.key);
         if (!p)
-            by.set(w.item.group.key, (p = { key: w.item.group.key, name: w.item.group.name, items: [] }));
+            by.set(w.item.group.key, (p = { key: w.item.group.key, name: w.item.group.name, items: [], only }));
         p.items.push(w);
     }
     return [...by.values()];
 }
+/**
+ * The places of the overview: when something is only here in the terminal, its places first, apart from those the
+ * Strom app shows too (a place with both — an archive's milder question beside its tasks — in each part with its own);
+ * else the places as they come.
+ */
+function overviewPlaces(items) {
+    const here = items.filter((w) => !inApp(w));
+    return here.length ? [...placesOf(here, true), ...placesOf(items.filter(inApp))] : placesOf(items);
+}
 /** A place's line on the overview: the thing itself when it is one, else what is there by kind. */
 function placeDetail(t, lang, tree, p, phase) {
     const one = p.items.length === 1 ? truncate(short(tree, lang, p.items[0]), 60) : undefined;
@@ -144,7 +155,9 @@ export async function waitingForYou(ctx, run, lang, root) {
             counts.set(w.item.section, (counts.get(w.item.section) ?? 0) + 1);
         if (filter && !counts.get(filter))
             filter = undefined;
-        const places = placesOf(filter ? here.filter((w) => w.item.section === filter) : here);
+        const places = overviewPlaces(filter ? here.filter((w) => w.item.section === filter) : here);
+        // the part only here in the terminal and the part the Strom app shows too, each with its heading
+        const split = places.some((p) => p.only);
         const pages = Math.max(1, Math.ceil(places.length / PAGE));
         page = Math.min(page, pages - 1);
         const [from, to] = view === "all" ? [0, places.length] : view ? [view.from, Math.min(view.to, places.length)] : [page * PAGE, Math.min(places.length, (page + 1) * PAGE)];
@@ -166,6 +179,10 @@ export async function waitingForYou(ctx, run, lang, root) {
         const width = Math.max(0, ...names.map((n) => [...n].length));
         for (const [k, p] of shown.entries()) {
             const name = names[k];
+            if (split && (k === 0 || shown[k - 1].only !== p.only)) {
+                const n = places.filter((x) => x.only === p.only).reduce((a, x) => a + x.items.length, 0);
+                screen.push(`  ${t(p.only ? "ui.wait.only.head" : "ui.wait.app.head", { n })}`);
+            }
             screen.push(`${String(from + k + 1).padStart(2)}  ${name}${" ".repeat(width - [...name].length)}   ${placeDetail(t, lang, tree, p, phase)}`);
         }
         // what can be typed here, only what does something now
@@ -247,7 +264,7 @@ export async function waitingForYou(ctx, run, lang, root) {
             if (/^\d+$/u.test(a) && Number(a) >= 1 && Number(a) <= places.length) {
                 const p = places[Number(a) - 1];
                 // a place of one: that thing at once
-                await guarded(ctx, lang, async () => (p.items.length === 1 ? thing(ctx, run, lang, root, p.items[0]) : place(ctx, run, lang, root, p.key, phase, filter)));
+                await guarded(ctx, lang, async () => (p.items.length === 1 ? thing(ctx, run, lang, root, p.items[0]) : place(ctx, run, lang, root, p.key, phase, filter, split ? p.only : undefined)));
                 break;
             }
             out(controlLine);
@@ -255,14 +272,14 @@ export async function waitingForYou(ctx, run, lang, root) {
     }
 }
 /** One place: its things, then for all of them at once — the request texts joined, sent, a conversation. */
-async function place(ctx, run, lang, root, key, phase, filter) {
+async function place(ctx, run, lang, root, key, phase, filter, only) {
     const t = translator(lang);
     const out = (line = "") => ctx.io.stdout(line + "\n");
     for (;;) {
         if (outOfAnswers(ctx))
             return;
         const tree = Tree.open(root, ctx.env);
-        const items = waitingHere(ctx, tree).filter((w) => w.item.group.key === key && w.item.phase === phase && (!filter || w.item.section === filter));
+        const items = waitingHere(ctx, tree).filter((w) => w.item.group.key === key && w.item.phase === phase && (!filter || w.item.section === filter) && (only === undefined || only === !inApp(w)));
         if (!items.length)
             return;
         const name = items[0].item.group.name;

package/dist/cli/menu.js

@@ -43,6 +43,7 @@ import { pathOf, startAgain } from "../core/userpath.js";
 import { offerAgent } from "./fixes.js";
 import { addToResearch } from "./menu-research.js";
 import { waitingForYou, waitingHere } from "./menu-waiting.js";
+import { waitingLine } from "../core/waiting.js";
 import { permissionWaitingLines } from "../core/archiveasks.js";
 import { settingsMenu } from "./menu-settings.js";
 import { mainPerson } from "../core/kin.js";
@@ -177,7 +178,8 @@ export async function runMenu(ctx, run) {
             }
             // what waits for the person: the same list What waits shows (each thing once — a task that waits for an archive's
             // decision is one of its question's)
-            const waiting = waitingHere(ctx, tree).length;
+            const waits = waitingHere(ctx, tree);
+            const waiting = waits.length;
             const started = tree.list("research").length > 0;
             out(t("ui.menu.tree", { name: tree.config.name, persons: tree.countLive("person") }));
             // No agent yet (none installed, or not the one chosen): the research waits for it — kept as an archive meanwhile,
@@ -201,8 +203,9 @@ export async function runMenu(ctx, run) {
                     out();
                 }
             }
+            // what of it the Strom app does not show (only here in the terminal) said, so its number and the app's agree
             if (waiting)
-                out(t("ui.menu.waiting", { count: waiting }));
+                out(waitingLine(lang, waits));
             // an archive's images wait for the person's decision: one line, only until it is answered
             // (since when, and the tasks that stand on it, once it waits long or holds up much)
             for (const line of permissionWaitingLines(tree, lang))

package/dist/cli/ui.js

@@ -63,6 +63,9 @@ export const UI = {
     "ui.menu.title": "Strom research {version}",
     "ui.menu.tree": "Family tree: {name} · people: {persons}",
     "ui.menu.waiting": "Waiting: {count}",
+    "ui.waiting.split": "{n} (of these {parts})",
+    "ui.waiting.split.here": "{n} only here in the terminal",
+    "ui.waiting.split.reply": "{n} waiting for a reply",
     "ui.menu.working": "The agent is working on its own right now.",
     "ui.menu.chat": "Continue the research with the agent",
     "ui.menu.start": "Start the research with the agent",
@@ -425,6 +428,8 @@ export const UI = {
     "ui.wait.how1": "scans go into the inbox, a folder per book, each named by its image number as the viewer counts it",
     "ui.wait.how2": "(9.jpg; a zoomed-in part of it: 9a.jpg) — the next run registers them and the task comes back by itself",
     "ui.wait.todo.n": "to do {n}",
+    "ui.wait.only.head": "Only here in the terminal (not in the Strom app) · {n}",
+    "ui.wait.app.head": "Also in the Strom app · {n}",
     "ui.wait.sent.n": "waiting for a reply {n}",
     "ui.wait.sent.title": "Waiting for a reply",
     "ui.wait.filter": "filter: {section}",
@@ -1357,6 +1362,12 @@ export const UI = {
     "ui.phone.removed": "the phone {name} is taken off the paired ones",
     "ui.phone.ended": "the phone's server ended",
     "ui.phone.waiting.item": "Something to see to on the computer",
+    "ui.widget.person": "person",
+    "ui.widget.family": "family",
+    "ui.widget.up": "Ancestors of a person{span}",
+    "ui.widget.down": "Descendants of a person{span}",
+    "ui.widget.one": "A person{span}",
+    "ui.widget.question": "A question of the research",
     "ui.phone.qr": "A QR code to pair a phone (one phone, until {time}): the phone's camera, on the same Wi-Fi as this computer.",
     "ui.phone.qr.url": "the address under the code: {url}",
     "ui.phone.qr.more": "another address of this computer: strom phone qr --address {url}",
@@ -1622,7 +1633,7 @@ export const UI = {
     "ui.plan.images": " (needs the scans first)",
     "ui.plan.more": "… and {n, plural, one {# more task} other {# more tasks}}",
     "ui.plan.stories": "Then the stories: {n} ({names})",
-    "ui.plan.waiting": "Waiting: {n} (in the menu: What waits)",
+    "ui.plan.waiting": "Waiting: {count} · in the menu: What waits",
     "ui.plan.none": "Nothing in the queue — the agent proposes new tasks after its next session, or tell it in a conversation what to look for.",
     "ui.plan.steer": "To change the order, tell the agent in a conversation what comes first.",
     "ui.plan.session": "the session of {day}",
@@ -1858,6 +1869,24 @@ export const UI = {
     "ui.intake.scans.archive": "The folder {folder} holds {n, plural, one {# image. Save it to the Strom archive as a family document?} other {# images. Save them to the Strom archive as family documents?}}",
     "ui.intake.book.archive": "{folder}: not saved.",
     "ui.intake.known": "This material is in the research already — nothing added.",
+    "ui.input.assign.add": "{id} – now also of: {who}",
+    "ui.input.assign.remove": "{id} – no longer of: {who}",
+    "ui.input.batch.add": "batch {name} – now also of: {who}",
+    "ui.input.batch.remove": "batch {name} – no longer of: {who}",
+    "ui.input.task.of": "task {task} – now also about: {who}",
+    "ui.input.assign.kept": "{id}: {who} stays – the whole batch is of them (off the batch: strom input assign --batch {batch} --remove {person})",
+    "ui.input.assign.none": "Nothing to change.",
+    "ui.input.hidden": "{id} hidden",
+    "ui.input.why.unrelated": "nothing of the family",
+    "ui.input.why.duplicate": "the same as another file",
+    "ui.input.task.without": "task {task} – without {files} (hidden)",
+    "ui.input.task.dropped": "task {task} dropped – its files are hidden ({files})",
+    "ui.input.hide.back": "to show again: strom input unskip {ids}",
+    "ui.input.hide.none": "Hidden already – nothing changed.",
+    "ui.input.shown.new": "{id} shown again (waits to be sorted)",
+    "ui.input.shown.processed": "{id} shown again (processed)",
+    "ui.input.task.gather": "task {task}: {what}",
+    "ui.input.unskip.none": "Nothing hidden – nothing changed.",
     "ui.intake.done": "✓ Added to the research: {n}. The agent goes through it in its next work.",
     "ui.intake.done.archive": "✓ Saved to the Strom archive: {n}.",
     "ui.intake.done.waiting": "✓ Kept in the research: {n}. The agent goes through it once it is on this computer.",

package/dist/commands/browse.js

@@ -17,7 +17,9 @@ import { lacksImages } from "../core/queue.js";
 import { forStory } from "../core/stories.js";
 import { isArchive } from "../core/mode.js";
 import { actsAsArchive, stateOf } from "../core/state.js";
-import { rankedQueue, waitingForUser } from "./tasks.js";
+import { rankedQueue } from "./tasks.js";
+import { waitingHere } from "../cli/menu-waiting.js";
+import { waitingLine } from "../core/waiting.js";
 import { readTuneLog } from "../core/tune.js";
 import { calibrationLabel } from "../core/viewsizes.js";
 /** A change strom made by itself in the reading of scans, as a person reads it in strom recent. */
@@ -205,7 +207,9 @@ register({
         // the stories, with the searches beyond the registers before them
         const work = queue.filter((t) => !forStory(t));
         const stories = queue.filter(forStory);
-        const waiting = waitingForUser(tree).length;
+        // what waits for the person: the menu's What waits, what of it is only here in the terminal said (core/waiting.ts)
+        const waits = waitingHere(ctx, tree);
+        const waiting = waits.length;
         const shown = work.slice(0, count);
         let n = 0;
         const rows = shown.map((t) => [
@@ -225,7 +229,7 @@ register({
                 out.push(ui(lang, "ui.plan.stories", { n: stories.length, names: storyNames.join(", ") }));
         }
         if (waiting)
-            out.push(ui(lang, "ui.plan.waiting", { n: waiting }));
+            out.push(waitingLine(lang, waits, "ui.plan.waiting"));
         if (queue.length)
             out.push("", ui(lang, "ui.plan.steer"));
         const item = (t) => ({ id: t.id, what: humanTask(tree, t.what, lang), level: t.level, state: t.state, needsImages: lacksImages(tree, t) });

package/dist/commands/intake.js

@@ -14,7 +14,7 @@ import { collectFiles, fileSha256, inputPath, MAX_IN_TREE, mimeOf, storeShared }
 import { create, normId, requireRecord, update } from "../core/records.js";
 import { phrase } from "../core/phrases.js";
 import { addMarriedNames, importedTree, importGedcom, importStromJson, isStromJson, marriedNamesPlan, undoMarriedNames } from "../core/import.js";
-import { gedcomName, likelyDuplicates } from "../core/people.js";
+import { displayName, gedcomName, likelyDuplicates } from "../core/people.js";
 import { decodeText, safeFolderName } from "../core/text.js";
 import { amendInput, checkOriginalMeta } from "../core/originals.js";
 import { batchStatus, closeBatch, listBatches, readBatch } from "../core/batches.js";
@@ -61,6 +61,69 @@ function idsGiven(ctx, args, opts) {
     return ids;
 }
 /** The research the inputs are for: the one named, else the only active one. */
+/** A person for the person reading, as the material names them: "Jan Novák [P0002]" (an ID the research lacks as given). */
+function whoOf(tree, ids) {
+    return ids
+        .map((id) => {
+        const p = tree.get(id);
+        return p ? `${displayName(p)} [${p.id}]` : id;
+    })
+        .join(", ");
+}
+/** The tasks' files before a write: what a task let go of is said by its files (strom input hide). */
+function filesOfTasks(tree) {
+    return new Map(tree.list("task").map((t) => [t.id, t.where.filter((w) => /^I\d/u.test(w))]));
+}
+/**
+ * What strom input assign|hide|unskip changed, in the research language (the person reads it — the menu, the Strom
+ * app's bridge, an agent too): each file, each task, each batch, from what this write logged and how the records are
+ * now. The history keeps its own words.
+ */
+function materialLines(tree, before, batch) {
+    const lang = tree.lang;
+    const out = [];
+    for (const o of tree.written) {
+        const [id, ...rest] = o.targets;
+        if (o.op === "input.assign" && id) {
+            const i = tree.get(id);
+            const now = new Set([...(i?.persons ?? []), ...(i?.sorted?.persons ?? [])]);
+            const add = rest.filter((p) => now.has(p));
+            const remove = rest.filter((p) => !now.has(p));
+            if (add.length)
+                out.push(ui(lang, "ui.input.assign.add", { id, who: whoOf(tree, add) }));
+            if (remove.length)
+                out.push(ui(lang, "ui.input.assign.remove", { id, who: whoOf(tree, remove) }));
+        }
+        else if (o.op === "batch.assign" && batch) {
+            const b = readBatch(tree.root, batch);
+            const now = new Set(b?.persons ?? []);
+            const name = b?.name ?? batch;
+            const add = o.targets.filter((p) => now.has(p));
+            const remove = o.targets.filter((p) => !now.has(p));
+            if (add.length)
+                out.push(ui(lang, "ui.input.batch.add", { name, who: whoOf(tree, add) }));
+            if (remove.length)
+                out.push(ui(lang, "ui.input.batch.remove", { name, who: whoOf(tree, remove) }));
+        }
+        else if (o.op === "task.edit" && id && rest.length)
+            out.push(ui(lang, "ui.input.task.of", { task: id, who: whoOf(tree, rest) }));
+        else if (o.op === "task.edit" && id) {
+            const t = tree.get(id);
+            const files = (before.get(id) ?? []).filter((f) => !t?.where.includes(f));
+            if (files.length)
+                out.push(ui(lang, "ui.input.task.without", { task: id, files: files.join(", ") }));
+        }
+        else if (o.op === "task.drop" && id)
+            out.push(ui(lang, "ui.input.task.dropped", { task: id, files: (before.get(id) ?? []).join(", ") }));
+        else if (o.op === "input.hide" && id) {
+            const why = tree.get(id)?.hidden?.reason;
+            out.push(`${ui(lang, "ui.input.hidden", { id })}${why ? ` (${ui(lang, `ui.input.why.${why}`)})` : ""}`);
+        }
+        else if (o.op === "input.unskip" && id)
+            out.push(ui(lang, tree.get(id)?.state === "processed" ? "ui.input.shown.processed" : "ui.input.shown.new", { id }));
+    }
+    return out;
+}
 function researchFor(tree, named) {
     if (typeof named === "string")
         return requireRecord(tree, named, "research").id;
@@ -340,8 +403,10 @@ register({
     run(ctx, { args, opts }) {
         const tree = ctx.tree();
         const ids = idsGiven(ctx, args, opts);
+        const before = filesOfTasks(tree);
         const got = tree.withTreeLock(() => unhideMaterial(tree, ids));
-        return { text: got.changed.length ? lines(...tree.written.map((o) => o.summary)) : "nothing skipped: nothing changed", data: got };
+        const tasks = got.tasks.map((id) => ui(tree.lang, "ui.input.task.gather", { task: id, what: tree.get(id)?.what ?? "" }));
+        return { text: got.changed.length ? lines(...materialLines(tree, before), ...tasks) : ui(tree.lang, "ui.input.unskip.none"), data: got };
     },
 }, {
     path: ["input", "hide"],
@@ -364,8 +429,12 @@ register({
         if (why !== undefined && !HIDE_REASONS.includes(why))
             throw new UsageError(`--why: ${HIDE_REASONS.join(" or ")}`, { code: "material.body", params: { why: why.slice(0, 40) } });
         const ids = idsGiven(ctx, args, opts);
+        const before = filesOfTasks(tree);
         const got = tree.withTreeLock(() => hideMaterial(tree, ids, { reason: why, by: fileBy(tree, ctx.env) }));
-        return { text: got.changed.length ? lines(...tree.written.map((o) => o.summary), `show again: strom input unskip ${got.changed.length > 3 ? "…" : got.changed.join(" ")}`) : "hidden already: nothing changed", data: got };
+        return {
+            text: got.changed.length ? lines(...materialLines(tree, before), ui(tree.lang, "ui.input.hide.back", { ids: got.changed.length > 3 ? "…" : got.changed.join(" ") })) : ui(tree.lang, "ui.input.hide.none"),
+            data: got,
+        };
     },
 }, {
     path: ["input", "assign"],
@@ -393,7 +462,7 @@ register({
             throw new UsageError("give the files or --batch, not both", { code: "material.body" });
         const got = tree.withTreeLock(() => assignMaterial(tree, { ...(batch ? { batch } : { files: idsGiven(ctx, args, opts) }), add: people(opts.add), remove: people(opts.remove) }));
         return {
-            text: lines(got.changed.length ? lines(...tree.written.map((o) => o.summary)) : "nothing to change", ...got.kept.map((k) => `${k.id}: ${k.person} stays — the whole batch is theirs (strom input assign --batch ${k.batch} --remove ${k.person})`)),
+            text: lines(got.changed.length ? lines(...materialLines(tree, new Map(), got.batch)) : ui(tree.lang, "ui.input.assign.none"), ...got.kept.map((k) => ui(tree.lang, "ui.input.assign.kept", { id: k.id, who: whoOf(tree, [k.person]), batch: k.batch, person: k.person }))),
             data: got,
         };
     },

package/dist/core/live.js

@@ -130,6 +130,7 @@ const EXCERPT_MS = 20_000;
 /** A source with more excerpts than this is answered without the pictures: the app asks for each (?clip=). */
 const EXCERPTS_AT_ONCE = 12;
 import { anyoneAtWork, liveWorkers } from "./workers.js";
+import { widgetWriter } from "./widget.js";
 import { monthSpend, openSessions } from "./session.js";
 import { rankTasks } from "./queue.js";
 import { humanTask } from "../cli/human.js";
@@ -3029,6 +3030,11 @@ export function serveLive(root, env) {
                 return atWorkNow;
             };
             let workers = safe("the start", () => JSON.stringify(atWork(seen))) ?? "";
+            // the research on the desktop of a Mac (the Strom Widget): the tree's overview written while the bridge runs
+            // (core/widget.ts; none off macOS) — the first a moment after the start, never in its way
+            const widget = widgetWriter(root, env);
+            if (widget)
+                setTimeout(() => safe("the widget", () => widget.tick(true)), 1000).unref?.();
             const send = (event, data) => {
                 for (const s of streams)
                     s.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
@@ -3179,6 +3185,7 @@ export function serveLive(root, env) {
                 // its research gone (taken off the computer, a test's folder): nothing to follow
                 if (researchGone())
                     return stop("the research is no longer there", "gone", false);
+                safe("the widget", () => widget?.tick());
                 if (!streams.size)
                     return;
                 safe("a tick", () => {
@@ -3218,6 +3225,7 @@ export function serveLive(root, env) {
                 clearInterval(timer);
                 clearInterval(keepAlive);
                 clearInterval(stopAsked);
+                safe("the widget", () => widget?.end(reason === "gone"));
                 send("end", { reason, ...(back === undefined ? {} : { back }), at: new Date().toISOString() });
                 for (const s of streams)
                     s.end();

package/dist/core/phone-finds.js

@@ -22,6 +22,7 @@ import { factSaid } from "./changelog.js";
 import { conflictTitle, displayName, lifespan } from "./people.js";
 import { ownerName } from "./overview.js";
 import { forPhone } from "./phone-watch.js";
+import { eventName } from "../cli/human.js";
 /** The window when the page asks for none: the last 24 hours. */
 export const FINDS_HOURS = 24;
 /** How far back the page may ask, and how far back a find before the window is looked for. */
@@ -128,7 +129,7 @@ export function findGroups(tree, ops, lang = tree.lang) {
         if (r.type === "person") {
             const span = lifespan(r);
             const title = forPhone(`${displayName(r)}${span ? ` (${span})` : ""}`);
-            return title ? { kind: "person", title } : undefined;
+            return title ? { kind: "person", title, name: forPhone(displayName(r)), ...(span ? { span } : {}) } : undefined;
         }
         const title = forPhone(ownerName(tree, r.id));
         return title ? { kind: "family", title } : undefined;
@@ -171,7 +172,7 @@ export function findGroups(tree, ops, lang = tree.lang) {
                 const span = lifespan(child);
                 const text = forPhone(`${displayName(child)}${span ? ` (${span})` : ""}`);
                 if (text)
-                    add(ofRecord(r), { kind: "child", text, at });
+                    add(ofRecord(r), { kind: "child", text, at, ...(span ? { span } : {}) });
                 break;
             }
             case "event.add":
@@ -182,9 +183,12 @@ export function findGroups(tree, ops, lang = tree.lang) {
                 const e = r?.events.find((x) => x.id === id);
                 if (!r || !e || e.retracted)
                     break;
-                const said = forPhone(factSaid(tree, r.id, e.id, lang) ?? "");
+                const raw = factSaid(tree, r.id, e.id, lang) ?? "";
+                const said = forPhone(raw);
                 if (!said)
                     break;
+                const name = eventName(e.kind, lang, e.label);
+                const fact = { kind: e.kind, name, what: raw.startsWith(`${name}: `) ? forPhone(raw.slice(name.length + 2)) : "" };
                 // a line of its own on the phone: its first letter as a sentence's
                 const text = said.charAt(0).toLocaleUpperCase(lang) + said.slice(1);
                 const kind = o.op === "event.add" ? "fact" : o.op === "event.edit" ? "fixed" : "cited";
@@ -192,13 +196,14 @@ export function findGroups(tree, ops, lang = tree.lang) {
                 if (was) {
                     // said already: as it is now, at its newest moment
                     was.text = text;
+                    was.fact = fact;
                     was.at = at;
                     const g = ofRecord(r);
                     if (g && at > g.at)
                         g.at = at;
                     break;
                 }
-                const line = { kind, text, at };
+                const line = { kind, text, at, fact };
                 facts.set(`${r.id}:${e.id}`, line);
                 add(ofRecord(r), line);
                 break;

package/dist/core/phone-watch.js

@@ -17,6 +17,7 @@ import { history, whoAtWork } from "./live.js";
 import { agentsHere } from "./apps.js";
 import { humanTask } from "../cli/human.js";
 import { ui } from "../cli/ui.js";
+import { lifespan } from "./people.js";
 import { ALL_PREFIXES } from "./model.js";
 /** How long the overview of the tree shown is kept (the page asks every 10 s); the marks of the other trees in the switcher. */
 export const OVERVIEW_MS = 15_000;
@@ -177,7 +178,17 @@ export function treeOverview(root, env) {
             const way = r?.direction === "ancestors" ? "up" : r?.direction === "descendants" ? "down" : "other";
             const what = task ? taskText(tree, task) : undefined;
             const name = (r ? forPhone(r.name) : "") || whoAtWork(w.label, tree.lang);
-            return { way, name, ...(what ? { task: what } : {}), since: w.since, ...(w.paused ? { paused: { until: w.paused.until } } : {}) };
+            const focus = r?.focus ? tree.get(r.focus) : undefined;
+            const span = focus?.type === "person" ? lifespan(focus) : "";
+            return {
+                way,
+                name,
+                ...(what ? { task: what } : {}),
+                since: w.since,
+                ...(w.paused ? { paused: { until: w.paused.until } } : {}),
+                ...(r ? { direction: r.direction } : {}),
+                ...(span ? { span } : {}),
+            };
         });
         const sessions = tree.list("session");
         const last = sessions.map((s) => s.ended ?? s.started).sort().at(-1);

package/dist/core/tree.js

@@ -29,7 +29,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.20.0";
+export const VERSION = "1.21.0-beta.2";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/dist/core/waiting.js

@@ -1,7 +1,8 @@
 // What waits for the person, in one ordered list: the tasks that wait for them, the questions about archives, the new
 // versions of approved stories — and, for the terminal, the trees the Strom app sent and the questions about the reading
 // of scans. The bridge sends it to the Strom app (/status `waiting`, the app's spec ZADANI_VYZKUM_menu-ceka.md); the
-// menu's What waits reads the same. Computed, nothing written.
+// menu's What waits reads the same — the terminal's own marked `terminalOnly` (TERMINAL_ONLY), so the menu says what
+// of its count the app does not show (waitingSplit, waitingLine). Computed, nothing written.
 //
 // Each item: its kind (core/waitkind.ts for a task), the section the app shows it in, the place where it is dealt with
 // (its group), todo or sent, its order; for a task its priority, the site, the request's text, whom, the folder for
@@ -66,6 +67,35 @@ function actionsOf(kind, phase, note) {
                 : [];
     return all.filter((a) => ACTIONS_OFFERED.includes(a));
 }
+/**
+ * The options that add what only the terminal shows (the menu's What waits): the bridge never asks for them, so the
+ * Strom app never shows them. Each item they add is marked `terminalOnly`; a new kind of the terminal's own goes here.
+ */
+export const TERMINAL_ONLY = ["sends", "tune", "conflicts", "milder"];
+/** Whether the Strom app shows a thing that waits too (its /status `waiting`): everything but the terminal's own. */
+export function inApp(w) {
+    return !w.terminalOnly;
+}
+/**
+ * How many things wait, split as the Strom app counts them: all of them (the menu's count), those shown only in the
+ * terminal, those in the app that wait for a reply (sent — the app counts only what is to do), and what is to do in
+ * the app (its number: all − only here − sent).
+ */
+export function waitingSplit(items) {
+    const here = items.filter((w) => !inApp(w)).length;
+    const sent = items.filter((w) => inApp(w) && w.item.phase === "sent").length;
+    return { all: items.length, here, sent, app: items.length - here - sent };
+}
+/**
+ * The line "Waiting: N" for the person: what of it is only here in the terminal and what waits for a reply, each said
+ * on its own — the rest is the app's number; as it was only when neither is there (N is the app's number then).
+ */
+export function waitingLine(lang, items, key = "ui.menu.waiting") {
+    const s = waitingSplit(items);
+    const parts = [...(s.here ? [ui(lang, "ui.waiting.split.here", { n: s.here })] : []), ...(s.sent ? [ui(lang, "ui.waiting.split.reply", { n: s.sent })] : [])];
+    const count = parts.length ? ui(lang, "ui.waiting.split", { n: s.all, parts: parts.join(", ") }) : String(s.all);
+    return ui(lang, key, { count });
+}
 /** An address a person may open: http(s) only. */
 function webUrl(u) {
     return u && /^https?:\/\//iu.test(u) && URL.canParse(u) ? u : undefined;
@@ -256,7 +286,7 @@ export function waitingFor(tree, o = {}) {
         for (const q of questions.filter((p) => p.kind === "milder" && p.host && p.connector)) {
             const title = q.title ?? q.connector;
             const what = ui(lang, "ui.archive.milder.item", { title, host: q.host, to: levelWords(lang, q.to ?? "allowed"), from: levelWords(lang, q.from ?? "restricted") });
-            out.push({ question: q, item: { id: q.key, what, on: "", at: q.at, kind: "milder", section: "decide", group: archiveGroup(tree, q.host, title), phase: "todo", actions: [], host: q.host, connector: q.connector } });
+            out.push({ question: q, terminalOnly: true, item: { id: q.key, what, on: "", at: q.at, kind: "milder", section: "decide", group: archiveGroup(tree, q.host, title), phase: "todo", actions: [], host: q.host, connector: q.connector } });
         }
     // a new version of an approved story: whose (a couple's: person and partner), since when
     if (o.stories !== false)
@@ -291,6 +321,7 @@ export function waitingFor(tree, o = {}) {
         for (const r of receivedPending(tree.root))
             out.push({
                 send: r,
+                terminalOnly: true,
                 item: {
                     id: r.intake,
                     what: ui(lang, "ui.waiting.sent", { day: humanDay(r.at, lang), time: r.at.slice(11, 16), n: r.changes }),
@@ -308,6 +339,7 @@ export function waitingFor(tree, o = {}) {
         for (const c of conflictsToDecide(tree))
             out.push({
                 conflict: c,
+                terminalOnly: true,
                 item: { id: c.id, what: conflictTitle(tree, c), on: "", at: c.created, kind: "conflict", section: "decide", group: { key: "conflicts", name: phrase(lang, "wait.group.conflicts"), kind: "other" }, phase: "todo", actions: [] },
             });
     // the questions about the reading of scans only a person answers
@@ -315,6 +347,7 @@ export function waitingFor(tree, o = {}) {
         for (const q of tuneQuestions(tree, o.tune).due)
             out.push({
                 tune: q,
+                terminalOnly: true,
                 item: { id: q.id, what: q.text, on: q.why, at: q.asked, kind: "tune", section: "decide", group: { key: "tune", name: phrase(lang, "wait.group.tune"), kind: "other" }, phase: "todo", actions: [] },
             });
     // one place, one name: the first said of it (an archive's question names it as the research knows the archive; its

package/dist/core/widget.js

@@ -0,0 +1,415 @@
+// The research on the desktop of a Mac (the Strom Widget, a program of its own, strom-mac): each tree's overview written
+// into a file the widget reads — who works on what now, the finds of the last 24 hours, what waits for the person in
+// the Strom app, the last 24 hours — worked out by the same functions as the phone's page (phone-watch.ts,
+// phone-finds.ts) and cleaned as for it (forPhone): never a path, a record's ID, a spend or a model. Beside each text
+// that names a person, the same without the names (the widget's "hide names").
+//
+// Written by the tree's bridge (strom live) while it runs, on macOS alone: ~/Library/Application Support/Strom/widget/
+// <tree id>.json and index.json (the trees there), each whole (a file beside it renamed over it). Looked at every
+// WIDGET_CHECK_MS, written when what it says changed, else every WIDGET_HEARTBEAT_MS; the bridge ending as it should
+// writes `running: false`, its research gone takes the file away. An archive has none. The widget only reads: nothing
+// of it comes back. An isolated installation (STROM_ISOLATED: a test's, a second strom) writes into its own settings
+// folder — a research of a test never shows in the person's widget.
+import fs from "node:fs";
+import path from "node:path";
+import { configDir, isolated, userHome } from "./paths.js";
+import { Settings } from "./config.js";
+import { Tree } from "./tree.js";
+import { actsAsArchive } from "./state.js";
+import { foldText } from "./text.js";
+import { writeFileAtomic } from "./json.js";
+import { appUrlSetting } from "./stromapp.js";
+import { forPhone, treeOverview } from "./phone-watch.js";
+import { treeFinds } from "./phone-finds.js";
+import { waitingFor, inApp } from "./waiting.js";
+import { scopes } from "./directions.js";
+import { agentsHere } from "./apps.js";
+import { humanTask } from "../cli/human.js";
+import { ui } from "../cli/ui.js";
+/** The version of the files' shape the widget reads (a newer one: the widget asks for its own update). */
+export const WIDGET_SCHEMA = 1;
+/** How often the bridge looks whether what the widget shows changed; written at least this often all the same. */
+export const WIDGET_CHECK_MS = 15_000;
+export const WIDGET_HEARTBEAT_MS = 60_000;
+/** At most so many finds (the newest), so many of what waits with its text. */
+export const WIDGET_FINDS = 50;
+export const WIDGET_PENDING = 3;
+/** What stands for a name taken out of a text. */
+const HIDDEN = "…";
+/**
+ * Where the widget's files are written: none but on macOS; STROM_WIDGET_DIR when set; an isolated installation into its
+ * own settings folder; else ~/Library/Application Support/Strom/widget of the HOME strom runs with.
+ */
+export function widgetDir(env, platform = process.platform) {
+    if (platform !== "darwin")
+        return undefined;
+    const said = env.STROM_WIDGET_DIR?.trim();
+    if (said)
+        return path.resolve(said);
+    if (isolated(env))
+        return path.join(configDir(env, platform), "widget");
+    return path.join(userHome(env), "Library", "Application Support", "Strom", "widget");
+}
+/** A moment as the widget reads it: ISO 8601 to the second, in UTC (Swift's .iso8601 reads no fractions). */
+export function isoSecond(at) {
+    const t = typeof at === "number" ? at : Date.parse(at);
+    return Number.isFinite(t) ? new Date(t).toISOString().replace(/\.\d{3}Z$/u, "Z") : "";
+}
+// The app's slug of a tree's name (strom-beta src/filenames.ts asciiSlug): ?tree=<slug> opens the tree of that name.
+const STANDALONE = { ß: "ss", æ: "ae", œ: "oe", ø: "o", đ: "d", ð: "d", þ: "th", ł: "l", ħ: "h", ı: "i", ŧ: "t", ŋ: "n", ĸ: "k" };
+export function appSlug(name) {
+    return name
+        .toLowerCase()
+        .replace(/[ßæœøđðþłħıŧŋĸ]/gu, (c) => STANDALONE[c] ?? c)
+        .normalize("NFD")
+        .replace(/[̀-ͯ]/gu, "")
+        .replace(/[^a-z0-9]+/gu, "-")
+        .replace(/^-+|-+$/gu, "");
+}
+/** The tree in the Strom app strom uses (the setting strom.app.url, the channel's copy): ?tree=<slug of its name>. */
+function treeUrl(env, name) {
+    const url = new URL(appUrlSetting(new Settings(env, {})).url);
+    const slug = appSlug(name);
+    if (slug)
+        url.searchParams.set("tree", slug);
+    return url.href;
+}
+// ── names out of a text ─────────────────────────────────────────────────────────────────────────────────────────────
+/** The stems of every name of the tree's people, folded: a word is a name when it is one of them and a few letters more. */
+const stemsKept = new Map();
+const MIN_STEM = 3;
+const MAX_ENDING = 4;
+function stemOf(folded) {
+    return folded.length > MIN_STEM ? folded.slice(0, Math.max(MIN_STEM, folded.length - 1)) : folded;
+}
+function nameStems(tree, key) {
+    const was = stemsKept.get(tree.root);
+    if (was && was.at === key)
+        return was.stems;
+    const names = [];
+    for (const p of tree.list("person"))
+        if (!p.retracted)
+            for (const n of p.names)
+                names.push(n.given, n.surname);
+    const stems = stemsOfNames(names);
+    stemsKept.set(tree.root, { at: key, stems });
+    return stems;
+}
+/** A name that drops its e before the last consonant in the other cases (Karel → Karla, Cvrlek → Cvrlka, Němec → Němcová). */
+const MOVABLE_E = /^(.*[bcdfghjklmnpqrstvwxz])e([kclnr])$/u;
+/** A stem ending in two consonants, as such a name has it without its e (Cvrlková → Cvrlk-, Němcová → Němc-). */
+const WITHOUT_E = /^(.*[bcdfghjklmnpqrstvwxz])([kclnr])$/u;
+/** The stems of names (folded): what a word of a text starts with when it is one of the names in any of its forms. */
+export function stemsOfNames(names) {
+    const stems = new Set();
+    for (const name of names)
+        for (const part of name.split(/[^\p{L}\p{M}]+/u)) {
+            const f = foldText(part);
+            if ([...f].length < 2)
+                continue;
+            const e = MOVABLE_E.exec(f);
+            if (e && e[1].length >= 2) {
+                // the name as it stands (Cvrlek) and without its e (Cvrlka, Cvrlkovi, Cvrlková) — not "Něme…", which "neměl" is too
+                stems.add(f);
+                stems.add(e[1] + e[2]);
+                stems.add(stemOf(`${e[1]}${e[2]}ova`));
+                continue;
+            }
+            stems.add(stemOf(f));
+            // a woman's surname said of the man or the family ("Lhotáková" → "Lhoták", "Lhotákovi"), and a man's said of her
+            const base = /^(.{3,})ova$/u.exec(f)?.[1];
+            const cut = base ? WITHOUT_E.exec(base) : null;
+            if (cut && base.length >= 4) {
+                // "Cvrlková" said of the man: Cvrlk- (Cvrlka) and Cvrlek
+                stems.add(base);
+                stems.add(`${cut[1]}e${cut[2]}`);
+            }
+            else if (base)
+                stems.add(stemOf(base));
+            else if (f.length >= 4)
+                stems.add(stemOf(`${f}ova`));
+        }
+    return stems;
+}
+/** Whether a word is a name of the tree's people: one of their stems and at most MAX_ENDING letters more (Kryštofa, Lhotákovou). */
+function isName(word, stems) {
+    const f = foldText(word);
+    const chars = [...f];
+    for (let k = Math.max(1, chars.length - MAX_ENDING); k <= chars.length; k++)
+        if (stems.has(chars.slice(0, k).join("")))
+            return true;
+    return false;
+}
+/**
+ * A text with the names of the tree's people taken out: each run of them (with what joins them: "Kryštofa Lhotáka")
+ * one "…". Any script; a word that only looks like a name goes too (better one word too many than a name shown).
+ * "" when nothing but names is left.
+ */
+export function withoutNames(text, stems) {
+    const parts = text.split(/([\p{L}\p{M}]+)/u);
+    const out = [];
+    let hidden = false;
+    for (let i = 0; i < parts.length; i++) {
+        const p = parts[i];
+        const word = i % 2 === 1;
+        if (word && isName(p, stems)) {
+            if (!hidden)
+                out.push(HIDDEN);
+            hidden = true;
+            continue;
+        }
+        // what stands between two names of one run (a space, a hyphen) goes with them
+        if (!word && hidden && /^[\s-]*$/u.test(p) && i + 1 < parts.length && isName(parts[i + 1], stems))
+            continue;
+        hidden = false;
+        out.push(p);
+    }
+    const s = out.join("").replace(/\s+/gu, " ").trim();
+    return /[\p{L}\p{N}]/u.test(s.replaceAll(HIDDEN, "")) ? s : "";
+}
+// ── the overview ─────────────────────────────────────────────────────────────────────────────────────────────────────
+/** A fact's name as a heading: its first letter capital ("povolání" → "Povolání"), in the research language's way. */
+function heading(name, lang) {
+    const [first = "", ...rest] = [...name];
+    return first.toLocaleUpperCase(lang) + rest.join("");
+}
+const FACTS = { BIRT: "birth", CHR: "baptism", BAPM: "baptism", MARR: "marriage", DEAT: "death", BURI: "burial" };
+/** The finds of the phone as the widget's lines: newest first, each its text and the same without names. */
+function findItems(tree, groups, stems, openUrl) {
+    const lang = tree.lang;
+    const person = ui(lang, "ui.widget.person");
+    const anon = (span) => (span ? `${person} (${span})` : person);
+    const out = [];
+    const at = (l) => isoSecond(l.at);
+    for (const g of groups)
+        for (const l of g.lines) {
+            const who = g.kind === "person" ? (g.name ?? g.title ?? "") : (g.title ?? "");
+            const whoNoNames = g.kind === "person" ? person : ui(lang, "ui.widget.family");
+            const base = { at: at(l), openUrl };
+            switch (l.kind) {
+                case "person":
+                    out.push({ kind: "person_new", text: g.title ?? "", textNoNames: anon(g.span), ...base });
+                    break;
+                case "family":
+                    out.push({ kind: "family_new", text: g.title ?? "", textNoNames: whoNoNames, ...base });
+                    break;
+                case "name":
+                    out.push({ kind: "name", text: l.text, textNoNames: anon(g.span), ...base });
+                    break;
+                case "child":
+                    out.push({ kind: "child", text: l.text, textNoNames: anon(l.span), ...base });
+                    break;
+                case "fact":
+                case "fixed":
+                case "cited": {
+                    const fact = FACTS[l.fact?.kind ?? ""] ?? "other";
+                    const what = l.fact?.what ?? "";
+                    out.push({
+                        kind: "fact",
+                        fact,
+                        label: fact === "other" && l.fact?.name ? heading(l.fact.name, lang) : null,
+                        text: [who, what].filter(Boolean).join(", "),
+                        textNoNames: [whoNoNames, withoutNames(what, stems)].filter(Boolean).join(", "),
+                        ...base,
+                    });
+                    break;
+                }
+                case "source": {
+                    // places, dates and sources stay (the widget's "hide names"); a name in a source's title goes
+                    const none = withoutNames(l.text, stems);
+                    out.push({ kind: "source_new", text: l.text, ...(none ? { textNoNames: none } : {}), ...base });
+                    break;
+                }
+                case "conflict":
+                case "hypothesis": {
+                    const none = withoutNames(l.text, stems);
+                    out.push({ kind: "resolved", resolved: l.kind === "conflict" ? "conflict" : "hypothesis_confirmed", text: l.text, ...(none ? { textNoNames: none } : {}), ...base });
+                    break;
+                }
+            }
+        }
+    return out.filter((f) => f.text).sort((a, b) => b.at.localeCompare(a.at)).slice(0, WIDGET_FINDS);
+}
+/** What waits for the person as the Strom app counts it: its /status `waiting`, only what is to do (not sent, waiting for a reply). */
+function pendingOf(tree, env) {
+    const settings = new Settings(env, {});
+    return waitingFor(tree, {
+        shared: settings.shared()?.value,
+        claude: () => settings.agent(tree.config).value === "claude" && agentsHere(env).some((a) => a.id === "claude" && a.cli),
+        stories: true,
+        scopes: scopes(tree),
+    }).filter((w) => inApp(w) && w.item.phase === "todo");
+}
+/**
+ * A line of "Now" without names: its direction and the years of whom it is about ("Předci osoby (1784)"); a question,
+ * by its words without the names; the agent itself (no research), as it is said (no name in it).
+ */
+function lineNoNames(lang, l, stems) {
+    const of = l.span ? ` (${l.span})` : "";
+    if (l.direction === "ancestors")
+        return ui(lang, "ui.widget.up", { span: of });
+    if (l.direction === "descendants")
+        return ui(lang, "ui.widget.down", { span: of });
+    if (l.direction === "person")
+        return ui(lang, "ui.widget.one", { span: of });
+    return withoutNames(l.name, stems) || ui(lang, "ui.widget.question");
+}
+/**
+ * The overview of a tree as the widget reads it (`running`: its bridge runs); undefined for an archive (nobody works
+ * on it: nothing to show of an agent) and a research that cannot be read.
+ */
+export function widgetTree(root, env, opts) {
+    const now = opts.now ?? Date.now();
+    const tree = Tree.open(root, env);
+    if (actsAsArchive(tree))
+        return undefined;
+    const lang = tree.lang;
+    const openUrl = treeUrl(env, tree.config.name);
+    const o = treeOverview(root, env);
+    const stems = nameStems(tree, o.latest ?? "");
+    const lines = o.now.map((l) => {
+        const task = l.task;
+        const taskNoNames = task ? withoutNames(task, stems) : "";
+        return {
+            dir: l.way,
+            title: l.name,
+            titleNoNames: lineNoNames(lang, l, stems),
+            ...(task ? { task } : {}),
+            ...(taskNoNames ? { taskNoNames } : {}),
+            since: isoSecond(l.since),
+            pausedUntil: l.paused ? isoSecond(l.paused.until) : null,
+            openUrl,
+        };
+    });
+    const windowStart = now - 24 * 3_600_000;
+    const finds = treeFinds(root, env, new Date(windowStart).toISOString(), now);
+    const waits = pendingOf(tree, env);
+    const pendingItems = waits.slice(0, WIDGET_PENDING).map(({ item }) => {
+        const text = forPhone(humanTask(tree, item.what, lang)) || ui(lang, "ui.phone.waiting.item");
+        const none = withoutNames(text, stems);
+        return { text, ...(none ? { textNoNames: none } : {}) };
+    });
+    const at = isoSecond(now);
+    return {
+        schemaVersion: WIDGET_SCHEMA,
+        treeKey: tree.config.id,
+        treeName: tree.config.name,
+        lang,
+        generatedAt: at,
+        running: opts.running,
+        lastActiveAt: at,
+        openUrl,
+        now: { lines, ...(o.lastWorked ? { lastWorkedAt: isoSecond(o.lastWorked) } : {}) },
+        findings: { windowStart: isoSecond(finds.since), items: findItems(tree, finds.groups, stems, openUrl) },
+        pending: { count: waits.length, items: pendingItems, openUrl },
+        ...(o.day ? { stats24h: o.day } : {}),
+    };
+}
+// ── the files ────────────────────────────────────────────────────────────────────────────────────────────────────────
+const treeFile = (dir, key) => path.join(dir, `${key}.json`);
+/** A tree's key as a file's name: the tree's ID (a UUID) — never a path. */
+const KEY = /^[0-9A-Za-z-]{1,64}$/u;
+/** index.json as the files of the trees there say it, written whole when it says something else. */
+export function writeWidgetIndex(dir, now = Date.now()) {
+    const trees = [];
+    let names = [];
+    try {
+        names = fs.readdirSync(dir).filter((n) => n.endsWith(".json") && n !== "index.json" && !n.startsWith("."));
+    }
+    catch {
+        return;
+    }
+    for (const n of names.sort()) {
+        try {
+            const t = JSON.parse(fs.readFileSync(path.join(dir, n), "utf8"));
+            if (typeof t.treeKey !== "string" || `${t.treeKey}.json` !== n)
+                continue;
+            trees.push({ treeKey: t.treeKey, treeName: String(t.treeName ?? ""), lang: String(t.lang ?? ""), running: t.running === true, lastActiveAt: String(t.lastActiveAt ?? ""), generatedAt: String(t.generatedAt ?? "") });
+        }
+        catch {
+            // being written by another bridge this moment: said the next time
+        }
+    }
+    const file = path.join(dir, "index.json");
+    try {
+        const was = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (JSON.stringify(was.trees) === JSON.stringify(trees) && was.schemaVersion === WIDGET_SCHEMA)
+            return;
+    }
+    catch {
+        // none yet
+    }
+    writeFileAtomic(file, `${JSON.stringify({ schemaVersion: WIDGET_SCHEMA, generatedAt: isoSecond(now), trees }, null, 2)}\n`);
+}
+/** A tree's file written whole (a file beside it renamed over it), then index.json. */
+export function writeWidgetTree(dir, data) {
+    if (!KEY.test(data.treeKey))
+        return;
+    writeFileAtomic(treeFile(dir, data.treeKey), `${JSON.stringify(data, null, 2)}\n`);
+    writeWidgetIndex(dir, Date.parse(data.generatedAt) || Date.now());
+}
+/** A tree's file taken away (its research gone, an archive now), and index.json without it. */
+export function dropWidgetTree(dir, key) {
+    if (!KEY.test(key))
+        return;
+    try {
+        fs.rmSync(treeFile(dir, key), { force: true });
+    }
+    catch {
+        return;
+    }
+    writeWidgetIndex(dir);
+}
+/** The writer of a tree's bridge; none off macOS. */
+export function widgetWriter(root, env, platform = process.platform, clock = Date.now) {
+    const dir = widgetDir(env, platform);
+    if (!dir)
+        return undefined;
+    const checkMs = Number(env.STROM_WIDGET_CHECK_MS ?? WIDGET_CHECK_MS);
+    const beatMs = Number(env.STROM_WIDGET_HEARTBEAT_MS ?? WIDGET_HEARTBEAT_MS);
+    let checked = -Infinity;
+    let written = -Infinity;
+    let said = "";
+    let last;
+    let key;
+    // what moves with the clock alone says nothing new
+    const content = (t) => JSON.stringify({ ...t, generatedAt: "", lastActiveAt: "", findings: { ...t.findings, windowStart: "" } });
+    return {
+        tick(force = false) {
+            const now = clock();
+            if (!force && now - checked < checkMs)
+                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);
+                key = undefined;
+                last = undefined;
+                said = "";
+                return;
+            }
+            key = t.treeKey;
+            last = t;
+            const c = content(t);
+            if (c === said && now - written < beatMs)
+                return;
+            writeWidgetTree(dir, t);
+            said = c;
+            written = now;
+        },
+        end(gone) {
+            if (!key)
+                return;
+            // what the file says now is no longer what was written: the next look writes it again
+            said = "";
+            if (gone)
+                return dropWidgetTree(dir, key);
+            if (!last)
+                return;
+            const at = isoSecond(clock());
+            writeWidgetTree(dir, { ...last, running: false, generatedAt: at, lastActiveAt: at });
+        },
+    };
+}

package/package.json

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