npm - agent-dag - Versions diffs - 3.2.1 → 3.3.0 - Mend

agent-dag 3.2.1 → 3.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (33) hide show

package/README.md +18 -6
package/bin/deck.js +9 -1
package/dist/web/assets/index-GLqupad3.css +1 -0
package/dist/web/assets/index-Z0vOy1A6.js +165 -0
package/dist/web/index.html +2 -2
package/hook/hook.js +60 -14
package/package.json +6 -3
package/release-notes.json +26 -0
package/src/server/agent-activity.mjs +27 -11
package/src/server/browser-history.mjs +31 -5
package/src/server/browser-presence.mjs +57 -12
package/src/server/browser-react.mjs +31 -9
package/src/server/browser-watch-store.mjs +56 -2
package/src/server/browser-watch.mjs +90 -10
package/src/server/ccusage.mjs +95 -2
package/src/server/codex-quota.mjs +6 -2
package/src/server/codex-usage.mjs +24 -1
package/src/server/cswap-admin.mjs +0 -14
package/src/server/cswap-auto.mjs +39 -1
package/src/server/cswap-install.mjs +6 -1
package/src/server/exec.mjs +44 -0
package/src/server/index.mjs +127 -11
package/src/server/installer.mjs +58 -3
package/src/server/macmon.mjs +17 -6
package/src/server/npx.mjs +6 -1
package/src/server/open-url.mjs +25 -4
package/src/server/quota.mjs +88 -26
package/src/server/retire-sound-hook.mjs +36 -2
package/src/server/self-update.mjs +17 -5
package/src/server/system-metrics.mjs +28 -36
package/src/server/uv-bootstrap.mjs +39 -3
package/dist/web/assets/index-Bnn7d7u8.css +0 -1
package/dist/web/assets/index-COdHVcLu.js +0 -149

package/dist/web/index.html CHANGED Viewed

@@ -40,8 +40,8 @@
         document.documentElement.setAttribute("data-theme", stored === "light" ? "light" : "dark");
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-COdHVcLu.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-Bnn7d7u8.css">
+    <script type="module" crossorigin src="/assets/index-Z0vOy1A6.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-GLqupad3.css">
   </head>
   <body>
     <div id="root"></div>

package/hook/hook.js CHANGED Viewed

@@ -145,9 +145,19 @@ function capturesSession(cwd, workspace, platform = process.platform) {
   return cwdInWorkspace(cwd, workspace, platform);
 }
+// Signal 0 delivers nothing; it asks whether the pid could be signalled.
+//
+// BOTH ERRNOS, and the second one is the Windows spelling. POSIX `kill(2)`
+// answers EPERM for a process this account may not signal. On Windows
+// `uv_kill` calls `OpenProcess`, a denial is ERROR_ACCESS_DENIED, and libuv
+// maps that to EACCES — so a deck started from an elevated terminal, or under
+// another account, read as DEAD to every probe in this repo. What followed was
+// silent: the live deck's discovery file was unlinked on the next hook fire,
+// rewritten five seconds later by keepDiscovery, and its banner went on
+// claiming it was receiving events it had stopped receiving.
 function isAlive(pid) {
   try { process.kill(pid, 0); return true; }
-  catch (e) { return e && e.code === "EPERM"; }
+  catch (e) { return !!e && (e.code === "EPERM" || e.code === "EACCES"); }
 }
 /**
@@ -241,16 +251,25 @@ function challengeProof(token, nonce) {
  * of them listening and permanently empty, with its banner still saying it is
  * receiving events.
  *
- * A tokenless file therefore falls back to what shipped before the handshake:
- * pid liveness and nothing else. That is not a weakening of anything — it is
- * the exact risk every release up to 1.33.70 already carried, unchanged — and
- * it costs the hardening nothing, because a file that does carry a token still
- * gets no payload until the port answers correctly. Drop this fallback, and
- * refuse tokenless files again, once no deck older than 1.33.71 is plausibly
- * still running.
+ * THE FALLBACK IS GONE, on the condition this comment set for itself: "drop it
+ * once no deck older than 1.33.71 is plausibly still running". That release is
+ * two majors back — this package is on 3.x — so the window has closed.
+ *
+ * What it did while it stood: a tokenless discovery file was handed the payload
+ * on pid liveness alone, which is a control an adversary switches off by
+ * leaving a key out of a JSON file. It cost that adversary nothing to write
+ * one, since writing into the discovery directory at all is the capability in
+ * question — but a stale file from an old deck, or a port another program has
+ * since taken, is the ordinary case it also covered, and both are better served
+ * by refusing.
+ *
+ * The cost of refusing is stated plainly: a deck older than 1.33.71 running
+ * beside a current one receives nothing, while its banner still says it is
+ * connected. That was the reason to keep the fallback in the first place, and
+ * it is now a machine nobody has.
  */
 function requiresProof(d) {
-  return typeof d.token === "string" && d.token !== "";
+  return true;
 }
 // Constant-time compare, purely so a hostile listener cannot walk the expected
