strom-research 1.24.0-beta.2 → 1.25.0-beta.1

package/CHANGELOG.cs.md

@@ -5,14 +5,24 @@
 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.25.0
+
+*Připravuje se: bety do 1.25.0-beta.1. Oddíl bude úplný s vydáním.*
+
+- **Data pro widget Strom i na Windows.** Výzkum teď zapisuje to, co z něj ukazuje widget Strom (na čem se pracuje,
+  nálezy za posledních 24 hodin, co čeká), i na Windows, do `%USERPROFILE%\.config\strom\widget`, se značkou verze
+  strom, která je zapsala. Widget, který zrovna čte svůj soubor, most nikdy nezdrží. `strom uninstall` odebere i soubory
+  widgetu, také na Macu; výzkum a nastavení zůstávají.
+
 ## 1.24.0
 
-*Připravuje se: bety do 1.24.0-beta.2. Oddíl bude úplný s vydáním.*
+*31. 10. 2026 · patří k aplikaci Strom 3.19.0.*
 
 - **Místa zmapovaná jednou pro všechny výzkumy na tomto počítači.** Místo, které jiný výzkum tady už přiřadil k regionům
   dějin, se převezme, když jde jistě o totéž místo (stejný název a stejné souřadnice, farnost nebo okres) a všechny
   výzkumy ho přiřazují stejně; přechází jen přiřazení místa, nic z rodiny. Místo stejného jména, které jistě totéž
-  není, dostane agent jako návrh; sám přiřazuje jen zbytek. `strom history adopt --dry-run` řekne, co by se převzalo.
+  není, dostane agent jako návrh; sám přiřazuje jen zbytek. `strom history adopt --dry-run` řekne, co by se převzalo. Otázka na zapnutí nebo vypnutí událostí
+  dějin říká, že platí pro všechny výzkumy na tomto počítači, i jak to změnit jen pro jeden výzkum.
 - **Opravy výzkumu pro aplikaci Strom.** Most vypíše, co `strom fixes` ve výzkumu nabízí (název, co dělá, kolik
   položek, stav, jestli jde vrátit), zdarma a bez zápisu; odkaz `strom-research://fixes` otevře opravu v terminálu
   výzkumu, kde se oprava i její vrácení vždy nejdřív potvrzuje.
@@ -21,12 +31,14 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   vynechává, a u pramenů bez výřezu. Jen veřejná webová stránka, nikdy adresa fondu; standardní soubor GEDCOM nechává
   adresu v poznámce. Datum verze výzkumu v souboru pro Strom nese i čas, takže aplikace ukáže den, kdy vznikla, i kolem
   půlnoci.
+- **Vlastní rod osoby z aplikace Strom.** Když aplikace Strom u osoby označí, že zakládá vlastní rod nebo rod
+  rodiny nenese, `strom sync` to uloží do výzkumu a soubor pro Strom to vrací, takže další odeslání i jiné zařízení
+  ukážou stejné rody; sloučení dvou osob značku zachová. Standardní soubor GEDCOM o tom nic neříká. Potřebuje aplikaci
+  Strom 3.19.0.
 - **Číslo domu, věk a období tak, jak byly zapsány.** Slovo pro číslo domu („No.“, „čp.“) se dává jen před samotné číslo;
   ulice s číslem jde do souboru tak, jak je. Věk „05y“ se čte jako 5 let. Obojí se z aplikace Strom vrací stejné,
   není to úprava uživatele. Období, které vede aplikace Strom („1871/1882“, nebo otevřené na jednom konci), přijde do
   výzkumu jako od … do …, nikdy jako datum někde mezi nimi.
-- **Otázka na dějiny říká, kde platí.** Zapnutí nebo vypnutí událostí dějin platí pro všechny výzkumy na tomto
-  počítači; otázka to říká, i jak to změnit jen pro jeden výzkum.
 - **Slabý nebo odmítnutý model agenta hlásí doctor.** Když výzkum nemá zvolený model a vlastní výchozí model agenta je
   ten, který výzkum shledal pro svou práci slabým nebo odmítnutým, `strom doctor` varuje a dá příkaz k volbě; sám
   nikdy nevolí.

