npm - agent-dag - Versions diffs - 3.8.6 → 3.8.8 - Mend

agent-dag 3.8.6 → 3.8.8

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 (9) hide show

package/dist/web/assets/index-DLRqo4Ty.js +217 -0
package/dist/web/index.html +1 -1
package/package.json +1 -1
package/release-notes.json +12 -0
package/src/server/ccusage.mjs +20 -2
package/src/server/cswap-auto.mjs +30 -5
package/src/server/index.mjs +47 -11
package/src/server/system-metrics.mjs +42 -10
package/dist/web/assets/index-BnUiIfx6.js +0 -205

package/dist/web/index.html CHANGED Viewed

@@ -40,7 +40,7 @@
         document.documentElement.setAttribute("data-theme", stored === "light" ? "light" : "dark");
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-BnUiIfx6.js"></script>
+    <script type="module" crossorigin src="/assets/index-DLRqo4Ty.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-ByAgTqB8.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "3.8.6",
+  "version": "3.8.8",
   "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": {

package/release-notes.json CHANGED Viewed

@@ -31,6 +31,18 @@
     "about a defect in the type, and the suite refuses both it and no space at",
     "all."
   ],
+  "3.8.8": [
+    {
+      "title": "\ud83d\udcc9 A false 99% on the memory chart, and three other quiet failures",
+      "body": "**The machine meter no longer invents a reading.** When the deck could not measure memory \u2014 a subprocess that would not start under load, or one that took too long \u2014 it substituted a number that means something else, and on a Mac that reads as about 99% used. The meter went red for half a minute, and because the chart keeps the highest value in each minute, that false peak stayed on it for a full day. A poll that cannot measure now keeps the last reading and records nothing: a gap in the chart is honest.\n\n**A failed ccusage repair no longer disables the repair.** If the deck found a half-installed copy it removes it and starts again. On Windows that removal can fail for a few seconds because the program it just ran still has the folder open \u2014 and the deck then treated the attempt as spent and never tried again for the rest of the session, leaving the panel permanently unable to read your usage. It now only counts a repair that happened.\n\n**Changing the auto-switch interval takes effect even during startup.** Set it in the first seconds after launch and the timer kept the old value for the life of the process, while the panel showed the new one.\n\n**Codex sessions with very large histories no longer cost hundreds of megabytes to read.** The deck read the whole file to find four values that live at its two ends \u2014 measured at 185 MB of memory and 95ms of frozen interface for one 44 MB session. It now reads only the ends."
+    }
+  ],
+  "3.8.7": [
+    {
+      "title": "\ud83e\udde0 Four things in the panel that behaved wrongly",
+      "body": "**Today's figure no longer overshoots.** Once a minute, when a fresh reading landed, the headline briefly counted past the true number and back down \u2014 it was measuring the last minute of spend from a starting point one moment out of date. The reading and its starting point are now recorded together, so there is no moment where they can disagree.\n\n**Browser Watch marks findings read when you close it, not when you open it.** It was clearing the badge immediately, and stamping every new finding as read the moment it arrived \u2014 so anything that turned up while you were reading was never badged at all. It was also writing to storage four times a second the whole time the panel was open.\n\n**A hidden tool category can always be brought back.** Hide one, leave the deck running, and once the canvas had turned over the row of chips disappeared while the filter stayed on \u2014 no bubbles, and nothing to press. Only reloading fixed it. The chips now stay for as long as anything is hidden.\n\n**Clicking a session's name no longer switches auto-fit off.** The deck was reading its own camera move as you grabbing the canvas, and remembered it across restarts, with nothing said."
+    }
+  ],
   "3.8.6": [
     {
       "title": "\ud83d\uddc2\ufe0f Two decks can no longer both claim the same log",

package/src/server/ccusage.mjs CHANGED Viewed

@@ -682,7 +682,19 @@ let _repairedThisRun = false;
 function discardDamagedInstall(runner, err) {
   if (_repairedThisRun || runner.kind !== "node" || installsDisabled()) return false;
   if (!cannotLoadModule(err?.message)) return false;
-  _repairedThisRun = true;
+  // THE FLAG IS SPENT ON A REPAIR THAT HAPPENED, not on one that was attempted
+  // (#790). It used to be set here, before the try — and the rm below fails on
+  // Windows for the reason its own maxRetries comment gives: the `node <entry>`
+  // child that just exited still holds a handle, the unlink marks the file
+  // delete-pending, and rmdir answers ENOTEMPTY past all ten retries. The catch
+  // returned false with NOTHING removed, and every later modal open and every
+  // 60s poll for the life of the deck then short-circuited on this same flag —
+  // including seconds later, once the handle was gone and the rm would have
+  // worked. The user's only way out was deleting ~/.agents-deck/ccusage by
+  // hand, which nothing tells them.
+  //
+  // The budget exists to stop a loop of INSTALLS. Here it was being consumed by
+  // a repair that never happened and never reached an install.
   try {
     // maxRetries because of what has just happened: the deck ran `node <entry>`
     // out of this very directory a moment ago, and on Windows a file any handle
@@ -700,7 +712,13 @@ function discardDamagedInstall(runner, err) {
     // rather than retrying into the same broken entry point.
     return false;
   }
-  return !resolveEntry();
+  const gone = !resolveEntry();
+  // Only now. The directory is really gone, so this deck has spent its one
+  // repair and the budget is doing its job. A failed `rm` returned false above
+  // without touching the flag, so the next poll — seconds later, once the
+  // handle is released — is free to try again.
+  if (gone) _repairedThisRun = true;
+  return gone;
 }
 /**

package/src/server/cswap-auto.mjs CHANGED Viewed

@@ -268,6 +268,8 @@ export async function setCswapConfig(key, value) {
   // Lowering it was equally inert.
   if (r.ok && key === "autoswitch.intervalSeconds" && _enabled) {
     stopLoop();
+    // startLoop records the ask when one is already in flight, so this can no
+    // longer be swallowed by the boot's own start — see the note there (#791).
     await startLoop();
   }
   return r.ok ? { ok: true } : { ok: false, reason: "set_failed", detail: (r.stderr || r.stdout).trim().slice(0, 300) };
@@ -580,19 +582,42 @@ function tick() {
  * has turned it off is the same defect from the other side.
  */
 async function startLoop() {
-  if (_timer || _starting) return;
+  // A start requested while one is already in flight is REMEMBERED, not dropped
+  // (#791). `initCswapAuto()` is fired unawaited at boot, so this sits inside
+  // `await tickInterval()` — a `cswap config` spawn, preceded on Windows by
+  // cswapBin() probing up to four spellings, two of them through cmd.exe, each
+  // with an 8s deadline — while the panel is already serving. A user setting
+  // the interval in that window called stopLoop() (no timer yet: a no-op) and
+  // then startLoop(), which returned here having done nothing; the boot's own
+  // start then resumed with the interval it had read BEFORE the write and
+  // installed the timer at the old value. The panel read back the new number
+  // while the loop kept the old one for the life of the process.
+  if (_starting) { _restartWanted = true; return; }
+  if (_timer) return;
   _starting = true;
   try {
-    const ms = await tickInterval();
-    if (!_enabled) return;   // turned off while we were asking cswap
-    _timer = setInterval(() => { tick().catch(() => {}); }, ms);
-    _timer.unref?.();
+    // Loop rather than a single pass: the config may be written again while
+    // THIS read is in flight, and the answer must be the last one written.
+    for (;;) {
+      _restartWanted = false;
+      const ms = await tickInterval();
+      if (!_enabled) return;   // turned off while we were asking cswap
+      if (_restartWanted) continue;   // the interval changed under this read
+      _timer = setInterval(() => { tick().catch(() => {}); }, ms);
+      _timer.unref?.();
+      break;
+    }
   } finally {
     _starting = false;
   }
   tick().catch(() => {});   // don't make the user wait a full interval for the first one
 }
+/** Set when a restart is asked for while `startLoop` is mid-read, so the read
+ *  that is already running takes the new value instead of installing the old
+ *  one. Module-level beside `_starting`, which it exists to answer for. */
+let _restartWanted = false;
 function stopLoop() {
   if (_timer) { clearInterval(_timer); _timer = null; }
 }

package/src/server/index.mjs CHANGED Viewed

@@ -1851,21 +1851,57 @@ async function findCodexRolloutPath(sid) {
   return found;
 }
-/** Tail-read a Codex rollout JSONL. Returns the last token_count info block
- *  plus the most recent observed model + the session's model_context_window
- *  (set once from task_started). */
-async function readCodexRollout(path) {
+/**
+ * The head and the tail of a Codex rollout, never the middle.
+ *
+ * WHAT THIS FIXES (#792). It called itself a tail-read and read the whole file:
+ * `Buffer.alloc(s.size)` in one go, then `split` and `JSON.parse` over every
+ * line. Measured against this machine's own largest rollout — 44.4 MB — that is
+ * 181ms to read and decode, 95ms of SYNCHRONOUS parsing blocking the event
+ * loop, and 185 MB of resident memory for the buffer, the string and the split
+ * array together. Past about 512 MB `toString` throws outright, the catch
+ * answers null, and the deck reports no Codex usage or model for the rest of
+ * its life.
+ *
+ * It is reached from `/api/event`, which is in OPEN_MUTATIONS — no token, no
+ * browser identity — so any local process can ask for it, and the per-session
+ * throttle is keyed on `sid`, which means distinct sid strings each get their
+ * own budget. That note's own rule is the one this violated: the deck's memory
+ * "cannot be a function of anything but the two constants named here".
+ *
+ * WHY HEAD AND TAIL RATHER THAN A CURSOR. The four fields do not live in one
+ * place. `session_meta` is the FIRST record — cwd, sometimes the model — while
+ * the last `token_count`, the last `task_started` and the newest
+ * `response_item` model are all at the END. A forward cursor would have to keep
+ * the head's answers across polls, which is a second cache to invalidate; two
+ * bounded reads answer the same question with no state at all.
+ *
+ * A file smaller than both windows is read once, so nothing changes for the
+ * ordinary rollout — the median here is well under a megabyte.
+ */
+const CODEX_HEAD_BYTES = 256 * 1024;
+const CODEX_TAIL_BYTES = 2 * 1024 * 1024;
+// Exported for the suite, which is the only way to drive the head-and-tail
+// branch: building a rollout larger than both windows is cheap, and reaching
+// this function through /api/event would mean a server, a discovery file and a
+// throttle that all have nothing to do with what is being measured.
+export async function readCodexRollout(path) {
   try {
     const s = await stat(path);
     if (s.size === 0) return null;
-    const fh = await open(path, "r");
     let text;
-    try {
-      const buf = Buffer.alloc(s.size);
-      await fh.read(buf, 0, s.size, 0);
-      text = buf.toString("utf8");
-    } finally {
-      await fh.close();
+    if (s.size <= CODEX_HEAD_BYTES + CODEX_TAIL_BYTES) {
+      text = await readByteRange(path, 0, s.size);
+    } else {
+      // A newline between them so the two windows cannot splice a half line
+      // from the head onto a half line from the tail and hand the parser a
+      // record that never existed. The tail's own first line is partial by
+      // construction and is dropped the same way: `JSON.parse` refuses it and
+      // the loop below skips it.
+      const head = await readByteRange(path, 0, CODEX_HEAD_BYTES);
+      const tail = await readByteRange(path, s.size - CODEX_TAIL_BYTES, s.size);
+      text = `${head}\n${tail}`;
     }
     let lastUsage = null;
     let model = null;

package/src/server/system-metrics.mjs CHANGED Viewed

@@ -262,6 +262,32 @@ export function availableFromVmStat(text, total) {
   return total != null && avail > total ? null : avail;
 }
+/**
+ * How much memory is really available, or NULL when this machine could not be
+ * asked.
+ *
+ * `os.freemem()` USED TO BE THE FALLBACK ON BOTH REAL PLATFORMS, and it is the
+ * one number this function exists to avoid (#789). The header above says why:
+ * counting only genuinely free pages makes the naive `(total - free) / total`
+ * read 99.5% on an idle 32 GB Mac — "a number that would send the reader
+ * straight to Activity Monitor, which is the one outcome this readout exists to
+ * prevent". So a failed measurement produced exactly the reading the module was
+ * written to suppress.
+ *
+ * And it did not merely flicker. `record` folds into the minute bucket by
+ * MAXIMUM, so one failed poll painted a red 99% peak on the memory chart that
+ * survived every good sample for the next twenty-four hours. The failure is
+ * ordinary: `run` resolves null on a spawn error (EAGAIN/EMFILE under fork
+ * pressure — a deck watching many agents is exactly that), on a non-zero exit,
+ * and on its own 2s deadline. 2,880 chances a day.
+ *
+ * Null instead, and the caller keeps the previous reading and records nothing.
+ * A gap in the chart is honest; a 99% peak is not.
+ *
+ * The last branch still answers `freemem()` because on Windows there is no
+ * better source to have failed — it is the measurement, not a substitute for
+ * one.
+ */
 async function readAvailable(platform = process.platform) {
   const total = os.totalmem();
@@ -269,14 +295,13 @@ async function readAvailable(platform = process.platform) {
     try {
       const parsed = availableFromMeminfo(await readFile("/proc/meminfo", "utf8"));
       if (parsed != null) return parsed;
-    } catch { /* fall through to freemem */ }
-    return os.freemem();
+    } catch { /* unreadable /proc — say so rather than guessing */ }
+    return null;
   }
   if (platform === "darwin") {
     const out = await run("vm_stat", []);
-    const parsed = out ? availableFromVmStat(out, total) : null;
-    return parsed ?? os.freemem();
+    return (out ? availableFromVmStat(out, total) : null) ?? null;
   }
   return os.freemem();
@@ -1382,15 +1407,22 @@ async function sampleMemory() {
   try {
     const total = os.totalmem();
     const available = await readAvailable();
-    memory = {
-      total,
-      available,
-      usedPct: Math.max(0, Math.min(100, Math.round(((total - available) / total) * 1000) / 10)),
-    };
+    // A poll that could not measure leaves the last reading standing and puts
+    // nothing in the history (#789). Recording a guess here is worse than
+    // recording nothing twice over: the meter would go red for 30 seconds, and
+    // the bucket's Math.max would keep that peak on the chart for a day.
+    // Swap below is a separate measurement and is still taken.
+    if (available != null) {
+      memory = {
+        total,
+        available,
+        usedPct: Math.max(0, Math.min(100, Math.round(((total - available) / total) * 1000) / 10)),
+      };
+      record("mem:physical", memory.usedPct);
+    }
     // Same 30s cadence as memory, and for the same reason: it moves in minutes
     // and costs a subprocess on two of the three platforms.
     swap = await readSwap();
-    record("mem:physical", memory.usedPct);
     if (swap && swap.total > 0) record("mem:swap", Math.round((swap.used / swap.total) * 1000) / 10);
   } catch { /* keep the previous reading rather than blanking the meter */ }
   finally { memInFlight = false; }