strom-research 1.24.0 → 1.25.0-beta.1

package/CHANGELOG.cs.md

@@ -5,6 +5,15 @@
 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
 
 *31. 10. 2026 · patří k aplikaci Strom 3.19.0.*

package/CHANGELOG.de.md

@@ -5,6 +5,16 @@
 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
 
 *31.10.2026 · gehört zur Strom-App 3.19.0.*

package/CHANGELOG.md

@@ -5,6 +5,15 @@ 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
 
 *2026-10-31 · goes with the Strom app 3.19.0.*

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/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";
+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",
+  "version": "1.25.0-beta.1",
   "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"
   }
 }