package/CHANGELOG.de.md

@@ -5,15 +5,26 @@
 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.25.0
+
+*In Vorbereitung: die Betas bis 1.25.0-beta.1. Der Abschnitt ist mit dem Release vollständig.*
+
+- **Daten für das Strom-Widget auch unter Windows.** Eine Forschung schreibt jetzt, was das Strom-Widget von ihr zeigt
+  (woran gearbeitet wird, die Funde der letzten 24 Stunden, was wartet), auch unter Windows, nach
+  `%USERPROFILE%\.config\strom\widget`, mit einer Marke des strom, der es geschrieben hat. Ein Widget, das gerade seine
+  Datei liest, hält die Brücke nie auf. `strom uninstall` entfernt auch die Dateien des Widgets, auch auf dem Mac; die
+  Forschung und die Einstellungen bleiben.
+
 ## 1.24.0
 
-*In Vorbereitung: die Betas bis 1.24.0-beta.2. Der Abschnitt ist mit dem Release vollständig.*
+*31.10.2026 · gehört zur Strom-App 3.19.0.*
 
 - **Orte einmal zugeordnet für jede Forschung auf diesem Computer.** Ein Ort, den eine andere Forschung hier schon den
   Regionen der Geschichte zugeordnet hat, wird übernommen, wenn es sicher derselbe Ort ist (derselbe Name und dieselben
   Koordinaten, Pfarrei oder derselbe Bezirk) und jede Forschung ihn gleich zuordnet; nur die Zuordnung des Orts geht
   über, nichts von der Familie. Ein Ort gleichen Namens, der nicht sicher derselbe ist, geht als Vorschlag an den
-  Agenten; er ordnet nur den Rest zu. `strom history adopt --dry-run` sagt, was übernommen würde.
+  Agenten; er ordnet nur den Rest zu. `strom history adopt --dry-run` sagt, was übernommen würde. Die Frage, die Ereignisse der Geschichte ein- oder
+  auszuschalten, sagt, dass es für jede Forschung auf diesem Computer gilt, und wie es sich für eine allein ändern lässt.
 - **Die Korrekturen einer Forschung für die Strom-App.** Die Brücke listet, was `strom fixes` in der Forschung anbietet
   (Titel, was sie tut, wie viele Einträge, ihr Stand, ob sie sich zurücknehmen lässt), kostenlos und ohne etwas zu
   schreiben; der Link `strom-research://fixes` öffnet eine Korrektur im Terminal der Forschung, wo sie und ihre
@@ -23,12 +34,14 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   Ausschnitten, die die Datei auslässt, und bei Quellen ohne Ausschnitt. Nur eine öffentliche Webseite, nie die Adresse
   eines Bestands; die Standard-GEDCOM-Datei behält die Adresse in der Notiz. Das Datum der Version der
   Forschung in der Strom-Datei trägt auch die Uhrzeit, so zeigt die App den Tag ihrer Entstehung auch um Mitternacht.
+- **Die eigene Linie einer Person aus der Strom-App.** Markiert die Strom-App, dass eine Person eine eigene Linie
+  gründet oder die der Familie nicht trägt, behält `strom sync` das in der Forschung, und die Strom-Datei gibt es
+  zurück, so zeigen die nächste Sendung und ein anderes Gerät dieselben Linien; das Zusammenführen zweier Personen
+  behält die Markierung. Die Standard-GEDCOM-Datei sagt nichts davon. Es braucht die Strom-App 3.19.0.
 - **Hausnummer, Alter und Zeitraum, wie sie geschrieben wurden.** Das Wort für eine Hausnummer („No.“, „čp.“) steht nur vor
   einer Zahl allein; eine Straße mit Nummer geht so in die Datei, wie sie ist. Ein Alter „05y“ gilt als 5 Jahre.
   Beides kommt aus der Strom-App gleich zurück, keine Änderung des Benutzers. Ein Zeitraum der Strom-App
   („1871/1882“ oder an einem Ende offen) kommt als von … bis … in die Forschung, nie als ein Datum irgendwo dazwischen.