@@ -286,8 +305,28 @@ const POST_TIMEOUT_MS = 1000;
  *
  * A deck that advertised no token cannot be asked and passes: see requiresProof.
  */
-function prove(d, cb) {
+function prove(d, cb, attempt = 0) {
   let settled = false;
+  // A DEADLINE IS NOT AN ANSWER, and the difference is worth one retry.
+  //
+  // A wrong proof, a refused connection and a 404 are all verdicts: that port
+  // is not the deck this record describes, and asking again would get the same
+  // answer. A TIMEOUT is not — it is a machine too busy to reply in 400ms, and
+  // the deck on the other side is fine. Measured on the Windows box: the full
+  // test suite (335 files in parallel) is enough load to make a healthy deck
+  // miss that window, and the event is then dropped with nothing on screen to
+  // say so. A big build or a machine running several agents is the same shape.
+  //
+  // One retry, only on the deadline, and the budget still fits: 400 + 400 for
+  // the challenge and 1000 for the POST, under the 1900ms cap main() sets —
+  // which is itself under the two-second timeout the installed hook entry
+  // carries, so Claude Code never has to kill this process.
+  const retryOnTimeout = () => {
+    if (settled) return;
+    if (attempt >= 1) return finish(false);
+    settled = true;                        // this attempt is over; the next owns `cb`
+    prove(d, cb, attempt + 1);
+  };
   const finish = ok => { if (settled) return; settled = true; cb(ok); };
   if (!requiresProof(d)) return finish(true);
@@ -320,8 +359,12 @@ function prove(d, cb) {
       finish(sameProof(proof, want));
     });
   });
-  req.on("error", () => finish(false));
-  req.on("timeout", () => req.destroy());
+  // `destroy()` on a timeout makes 'error' fire with ECONNRESET, so the two
+  // handlers have to agree on which of them is speaking: `timedOut` is what
+  // tells a deadline apart from a refusal.
+  let timedOut = false;
+  req.on("error", () => { if (timedOut) retryOnTimeout(); else finish(false); });
+  req.on("timeout", () => { timedOut = true; req.destroy(); });
   req.end();
 }
