strom-research 1.21.0-beta.1 → 1.21.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.21.0
 
-*Připravuje se: bety do 1.21.0-beta.1. Oddíl bude úplný s vydáním.*
+*26. 10. 2026 · patří k aplikaci Strom 3.16.0.*
 
 - **„Č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í.
@@ -15,6 +15,9 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou 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
 

package/CHANGELOG.de.md

@@ -7,7 +7,7 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.21.0
 
-*In Vorbereitung: die Betas bis 1.21.0-beta.1. Der Abschnitt ist mit dem Release vollständig.*
+*26.10.2026 · gehört zur Strom-App 3.16.0.*
 
 - **„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
@@ -17,6 +17,10 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   „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
 

package/CHANGELOG.md

@@ -7,7 +7,7 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 1.21.0
 
-*In preparation: the betas up to 1.21.0-beta.1. The section is complete with the release.*
+*2026-10-26 · goes with the Strom app 3.16.0.*
 
 - **"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
@@ -17,6 +17,9 @@ The changes of each version in short. The full notes and the install lines are o
   "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
 

package/assets/lang/cs.json

@@ -1373,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}",

package/assets/lang/de.json

@@ -1373,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}",

package/dist/cli/ui.js

@@ -1362,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}",

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

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.21.0-beta.1",
+  "version": "1.21.0",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {
@@ -57,8 +57,5 @@
   "devDependencies": {
     "@types/node": "^22.20.4",
     "typescript": "^7.0.2"
-  },
-  "publishConfig": {
-    "tag": "beta"
   }
 }