-- **Die Frage nach der Geschichte sagt, wo sie gilt.** Die Ereignisse der Geschichte ein- oder auszuschalten gilt für
-  jede Forschung auf diesem Computer; die Frage sagt es, und wie es sich für eine Forschung allein ändern lässt.
 - **Ein schwaches oder abgelehntes Modell des Agenten meldet der Doctor.** Ist für die Forschung kein Modell gewählt und
   das eigene Standardmodell des Agenten eines, das die Forschung für ihre Arbeit schwach oder abgelehnt fand, warnt
   `strom doctor` und nennt den Befehl zur Wahl; selbst wählt er nie.

package/CHANGELOG.md

@@ -5,15 +5,25 @@ 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.25.0
+
+*In preparation: the betas up to 1.25.0-beta.1. The section is complete with the release.*
+
+- **Data for the Strom widget on Windows too.** A research now writes what the Strom widget shows of it (what it works
+  on, the finds of the last 24 hours, what waits) also on Windows, into `%USERPROFILE%\.config\strom\widget`, with a
+  mark of the strom that wrote it. A widget reading its file never holds up the bridge. `strom uninstall` takes the
+  widget's files too, on a Mac as well; the research and the settings stay.
+
 ## 1.24.0
 
-*In preparation: the betas up to 1.24.0-beta.2. The section is complete with the release.*
+*2026-10-31 · goes with the Strom app 3.19.0.*
 
 - **Places mapped once for every research on this computer.** A place another research here has mapped to its
   regions of history is taken over when it is surely the same place (the same name and the same coordinates, parish
   or district) and every research maps it alike; only the place's map crosses, nothing of the family. A place of the
   same name that is not surely the same is offered to the agent as a suggestion; the agent maps only the rest.
-  `strom history adopt --dry-run` says what would be taken.
+  `strom history adopt --dry-run` says what would be taken. The question about turning the events of history on or off
+  says it holds for every research on this computer, and how to change it for one research alone.
 - **The fixes of a research for the Strom app.** The bridge lists what `strom fixes` offers in the research (title,
   what it does, how many items, its state, whether it can be put back), free and without writing anything; the link
   `strom-research://fixes` opens a fix in the research's terminal, where setting it right or putting it back is
@@ -23,12 +33,14 @@ The changes of each version in short. The full notes and the install lines are o
   file leaves out and for the sources without an excerpt. Only a public web page, never a recordset's address; the
   standard GEDCOM file keeps the address in the note. The date of the research's version in the Strom file carries its
   time too, so the app shows the day it was made also around midnight.
+- **A person's own lineage from the Strom app.** Where the Strom app marks that a person founds a lineage of their
+  own or carries none of the family's, `strom sync` keeps it in the research and the Strom file gives it back, so the
+  next send and another device show the same lineages; a merge of two people keeps the mark. The standard GEDCOM file
+  says nothing of it. It needs the Strom app 3.19.0.
 - **A house number, an age and a period as they were written.** The word for a house number ("No.", "čp.") is put only before
   a number standing alone; a street with its number goes into the file as it is. An age of "05y" is read as 5 years.
   Both come back from the Strom app the same, no edit of the user's. A period the Strom app keeps ("1871/1882", or
   open at one end) comes into the research as from … to …, never as a date somewhere between.
-- **The question about history says where it holds.** Turning the events of history on or off holds for every
-  research on this computer; the question says so, and how to change it for one research alone.
 - **A weak or refused model of the agent said by the doctor.** When no model is chosen for the research and the
   agent's own default is one the research found weak or refused for its work, `strom doctor` warns and gives the
   command to choose one; it never chooses itself.

package/assets/lang/cs.json