@@ -392,8 +435,11 @@ function post(d, body, persists, done) {
 }
 function main() {
-  // Hard cap so a stuck server can never wedge the host CLI.
-  setTimeout(() => process.exit(0), 1500);
+  // Hard cap so a stuck server can never wedge the host CLI. 1900ms, which is
+  // the challenge's two attempts (400 + 400) plus the POST's 1000 with a little
+  // room — and still under the two-second timeout the installed hook entry
+  // carries, so this process ends itself rather than being killed.
+  setTimeout(() => process.exit(0), 1900);
   // The deck reads the Claude quota by running `claude --print /usage`, which is
   // a full Claude Code invocation and therefore fires these hooks. Reporting it

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "3.2.1",
+  "version": "3.3.0",
   "description": "Live deck of Claude Code and Codex agents — watch tool calls, token spend and every Claude Code subagent on one calm canvas. Run it with npx ccdeck.",
   "type": "module",
   "bin": {
@@ -19,12 +19,13 @@
   ],
   "scripts": {
     "dev:web": "vite",
-    "build:web": "vite build",
     "dev:server": "node src/server/index.mjs",
     "start": "node bin/agent-dag.js",
     "build": "vite build",
     "test": "vitest run",
-    "prepublishOnly": "vite build"
+    "prepublishOnly": "vite build",
+    "prepack": "vite build",
+    "typecheck": "tsc --noEmit -p tsconfig.build.json"
   },
   "engines": {
     "node": ">=18"
@@ -55,6 +56,8 @@
   },
   "homepage": "https://github.com/BarganConstantin/ccdeck#readme",
   "devDependencies": {
+    "@types/dagre": "^0.7.54",
+    "@types/node": "^22.20.1",
     "@types/react": "^18.3.12",
     "@types/react-dom": "^18.3.1",
     "@vitejs/plugin-react": "^4.3.4",

package/release-notes.json CHANGED Viewed

@@ -31,6 +31,32 @@
     "about a defect in the type, and the suite refuses both it and no space at",
     "all."
   ],
+  "3.3.0": [
+    {
+      "title": "📊 The Usage panel answers for a period, not just for the board",
+      "body": "It used to add up the sessions drawn on the canvas — which is an honest number with a scope nobody reads it as having: finished sessions are evicted a couple of minutes after they end, so the figure fell on its own while nothing had happened and nothing was refunded.\n\nIt now reads ccusage, the same source the H modal uses, and offers today, this month and all time. BY MODEL and BY SESSION come from there too, and each session is named by the project the board knows it as rather than by a uuid.\n\nThe live figure is still there, on its own line and labelled — what the sessions currently on the board have spent — because that is a different question from what the month cost.\n\nOne thing worth knowing about the source: ccusage reports a session's LIFETIME total, so the rows under \"active today\" can add up to more than the day above them. The heading says so."
+    },
+    {
+      "title": "🪟 Windows: a deck started from an elevated terminal was being treated as dead",
+      "body": "The hook decides whether a deck is still running by trying to signal it. On POSIX a process you may not signal answers EPERM; on Windows it answers EACCES, and only EPERM was accepted — so a deck started from an elevated terminal, or under another account, read as gone. Its registration was deleted on every event and rewritten five seconds later, while its banner went on saying it was connected and almost nothing arrived.\n\nThree more Windows-only faults went with it: a read-only settings.json made every hook install fail for good (the atomic write could not replace the file); the machine panel answered 500 every four seconds whenever the process read failed; and a bare command name was looked for in the working directory before PATH, which is where `npx ccdeck` was run."
+    },
+    {
+      "title": "👁 Browser Watch reads nothing while it is switched off",
+      "body": "The switch used to control only what was KEPT. The read happened anyway — every five minutes, on every deck, the panel's badge poll discovered each Chromium profile and copied its whole History database to a temp file to query it. A switch that says off while that continues is not a switch.\n\nWith the watch off, nothing touches a browser now. Opening the panel still reads live, because that is you looking, and a watch that is ON still records in the background — that is the feature. The trade is that the topbar badge no longer counts findings while the watch is off; open the panel to see them.\n\nThe README has a Browser Watch section now: what is read, when, where the copy goes, and that only visits after the deck started are ever considered."
+    },
+    {
+      "title": "🔒 The deck's own data is no longer readable by anything on the machine",
+      "body": "Changing an account needed the deck's credential; reading the event ring did not. Anything running on your machine could `curl` the events — prompt text, the commands an agent ran, the paths and contents it touched — plus the account list and the browsing episodes.\n\nThose reads now answer to the same rule the mutations do: the deck's own page, or its token. Nothing changes for you in the browser. A script of yours that reads those routes needs the token from `~/.claude/agent-dag/<pid>.json`, sent as `x-ccdeck-token`."
+    },
+    {
+      "title": "💳 An API-key, Bedrock or Vertex install is told there is no quota window",
+      "body": "Those installs are billed per token and have no five-hour window. The CLI ran, printed no quota lines, and the deck read that as a genuine \"under 1%\" — drawing two empty bars for a measurement nobody had taken, or telling you to run /usage, which cannot help there.\n\nIt now says what it is, in one line, the way the Codex half already did."
+    },
+    {
+      "title": "🎨 The model chip is coloured by its model again",
+      "body": "A session that switched model — Sonnet, then Opus — drew a chip reading \"Opus 5 +1\" in Sonnet blue, because the colour was picked from the tooltip and the tooltip lists every model the card's spend covers. Add a Fable turn and it went yellow.\n\nAlso fixed on the way past: an account import the CLI rejected could take the whole deck down with it, and a corrupt compressed Codex rollout leaked a file handle on every poll."
+    }
+  ],
   "3.2.1": [
     {
       "title": "💵 Sonnet 5 was being costed fifty per cent high",

package/src/server/agent-activity.mjs CHANGED Viewed

@@ -441,27 +441,43 @@ export function classify(visits, { quietMs = 15 * 60_000, exclude = [] } = {}) {
 export function toEpisodes(findings, { gapMs = 15 * 60_000 } = {}) {
   if (!Array.isArray(findings) || findings.length === 0) return [];
-  const byHost = new Map();
+  // GROUPED BY BROWSER AND HOST, not by host alone.
+  //
+  // The comment that used to stand here said "one host's findings all came from
+  // the same profile", and the caller makes that false: browser-watch
+  // concatenates the findings of every profile of every browser before handing
+  // them over. So Chrome and Brave both visiting gitlab.example.com inside one
+  // gap window became ONE episode, tagged with whichever browser was seen
+  // first — and with `reaction: "quit-browser"` that closes the wrong
+  // application, destroying a session the user was using while the one actually
+  // being driven stays open. The panel then reports the browser it quit.
+  //
+  // NUL as the separator because it cannot occur in either half: a host comes
+  // from `new URL(...).host` and a browser key is one of this repo's own
+  // identifiers.
+  const byPair = new Map();
   const browserOf = new Map();
+  const hostOf = new Map();
   for (const finding of findings) {
     const host = typeof finding?.host === "string" && finding.host !== "" ? finding.host : null;
     const url = typeof finding?.url === "string" ? finding.url : null;
     const timeMs = toMs(finding?.timeMs);
     if (host === null || url === null || timeMs === null) continue;
-    const rows = byHost.get(host);
-    if (rows === undefined) byHost.set(host, [{ url, timeMs }]);
+    const browser = typeof finding?.browser === "string" ? finding.browser : null;
+    const key = `${browser ?? ""}\u0000${host}`;
+    const rows = byPair.get(key);
+    if (rows === undefined) byPair.set(key, [{ url, timeMs }]);
     else rows.push({ url, timeMs });
-    // `browser` rides on the HOST, not on each url row: a url row is evidence
+    // `browser` rides on the GROUP, not on each url row: a url row is evidence
     // and its shape is pinned by a test that is right to pin it. A reaction
-    // downstream has to know which application to tell, and one host's findings
-    // all came from the same profile.
-    if (!browserOf.has(host) && typeof finding?.browser === "string") {
-      browserOf.set(host, finding.browser);
-    }
+    // downstream has to know which application to tell.
+    if (!browserOf.has(key) && browser !== null) browserOf.set(key, browser);
+    if (!hostOf.has(key)) hostOf.set(key, host);
   }
   const groups = [];
-  for (const [host, rows] of byHost) {
+  for (const [key, rows] of byPair) {
+    const host = hostOf.get(key);
     // A copy was built above, so this sorts nothing the caller can see. Callers
     // hand this the output of `classify`, and a function that reordered its
     // argument as a side effect would be a trap the second caller finds.
@@ -473,7 +489,7 @@ export function toEpisodes(findings, { gapMs = 15 * 60_000 } = {}) {
         open.endMs = row.timeMs;
         continue;
       }
-      open = { host, browser: browserOf.get(host) ?? null, startMs: row.timeMs, endMs: row.timeMs, urls: [row] };
+      open = { host, browser: browserOf.get(key) ?? null, startMs: row.timeMs, endMs: row.timeMs, urls: [row] };
       groups.push(open);
     }
   }

package/src/server/browser-history.mjs CHANGED Viewed

@@ -46,7 +46,8 @@
 // ── 3. THERE MAY BE NO SQLITE READER AT ALL ─────────────────────────────────
 //
 // `node:sqlite` exists only from Node 22.5, and this package declares
-// `engines: { node: ">=18" }` — CI itself runs Node 20. A top-level
+// `engines: { node: ">=18" }` — CI runs Node 22 on all three OSes and
+// Node 18 on one Linux leg, which is the version the package advertises. A top-level
 // `import "node:sqlite"` is therefore not an option: it throws
 // ERR_UNKNOWN_BUILTIN_MODULE at module load, before any of this file's own error
 // handling exists, and takes the server's import graph with it. It is loaded
@@ -63,6 +64,9 @@ import { copyFile, mkdir, rm } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { constants as fsConstants } from "node:fs";
+const { COPYFILE_EXCL } = fsConstants;
 import { pathLookup, run } from "./exec.mjs";
 /**
@@ -230,7 +234,7 @@ const loadSqlite = async () => {
  * CLI is the fallback rather than the default because every call to it costs a
  * process, and this runs on a poll.
  *
- * The dynamic import is inside a try/catch and covers more than "Node 20 has no
+ * The dynamic import is inside a try/catch and covers more than "Node 18 has no
  * such module". Between 22.5 and 22.12 node:sqlite existed but required
  * `--experimental-sqlite`, which the deck is not started with, and the import
  * fails there too — the same catch, the same fallback, no version arithmetic
@@ -333,9 +337,31 @@ export async function readVisitsSince(historyPath, sinceChromeTime, opts = {}) {
   let copyPath = null;
   try {
-    await makeDir(copyDir, { recursive: true });
-    copyPath = join(copyDir, `history-${process.pid}-${++copySeq}.sqlite`);
-    await copy(historyPath, copyPath);
+    // MODE 0700, AND A NAME NOBODY ELSE CAN PREDICT.
+    //
+    // `os.tmpdir()` is per-user on macOS (/var/folders/…, 0700) and on Windows,
+    // and on Linux it is the shared, world-writable /tmp. A fixed directory
+    // name and `history-<pid>-<n>.sqlite` inside it meant three things there,
+    // all of them avoidable:
+    //
+    //   * a complete, unencrypted copy of the user's browsing history, mode
+    //     0644, under a predictable path, readable by every other account on
+    //     the machine for the life of the poll;
+    //   * another UID can create the directory first — `mkdir` with `recursive`
+    //     swallows EEXIST and keeps THEIR mode — and then read every copy, or
+    //     plant a symlink at the name and have this overwrite a file the user
+    //     owns, because `copyFile` was called without COPYFILE_EXCL;
+    //   * a second user on the same box then fails EACCES on a directory they
+    //     cannot write, and their deck is degraded for good.
+    //
+    // The mode is set on creation AND after, because the directory may already
+    // exist from an earlier run of this same deck.
+    await makeDir(copyDir, { recursive: true, mode: 0o700 });
+    copyPath = join(copyDir, `history-${process.pid}-${++copySeq}-${randomUUID().slice(0, 8)}.sqlite`);
+    // COPYFILE_EXCL: refuse rather than write through a symlink or over a file
+    // that is already there. A refusal is one degraded poll; the alternative is
+    // clobbering whatever the name pointed at.
+    await copy(historyPath, copyPath, COPYFILE_EXCL);
   } catch (err) {
     // The browser is not installed, the profile moved, the disk is full. All of
     // them are "no rows this poll", none of them is a reason to stop polling.

package/src/server/browser-presence.mjs CHANGED Viewed

@@ -30,20 +30,65 @@ import { basename } from "node:path";
 import { browserRoots, hasExtension, profileDirs } from "./browser-profiles.mjs";
 import { run } from "./exec.mjs";
-/** The application name each browser's processes carry, for the probes below.
- *  Only the ones whose name is knowable; a root with no entry here is still
- *  reported as installed, just never as running. */
+/**
+ * The name each browser's processes carry — PER PLATFORM, because they do not
+ * agree.
+ *
+ * This used to be one table of macOS bundle display names, sent to all three
+ * probes. `tasklist /FI "IMAGENAME eq Google Chrome.exe"` matches nothing and
+ * exits **0** printing `INFO: No tasks are running…`, so the probe read
+ * `ok: true` and returned a confident `false`; `pgrep -x "Google Chrome"`
+ * matches against `comm`, which on Linux is `chrome`. Every browser on Windows
+ * and Linux therefore reported "not running", `relayLink` was never called, and
+ * the relay half of this panel was dead on two of the three platforms — while
+ * the module's own header forbids exactly that: a state that means "definitely
+ * not connected" when nothing established it.
+ *
+ * Arc is macOS-only and has no entry elsewhere, which is the honest answer: a
+ * root with no name here is reported as installed and never as running.
+ */
 const APP_NAME = {
-  chrome: "Google Chrome",
-  "chrome-beta": "Google Chrome Beta",
-  "chrome-canary": "Google Chrome Canary",
-  chromium: "Chromium",
-  brave: "Brave Browser",
-  edge: "Microsoft Edge",
-  vivaldi: "Vivaldi",
-  arc: "Arc",
+  darwin: {
+    chrome: "Google Chrome",
+    "chrome-beta": "Google Chrome Beta",
+    "chrome-canary": "Google Chrome Canary",
+    chromium: "Chromium",
+    brave: "Brave Browser",
+    edge: "Microsoft Edge",
+    vivaldi: "Vivaldi",
+    arc: "Arc",
+  },
+  // Image names, which is what tasklist's IMAGENAME filter compares against.
+  // The probe appends `.exe`, so these are spelled without it, exactly as the
+  // POSIX ones are.
+  win32: {
+    chrome: "chrome",
+    "chrome-beta": "chrome",
+    "chrome-canary": "chrome",
+    chromium: "chrome",
+    brave: "brave",
+    edge: "msedge",
+    vivaldi: "vivaldi",
+  },
+  // `comm`, which is what `pgrep -x` matches and what the packages install as.
+  linux: {
+    chrome: "chrome",
+    "chrome-beta": "chrome",
+    "chrome-canary": "chrome",
+    chromium: "chromium",
+    brave: "brave",
+    edge: "msedge",
+    vivaldi: "vivaldi-bin",
+  },
 };
+/** The process name for a browser on a platform, or null when this platform
+ *  has no name for it — which is a different answer from "not running". */
+export function processName(key, platform = process.platform) {
+  const table = APP_NAME[platform] ?? APP_NAME.linux;
+  return table[key] ?? null;
+}
 /** Every address the relay currently resolves to.
  *
  *  Empty is not an error — a machine with no `dig`, or one where the name is
@@ -139,7 +184,7 @@ export async function browserSurvey({
   for (const root of roots) {
     const installed = exists(root.root);
     const profiles = installed ? profileDirs(root.root, deps.fs) : [];
-    const app = APP_NAME[root.key] ?? null;
+    const app = processName(root.key, platform);
     const running = installed && app ? await isRunning(app, platform, deps) : false;
     out.push({
       key: root.key,

package/src/server/browser-react.mjs CHANGED Viewed

@@ -20,6 +20,9 @@
 // The session that opened it is still attached and can still read every other
 // tab. Only quitting takes anything back.
 import { run } from "./exec.mjs";
+// The one table of process names, shared with the presence probe so the reaction
+// and the "is it running" answer can never disagree about what to look for.
+import { processName } from "./browser-presence.mjs";
 /** Reactions this platform can actually carry out, in the order the panel
  *  should offer them. Never a list the caller has to filter again. */
@@ -107,17 +110,29 @@ export async function notify(title, body, platform = process.platform, deps = {}
     return r?.ok === true;
   }
   if (platform === "win32") {
-    // PowerShell's own toast, through the same argv discipline: the strings go
-    // in as parameters rather than as script text.
+    // THE STRINGS GO THROUGH THE ENVIRONMENT, and the previous spelling could
+    // not have worked at all. PowerShell documents that a string `-Command`
+    // must be the LAST parameter: everything after it is appended to the
+    // command text. So `… -t <title> -b <body>` was not two parameters, it was
+    // more script — pasted after `…Show($x)`, where it failed to parse — and
+    // `param($t,$b)` cannot receive arguments through `-Command` in any case.
+    // The toast therefore never appeared on Windows, for the reaction that is
+    // the default.
+    //
+    // That mistake also put attacker-chosen text into a script. `body` carries
+    // `episode.host`, which is `new URL(row.url).host` out of the browser's own
+    // history — the whole premise of this feature is that somebody else may
+    // have opened that page. `$env:` reads it as data at runtime, which is the
+    // same discipline the argv paths above keep.
     const r = await exec("powershell.exe", [
       "-NoProfile", "-NonInteractive", "-Command",
-      "param($t,$b); [void][Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType=WindowsRuntime];"
+      "[void][Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType=WindowsRuntime];"
       + "$x = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent(0);"
-      + "$n = $x.GetElementsByTagName('text'); $n.Item(0).AppendChild($x.CreateTextNode($t)) > $null;"
-      + "$n.Item(1).AppendChild($x.CreateTextNode($b)) > $null;"
+      + "$n = $x.GetElementsByTagName('text');"
+      + "$n.Item(0).AppendChild($x.CreateTextNode($env:CCDECK_TOAST_TITLE)) > $null;"
+      + "$n.Item(1).AppendChild($x.CreateTextNode($env:CCDECK_TOAST_BODY)) > $null;"
       + "[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('ccdeck').Show($x)",
-      "-t", title, "-b", body,
-    ]).catch(() => null);
+    ], { env: { ...process.env, CCDECK_TOAST_TITLE: title, CCDECK_TOAST_BODY: body } }).catch(() => null);
     return r?.ok === true;
   }
   const r = await exec("notify-send", [title, body]).catch(() => null);
@@ -151,11 +166,18 @@ export async function quitBrowser(browserKey, platform = process.platform, deps
     ]).catch(() => null);
     return { ok: r?.ok === true, reason: r?.ok ? "quit" : "script_failed" };
   }
+  // NOT THE DISPLAY NAME WITH ITS SPACES REMOVED. `"Google Chrome"` became
+  // `GoogleChrome.exe` and `google-chrome`, and neither is a process on either
+  // platform — so this reaction was offered on Windows and Linux and could
+  // never once have worked. The names live in browser-presence, which is where
+  // the other probe reads them from, so the two cannot drift apart.
+  const proc = processName(browserKey, platform);
+  if (!proc) return { ok: false, reason: "unknown_browser" };
   if (platform === "win32") {
-    const r = await exec("taskkill", ["/IM", `${app.replace(/ /g, "")}.exe`, "/F"]).catch(() => null);
+    const r = await exec("taskkill", ["/IM", `${proc}.exe`, "/F"]).catch(() => null);
     return { ok: r?.ok === true, reason: r?.ok ? "quit" : "taskkill_failed" };
   }
-  const r = await exec("pkill", ["-x", app.toLowerCase().replace(/ /g, "-")]).catch(() => null);
+  const r = await exec("pkill", ["-x", proc]).catch(() => null);
   return { ok: r?.ok === true, reason: r?.ok ? "quit" : "pkill_failed" };
 }

package/src/server/browser-watch-store.mjs CHANGED Viewed

@@ -48,7 +48,7 @@ const STORE_VERSION = 2;
  *  person could open and read. Trimmed oldest-first. */
 const KEEP = 500;
-export const storeDir = (home = claudeConfigDir()) => join(home, "agent-dag", "browser-watch");
+const storeDir = (home = claudeConfigDir()) => join(home, "agent-dag", "browser-watch");
 export const storePath = (home = claudeConfigDir()) => join(storeDir(home), "state.json");
 /** The plain-text log, which is the one file here a person opens themselves.
@@ -223,6 +223,22 @@ export async function readStore(home = claudeConfigDir(), deps = {}) {
  * driven — the one file whose loss this feature cannot absorb. installer.mjs
  * makes the same argument about settings.json, for the same reason.
  */
+/**
+ * One writer at a time, in this process.
+ *
+ * Three call sites write this file — the poll's snapshot, the settings route
+ * and the dismiss route — and none of them knew about the others. The queue is
+ * the same shape `log-writer.mjs` uses for its appends: a promise chain that
+ * survives a rejection, so one failed write cannot wedge every later one.
+ */
+let _chain = Promise.resolve();
+let _writeSeq = 0;
+function serialized(job) {
+  const started = _chain.then(job, job);
+  _chain = started.then(() => {}, () => {});
+  return started;
+}
 /**
  * Write the whole store, atomically.
  *
@@ -235,6 +251,11 @@ export async function readStore(home = claudeConfigDir(), deps = {}) {
  * test that greps this file's callers for the field.
  */
 export async function writeStore(state, home = claudeConfigDir(), deps = {}) {
+  return serialized(() => writeNow(state, home, deps));
+}
+/** The write itself, already inside the queue. */
+async function writeNow(state, home, deps) {
   const mk = deps.mkdir ?? mkdir;
   const write = deps.writeFile ?? writeFile;
   const mv = deps.rename ?? rename;
@@ -245,11 +266,44 @@ export async function writeStore(state, home = claudeConfigDir(), deps = {}) {
     episodes: (state.episodes ?? []).map(archivable),
     dismissed: [...new Set(state.dismissed ?? [])].slice(-DISMISS_KEEP),
   }, null, 2) + "\n";