@@ -881,6 +881,7 @@
   "ui.uninstall.links": "odkazy z aplikace Strom",
   "ui.uninstall.git": "vlastní git stromu",
   "ui.uninstall.path": "záznam instalátoru v PATH",
+  "ui.uninstall.widget": "soubory widgetu Strom",
   "ui.uninstall.program": "program",
   "ui.uninstall.list": "strom z počítače odebere:",
   "ui.uninstall.keeps": "Výzkumy zůstávají ({home}), stejně jako nastavení s klíči, které je pečetí ({config}) – smazat je ručně, jen pokud už nikdy nebudou potřeba.",

package/assets/lang/de.json

@@ -881,6 +881,7 @@
   "ui.uninstall.links": "die Links aus der Strom-App",
   "ui.uninstall.git": "strom's eigenes git",
   "ui.uninstall.path": "der PATH-Eintrag des Installationsprogramms",
+  "ui.uninstall.widget": "die Dateien des Strom-Widgets",
   "ui.uninstall.program": "das Programm",
   "ui.uninstall.list": "strom entfernt von diesem Computer:",
   "ui.uninstall.keeps": "Die Forschungen bleiben ({home}), ebenso die Einstellungen mit den Schlüsseln, die sie versiegeln ({config}) – sie nur dann selbst löschen, wenn sie nie wieder gebraucht werden.",

package/dist/cli/main.js

@@ -38,6 +38,7 @@ import { expandFromLine, refreshLinks } from "../core/links.js";
 import { clockLine, FINISH_LINE, finishLimitLine, finishOf, timeLine } from "../core/clock.js";
 import { currentSession } from "../core/session.js";
 import { backgroundOf } from "../core/fetching.js";
+import { markWidget } from "../core/widget.js";
 import { callMistake, checkArgs, GroupOnly, parseOptions, resolveCommand, firstWord, severalRecords, splitPassthrough, usageOf } from "./execute.js";
 import { placeholders, UI, ui } from "./ui.js";
 import { catalog, localized, placeholdersOf, sayCommandAs } from "../core/phrases.js";