-  const tmp = `${storePath(home)}.${process.pid}.tmp`;
+  // A NAME NO SECOND WRITE CAN BE USING. The pid distinguishes decks and not
+  // the calls inside one, and there are three writers in this process — the
+  // poll's snapshot, the settings route and the dismiss route — with nothing
+  // between them. Measured with a full 500-episode archive (~2.5 MB, past the
+  // 512 KiB writeFile chunk): eight concurrent runs left state.json unparseable
+  // in six of them and failed one call with ENOENT, renaming a temp file the
+  // other writer had already renamed away. readStore swallows a corrupt file,
+  // so the next poll reported an empty archive and no dismissals at all — total
+  // loss of the one file this feature exists to keep.
+  const tmp = `${storePath(home)}.${process.pid}.${++_writeSeq}.tmp`;
   await write(tmp, body, "utf8");
   await mv(tmp, storePath(home));
 }
+/**
+ * Read, change, write — with nothing else writing in between.
+ *
+ * `writeStore` writes what it is handed and merges nothing, which is right for
+ * a whole-state write and wrong for a caller that owns one field. The snapshot
+ * takes about 400ms — a 21 MB History copy plus the sqlite read — and used to
+ * write back the `dismissed` and `settings` it had read at the start, so a
+ * dismissal made while it ran was reverted by the next poll ten seconds later.
+ * The settings route and the dismiss route had the same shape against each
+ * other.
+ *
+ * So a caller that owns one field passes a function instead: it runs inside the
+ * same queue the write does, against the state on disk at that moment, and no
+ * other writer can slip between the read and the write.
+ */
+export async function updateStore(mutate, home = claudeConfigDir(), deps = {}) {
+  return serialized(async () => {
+    const current = await readStore(home, deps);
+    const next = (await mutate(current)) ?? current;
+    await writeNow(next, home, deps);
+    return next;
+  });
+}
 /**
  * The archive with `seen` folded into it, newest first and capped.
  *