@@ -410,6 +411,8 @@ async function mainOf(argv, io, env, cwd) {
             ctx.settings.config.lastChannel = channel;
             ctx.settings.save();
             refreshGlobal(env);
+            // …and the widget on the desktop (macOS, Windows) learns this strom writes its files: index.json, even with no tree
+            markWidget(env);
             // …and the links from the Strom app lead to this strom again (where strom made them on this person's yes —
             // never another installation's: one with its own settings asks)
             try {

package/dist/cli/ui.js

@@ -718,6 +718,7 @@ export const UI = {
     "ui.uninstall.links": "the links from the Strom app",
     "ui.uninstall.git": "strom's own git",
     "ui.uninstall.path": "the installer's PATH entry",
+    "ui.uninstall.widget": "the Strom widget's files",
     "ui.uninstall.program": "the program",
     "ui.uninstall.list": "strom takes this off the computer:",
     "ui.uninstall.keeps": "The research stays ({home}), and so do the settings with the keys that seal it ({config}) — delete them by hand only if they are never wanted again.",

package/dist/commands/setup.js

@@ -68,6 +68,7 @@ import { ensureHooksDir } from "../core/hooks.js";
 import { claudeInChrome, CLAUDE_IN_CHROME_URL, downloadsDir } from "../core/browser.js";
 import { browserConnectors, fenceKeepsNetOff, listConnectors } from "../core/connector.js";
 import { appReadLimits } from "../core/live-read.js";
+import { markWidget } from "../core/widget.js";
 export const SHARED_DIRS = ["media", "catalog", "tools", "cache", "inbox"];
 export function ensureShared(dir) {
     for (const d of SHARED_DIRS)
@@ -94,6 +95,8 @@ register({
         const s = ctx.settings;
         if (ctx.interactive && !isAgent(ctx.env)) {
             const r = await setupWizard(ctx, { research: Boolean(opts.research) });
+            // the widget on the desktop (macOS, Windows) learns this strom writes its files
+            markWidget(ctx.env);
             // run in an archive (the Strom app's link to the research's settings too): research offered beside it
             let root;
             try {
@@ -184,6 +187,7 @@ register({
             cfg.trees = trees;
         s.save();
         fs.mkdirSync(home, { recursive: true });
+        markWidget(ctx.env);
         const sharedDir = s.shared().value;
         const treesDir = s.trees().value;
         fs.mkdirSync(treesDir, { recursive: true });

package/dist/commands/start.js

@@ -497,7 +497,7 @@ register({
     },
 }, {
     path: ["uninstall"],
-    summary: "Take strom off this computer: what the agents were taught, the shortcut, its own git, its PATH lines and the program — the research and the settings stay",
+    summary: "Take strom off this computer: what the agents were taught, the shortcut, its own git, its PATH lines, the widget's files and the program — the research and the settings stay",
     group: "setup",
     description: "The user's decision: a person at their terminal is asked there (--yes: no question); asked by an agent, strom asks\n" +
         "in a window of the system. Installed through npm, the program itself goes with npm uninstall -g strom-research.",

package/dist/core/json.js

@@ -42,7 +42,7 @@ export function stringifyCanonical(value) {
 export const RENAME_PATIENCE = 1500;
 const RENAME_FIRST_WAIT = 25;
 /** What another program holding the target (an antivirus, the search indexer, a backup) makes a rename fail with. */
-const HELD = new Set(["EPERM", "EBUSY", "EACCES"]);
+export const HELD = new Set(["EPERM", "EBUSY", "EACCES"]);
 /**
  * fn, again for a while on Windows when a file it uses is held: an antivirus, the indexer or a sync tool that has the
  * file open for a moment makes a rename, a read or a removal fail with EPERM, EBUSY or EACCES. The waits grow (25, 50,
@@ -88,14 +88,20 @@ export function readFileRetrying(file, platform = process.platform) {
 export function removeRetrying(file, platform = process.platform) {
     retryingHeld(file, platform, () => fs.rmSync(file, { force: true }));
 }
-/** Write via a temp file in the same directory and rename: never a half file. */
-export function writeFileAtomic(file, content) {
+/**
+ * Write via a temp file in the same directory and rename: never a half file. `patient: false`: the rename tried once,
+ * never waited for a file another program holds (the widget's files: the bridge's tick is never held up by a reader).
+ */
+export function writeFileAtomic(file, content, opts = {}) {
     const dir = path.dirname(file);
     fs.mkdirSync(dir, { recursive: true });
     const tmp = path.join(dir, `.${path.basename(file)}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`);
     fs.writeFileSync(tmp, content, "utf8");
     try {
-        renameRetrying(tmp, file);
+        if (opts.patient === false)
+            fs.renameSync(tmp, file);
+        else
+            renameRetrying(tmp, file);
     }
     catch (err) {
         fs.rmSync(tmp, { force: true });

package/dist/core/live.js

@@ -3727,8 +3727,8 @@ 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
+            // the research on the desktop (the Strom Widget of a Mac, the widget of Windows 11): the tree's overview written
+            // while the bridge runs (core/widget.ts; none but on macOS and Windows) — the first a moment after the start, never in its way
             const widget = widgetWriter(root, env);
             if (widget)
                 setTimeout(() => safe("the widget", () => widget.tick(true)), 1000).unref?.();

package/dist/core/stromapp.js

@@ -562,11 +562,11 @@ export function appKnowsPrimaryName(settings, version) {
  * The first Strom app that keeps the person's own bounds of a lineage (spec 028; the app's ZADANI_VYZKUM_rody.md):
  * it reads 1 _STROM_LINE FOUNDER|NOCARRY on a person and 1 _STROM_LINES Y in the header of the Strom file, keeps them
  * as its lineageOverrides and sends them back. An older app skips the tags and sends none back (a send of it says
- * nothing of them: no header mark). Not released yet (the app's 3.19.0); an app of unknown version (strom app from a
+ * nothing of them: no header mark). Released with the app 3.19.0; an app of unknown version (strom app from a
  * terminal) stays off, as the groups of a surname's forms; another copy of the app (its beta, its development) gets
  * them from APP_READS_LINES_BETA.
  */
-export const APP_READS_LINES = undefined;
+export const APP_READS_LINES = "3.19.0";
 /** The first beta of the app that reads and writes the bounds of a lineage (another copy of the app gets them from it). */
 export const APP_READS_LINES_BETA = "3.19.0-beta.4";
 /** Does the Strom app of this version keep the bounds of a lineage the person set (_STROM_LINE, _STROM_LINES)? */

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

package/dist/core/uninstall.js

@@ -1,8 +1,9 @@
 // What strom put on this computer outside the research, and taking it away
 // again (strom uninstall): what the agents were taught, the shortcut, strom's
-// own git, the PATH lines of the installer and the program itself. The
-// research stays, and so do the settings with the keys that seal it — they
-// are the user's; strom says where they are.
+// own git, the PATH lines of the installer, the widget's files (what it
+// showed of the research) and the program itself. The research stays, and so
+// do the settings with the keys that seal it — they are the user's; strom
+// says where they are.
 import fs from "node:fs";
 import path from "node:path";
 import { spawn, spawnSync } from "node:child_process";
@@ -13,6 +14,7 @@ import { globalTargets, isInstalled, uninstallGlobal } from "../agents/global.js
 import { PROFILES } from "../agents/profiles.js";
 import { holdsPath, installation, pathForms, PROGRAM_ENTRIES } from "./self.js";
 import { linkFiles, linkOwner, unregisterLinks } from "./links.js";
+import { widgetDir } from "./widget.js";
 /** The mark the installer (install/install.sh) puts on the PATH line it adds. */
 const MARK = "# strom research";
 const sys = (cmd, args) => {
@@ -328,6 +330,11 @@ export function uninstallPlan(env, names, opts = {}) {
             // none
         }
     }
+    // the widget's files (macOS, Windows): only what strom wrote there, the folder when nothing else is left in it — the
+    // widget would show the research as not at work for ever
+    const widget = widgetDir(env, platform);
+    if (widget && widgetFiles(widget).length && !holdsKept(widget, keep, platform))
+        remove.push({ kind: "widget", path: widget, remove: () => removeWidgetFiles(widget) });
     const program = inst.kind === "installed" ? inst.root : undefined;
     // install.json's launchers: those of a launcher's name outside the research only
     const chosen = launchersToTake(inst.launchers ?? [], keep, platform);
@@ -346,3 +353,26 @@ export function uninstallPlan(env, names, opts = {}) {
     const skipped = chosen.skipped.filter((l) => !pathForms(l, platform).some((f) => taken.has(f)));
     return { remove, npm: inst.kind === "npm", ...(program ? { program, launchers: chosen.take, skipped } : {}) };
 }
+/** What strom writes into the widget's folder: index.json, each tree's <ID>.json and a file being written beside one. */
+const WIDGET_FILE = /^(?:index|[0-9A-Za-z-]{1,64})\.json$|^\..+\.json\.\d+\.[0-9a-f]+\.tmp$/u;
+export function widgetFiles(dir) {
+    try {
+        return fs.readdirSync(dir).filter((n) => WIDGET_FILE.test(n) && fs.statSync(path.join(dir, n)).isFile());
+    }
+    catch {
+        return [];
+    }
+}
+/** The widget's files taken; the folder too when nothing else is in it (never what strom did not write there). */
+export function removeWidgetFiles(dir) {
+    for (const n of widgetFiles(dir))
+        fs.rmSync(path.join(dir, n), { force: true });
+    try {
+        if (!fs.readdirSync(dir).length)
+            fs.rmdirSync(dir);
+    }
+    catch {
+        // gone already, or another program's file in it: it stays
+    }
+    return !widgetFiles(dir).length;
+}

package/dist/core/widget.js

@@ -4,20 +4,22 @@
 // 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.
+// Written by the tree's bridge (strom live) while it runs, on macOS (~/Library/Application Support/Strom/widget/) and
+// Windows (%USERPROFILE%\.config\strom\widget\, the Windows 11 widget of strom-win): <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. index.json is there from this strom's first run and its setup on (`strom`: the
+// version that wrote it), so the widget tells a strom too old to write any from one whose bridge has not run yet.
 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 { Tree, VERSION } from "./tree.js";
 import { actsAsArchive } from "./state.js";
 import { foldText } from "./text.js";
-import { writeFileAtomic } from "./json.js";
+import { writeFileAtomic, HELD } from "./json.js";
 import { appUrlSetting } from "./stromapp.js";
 import { forPhone, treeOverview } from "./phone-watch.js";
 import { treeFinds } from "./phone-finds.js";
@@ -37,17 +39,23 @@ 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.
+ * Where the widget's files are written: none but on macOS and Windows; STROM_WIDGET_DIR when set; an isolated
+ * installation into its own settings folder; else on macOS ~/Library/Application Support/Strom/widget of the HOME strom
+ * runs with, on Windows %USERPROFILE%\.config\strom\widget — the profile's own folder (HOME may be Git Bash's), also
+ * with settings elsewhere (STROM_CONFIG_DIR), as the Mac's ~/Library. Never under AppData: an app packaged as MSIX
+ * (Claude's desktop app, whose agent starts the bridge) gets every new file there as a private copy of its own, which
+ * the widget would never see (found 2026-10-30 with the seal keys; core/paths.ts configDir).
  */
 export function widgetDir(env, platform = process.platform) {
-    if (platform !== "darwin")
+    if (platform !== "darwin" && platform !== "win32")
         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");
+    if (platform === "win32")
+        return path.join(env.USERPROFILE || userHome(env), ".config", "strom", "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). */
@@ -318,15 +326,37 @@ export function widgetTree(root, env, opts) {
 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. */
+/**
+ * A file of the widget written whole (a file beside it renamed over it) — at once or not now: the widget reading it this
+ * moment holds it on Windows (a rename over an open file fails with EPERM or EBUSY there), and the bridge never waits
+ * for it (writeFileAtomic's patience would hold the bridge's tick for 1.5 s). False: not written, nothing left beside
+ * it; the next look writes it.
+ */
+function writeNow(file, content) {
+    try {
+        writeFileAtomic(file, content, { patient: false });
+        return true;
+    }
+    catch (err) {
+        if (HELD.has(err.code ?? ""))
+            return false;
+        throw err;
+    }
+}
+/**
+ * index.json as the files of the trees there say it, written whole when it says something else (or another strom wrote
+ * it); the folder made when there is none (the mark of this strom: strom's first run, its setup). False: held by the
+ * widget this moment, not written.
+ */
 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;
+    catch (err) {
+        if (err.code !== "ENOENT")
+            return true;
     }
     for (const n of names.sort()) {
         try {
@@ -342,34 +372,64 @@ export function writeWidgetIndex(dir, now = Date.now()) {
     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;
+        if (JSON.stringify(was.trees) === JSON.stringify(trees) && was.schemaVersion === WIDGET_SCHEMA && was.strom === VERSION)
+            return true;
     }
     catch {
         // none yet
     }
-    writeFileAtomic(file, `${JSON.stringify({ schemaVersion: WIDGET_SCHEMA, generatedAt: isoSecond(now), trees }, null, 2)}\n`);
+    return writeNow(file, `${JSON.stringify({ schemaVersion: WIDGET_SCHEMA, generatedAt: isoSecond(now), strom: VERSION, trees }, null, 2)}\n`);
+}
+/**
+ * The mark that this strom writes the widget's files (on macOS and Windows): index.json, with no tree in it when no
+ * bridge ran yet — written at strom's first run of a version and at its setup. A widget that finds none tells a strom too
+ * old to write any (strom update) from one whose bridge has not run yet. Never in the way: any failure said nowhere.
+ */
+export function markWidget(env, platform = process.platform) {
+    const dir = widgetDir(env, platform);
+    if (!dir)
+        return;
+    try {
+        writeWidgetIndex(dir);
+    }
+    catch {
+        // written by the next bridge
+    }
 }
-/** A tree's file written whole (a file beside it renamed over it), then index.json. */
+/** A tree's file written whole (a file beside it renamed over it), then index.json. False: held by the widget, not now. */
 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());
+        return true;
+    if (!writeNow(treeFile(dir, data.treeKey), `${JSON.stringify(data, null, 2)}\n`))
+        return false;
+    return 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) {
+/**
+ * A tree's file taken away (its research gone, an archive now), and index.json without it. One the widget holds without
+ * letting it go (Windows) stays: it says at least `running: false` (as `last` was, or as it says), not a research at work
+ * for the quarter of an hour the widget takes to call it old.
+ */
+export function dropWidgetTree(dir, key, last) {
     if (!KEY.test(key))
         return;
+    const file = treeFile(dir, key);
     try {
-        fs.rmSync(treeFile(dir, key), { force: true });
+        fs.rmSync(file, { force: true });
     }
     catch {
+        try {
+            const was = last ?? JSON.parse(fs.readFileSync(file, "utf8"));
+            const at = isoSecond(Date.now());
+            writeWidgetTree(dir, { ...was, running: false, generatedAt: at, lastActiveAt: at });
+        }
+        catch {
+            // nothing more to do: the widget calls it old by itself
+        }
         return;
     }
     writeWidgetIndex(dir);
 }
-/** The writer of a tree's bridge; none off macOS. */
+/** The writer of a tree's bridge; none but on macOS and Windows. */
 export function widgetWriter(root, env, platform = process.platform, clock = Date.now) {
     const dir = widgetDir(env, platform);
     if (!dir)
@@ -381,40 +441,54 @@ export function widgetWriter(root, env, platform = process.platform, clock = Dat
     let said = "";
     let last;
     let key;
+    // what the widget held at the last look (Windows: renamed over an open file): written at the next tick, not the next look
+    let held;
     // what moves with the clock alone says nothing new
     const content = (t) => JSON.stringify({ ...t, generatedAt: "", lastActiveAt: "", findings: { ...t.findings, windowStart: "" } });
+    const write = (t, c, now) => {
+        if (!writeWidgetTree(dir, t)) {
+            held = { t, c };
+            return;
+        }
+        held = undefined;
+        said = c;
+        written = now;
+    };
     return {
         tick(force = false) {
             const now = clock();
-            if (!force && now - checked < checkMs)
+            if (!force && now - checked < checkMs) {
+                if (held)
+                    write({ ...held.t, generatedAt: isoSecond(now), lastActiveAt: isoSecond(now) }, held.c, now);
                 return;
+            }
             checked = now;
             const t = widgetTree(root, env, { running: true, now });
             if (!t) {
                 // an archive now: nothing of it on the desktop
                 if (key)
-                    dropWidgetTree(dir, key);
+                    dropWidgetTree(dir, key, last);
                 key = undefined;
                 last = undefined;
+                held = undefined;
                 said = "";
                 return;
             }
             key = t.treeKey;
             last = t;
             const c = content(t);
-            if (c === said && now - written < beatMs)
+            if (c === said && now - written < beatMs && !held)
                 return;
-            writeWidgetTree(dir, t);
-            said = c;
-            written = now;
+            write(t, c, now);
         },
         end(gone) {
             if (!key)
                 return;
             // what the file says now is no longer what was written: the next look writes it again
             said = "";
+            held = undefined;
             if (gone)
-                return dropWidgetTree(dir, key);
+                return dropWidgetTree(dir, key, last && { ...last, running: false });
             if (!last)
                 return;
             const at = isoSecond(clock());

package/package.json

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