npm - agent-dag - Versions diffs - 3.0.0 → 3.2.0 - Mend

agent-dag 3.0.0 → 3.2.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 (17) hide show

package/README.md +33 -0
package/bin/deck.js +266 -61
package/dist/web/assets/{index-6cAJDiBs.js → index-7UsJp5Ht.js} +40 -22
package/dist/web/index.html +1 -1
package/package.json +1 -4
package/release-notes.json +28 -0
package/src/server/boot-deadline.mjs +127 -0
package/src/server/cswap-install.mjs +61 -8
package/src/server/hwmonitor.mjs +56 -0
package/src/server/index.mjs +102 -23
package/src/server/lhm-parse.mjs +91 -0
package/src/server/log-tail.mjs +139 -0
package/src/server/macmon.mjs +299 -0
package/src/server/open-url.mjs +226 -0
package/src/server/quota.mjs +48 -2
package/src/server/system-metrics.mjs +211 -18
package/src/server/term.mjs +79 -3

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-6cAJDiBs.js"></script>
+    <script type="module" crossorigin src="/assets/index-7UsJp5Ht.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Bnn7d7u8.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "3.0.0",
+  "version": "3.2.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": {
@@ -54,9 +54,6 @@
     "url": "https://github.com/BarganConstantin/ccdeck/issues"
   },
   "homepage": "https://github.com/BarganConstantin/ccdeck#readme",
-  "dependencies": {
-    "open": "^10.1.0"
-  },
   "devDependencies": {
     "@types/react": "^18.3.12",
     "@types/react-dom": "^18.3.1",

package/release-notes.json CHANGED Viewed

@@ -31,6 +31,34 @@
     "about a defect in the type, and the suite refuses both it and no space at",
     "all."
   ],
+  "3.2.0": [
+    {
+      "title": "🌡️ Windows shows a temperature where it can find one",
+      "body": "On most Windows laptops there is nothing to show, and that is Windows rather than this deck: modern machines declare no ACPI thermal zone, and the sensors that do exist sit behind an interface only an administrator may read. Measured on real hardware, elevated and not.\n\nOne thing does work, and it costs you nothing to have. If LibreHardwareMonitor happens to be running with its web server on, the deck now reads its numbers over localhost — which needs no privileges at all.\n\nIt is only ever a read. Nothing is installed, nothing is asked of you, and a machine without it shows no section, exactly as before."
+    }
+  ],
+  "3.1.0": [
+    {
+      "title": "🚀 The first run stops looking like it hung",
+      "body": "`npx ccdeck` on a machine that has never run it used to sit on a spinner at \"checking claude-swap\" and say nothing else. Measured on a Windows box: seventeen and a half seconds before it told you where to point a browser. It is now one and a half.\n\nThe deck was waiting for an install nobody asked for during that boot — a Python toolchain being fetched so the accounts panel would work. The port had been open the whole time; there was just nothing on screen to say so.\n\nIt no longer waits. Anything still working past the boot says so on its own line and keeps going in the background, and the deck comes up without it."
+    },
+    {
+      "title": "⚡ Every start is quicker, and stays quicker",
+      "body": "The event log was read from the beginning on every boot to fill a buffer that only keeps the last two thousand events — so four fifths of that reading existed to be thrown away, and it got slower the longer you had been using the deck. It reads from the end now and stops when the buffer is full: 258ms down to 20ms here, on a 34 MB log, and it no longer grows.\n\nThe accounts tool is also asked for its version once instead of twice, which on this machine was the single largest thing in an ordinary boot."
+    },
+    {
+      "title": "📉 Ten fewer packages to install",
+      "body": "Opening your browser used to cost a dependency that brought nine more with it — ten downloads on a cold `npx ccdeck` before the deck's own files were unpacked. It is now done with the commands the operating system already has.\n\nThe package has no runtime dependencies at all."
+    },
+    {
+      "title": "🌡️ Temperature, on the machines that could not show it",
+      "body": "On Windows the deck was asking somewhere it is not allowed to look: that reading lives behind a namespace that needs administrator, so it failed for everybody and the section never appeared. It reads a performance counter now, which needs nothing.\n\nOn Apple Silicon there is no command that ships with macOS which prints a temperature at all — the sensors are behind an interface only native code can reach. The deck fetches a small signed tool for it, verified against the checksum its release publishes, in the background and only on the Macs that need it. You do not have to install anything. `AGENTS_DECK_NO_DOWNLOAD=1` turns that off.\n\nA machine with no sensor still shows no section, which includes every virtual machine. Nothing is drawn that was not measured."
+    },
+    {
+      "title": "😌 The terminal goes quiet when there is nothing happening",
+      "body": "The dot at the bottom blinked every 800ms for as long as the deck ran, which is what a terminal does while it is working — so a deck that had finished in a second looked like one that never finished.\n\nIt now moves only while something actually is: a job still running, or hooks that cannot find the deck. Otherwise it is drawn once and left alone, and it says what the job is rather than just blinking. A step that takes more than three seconds shows how long it has been going, which is the whole of \"is this stuck\".\n\nAnd a machine with no Claude Code installed stops being told about it every few seconds — that one is said once now, on its own line instead of across the status line."
+    }
+  ],
   "3.0.0": [
     {
       "title": "📈 The machine panel now shows what it DID, not just what it is",

package/src/server/boot-deadline.mjs ADDED Viewed

@@ -0,0 +1,127 @@
+// The boot has a deadline, and the jobs under it do not get to decide it.
+//
+// #742. Two people on two operating systems reported the same thing: `npx
+// ccdeck`, the wordmark, four rows, then a spinner at "checking claude-swap…"
+// and nothing — no "server ready", no browser, no way to tell a slow machine
+// from a dead one. The port was open the whole time. What they were watching
+// was `reportStartup` awaiting `ensureCswap`, which on a machine that has
+// neither claude-swap nor a Python toolchain downloads a uv binary under a
+// 120-second deadline and then runs `uv tool install claude-swap` under a
+// 180-second one. Five minutes, worst case, before the line that says where to
+// point a browser — for a panel that is optional and that nobody asked for
+// during that boot.
+//
+// The install itself is not the bug and is not cancelled here. What was wrong
+// is that the boot waited for it. So every job whose failure is not fatal is
+// given a slice of the boot rather than the whole of it, and a job that is
+// still working when its slice runs out is SAID SO and left running. The row it
+// would have printed is printed later, when it settles, which is the same
+// contract the deck already has with its background upgrade.
+//
+// bin/deck.js's `update` job has raced a timer since it was written — this is
+// that idea, given a name and the one thing the inline race could not do: tell
+// "the job answered null" apart from "the job did not answer", which for
+// claude-swap is the difference between "not installed" and "still installing".
+/** How long the whole report may spend waiting on jobs that are not fatal.
+ *
+ *  Eight seconds is chosen from the two ends it sits between. Below it are the
+ *  probes a normal boot really does pay — `cswap --version`, `uv --version`,
+ *  a PyPI lookup — which finish in well under a second on a warm machine and in
+ *  two or three on a cold one behind a slow DNS; a deadline under that would
+ *  turn every honest boot into a background one and the rows would stop being
+ *  where a reader looks for them. Above it is the only thing the deadline
+ *  exists to bound, and that one is measured in minutes, so there is no value
+ *  in the middle that anybody would notice being wrong. */
+export const BOOT_DEADLINE_MS = 8_000;
+/**
+ * The deadline, as the environment may override it.
+ *
+ * Tests need a boot they can watch inside a test budget, and a test that has to
+ * wait eight real seconds to prove the deadline works is a test that costs the
+ * suite eight seconds forever. Read from the environment rather than passed
+ * down through four call sites for one caller that is not the product.
+ *
+ * Anything unparseable, negative, or absent is the default. Zero is honoured —
+ * "give the jobs nothing" is a coherent thing for a test to ask for, and the
+ * timer path below still runs, so it exercises the same code the product does.
+ */
+export function bootDeadlineMs(env = process.env) {
+  const raw = env.AGENTS_DECK_BOOT_DEADLINE_MS;
+  if (raw === undefined || raw === "") return BOOT_DEADLINE_MS;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : BOOT_DEADLINE_MS;
+}
+/**
+ * Await `work`, but never past `ms`.
+ *
+ * Answers `{ done: true, value }` or `{ done: false, value: undefined }`. A
+ * shape rather than a sentinel value, because three of the jobs this wraps
+ * resolve to `null` on purpose — "not attempted" is a real answer and must not
+ * read as "ran out of time".
+ *
+ * A rejection is a settled job, not a timeout: `{ done: true, value: undefined
+ * }`. Every caller here already attached its own rejection handler at the point
+ * the promise was created, so the throw has been dealt with and what is left to
+ * decide is only whether to keep waiting. Re-throwing would turn a job that
+ * failed politely into a boot that died.
+ *
+ * The timer is cleared the moment the job settles, so a boot whose jobs all
+ * answer at once does not hold the event loop for the rest of the deadline.
+ *
+ * It is deliberately NOT unref'd. An unref'd deadline is a deadline that does
+ * not fire when the only thing left in the process is the deadline itself —
+ * which is exactly the shape of a test that awaits nothing else, and would have
+ * made this function pass by exiting rather than by working. The cost of
+ * keeping it is at most one deadline's worth of a process that was about to
+ * end, against a deck that runs until Ctrl+C.
+ */
+export function within(work, ms, { setTimer = setTimeout, clearTimer = clearTimeout } = {}) {
+  return new Promise(resolve => {
+    let answered = false;
+    const timer = setTimer(() => {
+      if (answered) return;
+      answered = true;
+      resolve({ done: false, value: undefined });
+    }, ms);
+    Promise.resolve(work).then(
+      value => {
+        if (answered) return;
+        answered = true;
+        clearTimer(timer);
+        resolve({ done: true, value });
+      },
+      () => {
+        if (answered) return;
+        answered = true;
+        clearTimer(timer);
+        resolve({ done: true, value: undefined });
+      },
+    );
+  });
+}
+/**
+ * A deadline shared by everything that draws on it, in the order they are
+ * awaited.
+ *
+ * One budget for the whole report rather than one each, because the rows are
+ * awaited in sequence and per-job deadlines would multiply: four jobs at eight
+ * seconds is a thirty-two second boot that every individual deadline would call
+ * within its budget. What a reader was promised is that the deck is ready
+ * within the deadline, and that promise is about the sum.
+ *
+ * `left()` never goes below zero, so a job reached after the budget is spent is
+ * given a zero-length slice and reported as still working — which it is.
+ */
+export function budget(ms, now = Date.now) {
+  const started = now();
+  return {
+    left: () => Math.max(0, ms - (now() - started)),
+    spent: () => now() - started,
+    /** Await `work` against whatever is left. */
+    within: (work, deps) => within(work, Math.max(0, ms - (now() - started)), deps),
+  };
+}

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

@@ -266,15 +266,50 @@ export function cswapOwner(bin, platform = process.platform, env = process.env,
 }
 let _bin = null;
+/**
+ * What the probe that resolved `_bin` printed, and when.
+ *
+ * #742: resolving the binary means running `cswap --version`, and reading the
+ * version means running `cswap --version`. Those were two separate spawns of a
+ * Python CLI a moment apart, and on this Mac each one costs between one and two
+ * and a half seconds — which made a probe of an ALREADY INSTALLED claude-swap
+ * the single largest thing in an ordinary boot.
+ *
+ * The second spawn is what this retires, and only the second: anything asking
+ * later gets a fresh answer, because a version read once at boot is not a
+ * version for the life of a deck that runs for days and may upgrade the tool
+ * underneath itself. Five seconds is long enough to cover cswapBin handing
+ * straight over to cswapVersion and far too short to be a cache.
+ */
+let _probe = null;
+const PROBE_FRESH_MS = 5_000;
+/** "claude-swap 0.25.0" → "0.25.0", and "installed" for a copy that answered
+ *  without a number in it. Shared so the memo and the spawn cannot disagree. */
+function versionIn(r) {
+  const m = (r.stdout || r.stderr).trim().match(/(\d+\.\d+\.\d+\S*)/);
+  return m ? m[1] : "installed";
+}
 export async function cswapBin() {
   // An explicit path wins over everything and is never cached away — someone
   // debugging a bad resolution needs it to take effect immediately.
   if (process.env.AGENTS_DECK_CSWAP) return process.env.AGENTS_DECK_CSWAP;
   if (_bin) return _bin;
-  if ((await run("cswap", ["--version"], { timeout: 8_000 })).ok) return (_bin = "cswap");
+  const take = (spelling, r) => {
+    _probe = { version: versionIn(r), at: Date.now() };
+    return (_bin = spelling);
+  };
+  const bare = await run("cswap", ["--version"], { timeout: 8_000 });
+  if (bare.ok) return take("cswap", bare);
   for (const c of cswapCandidates()) {
-    if (existsSync(c) && (await run(c, ["--version"], { timeout: 8_000 })).ok) return (_bin = c);
+    if (!existsSync(c)) continue;
+    const r = await run(c, ["--version"], { timeout: 8_000 });
+    if (r.ok) return take(c, r);
   }
   return "cswap";   // not found; leave the bare name so errors read sensibly
 }
@@ -299,15 +334,18 @@ export async function cswapBin() {
  * ensureCswap below, whose return value says nothing about which binary the
  * following twenty account operations will be sent to. See cswap-bin-memo.test.ts.
  */
-export function resetCswapBin() { _bin = null; }
+export function resetCswapBin() { _bin = null; _probe = null; }
 /** Installed version string, or null when cswap cannot be found. */
 export async function cswapVersion() {
-  const r = await run(await cswapBin(), ["--version"]);
+  const bin = await cswapBin();
+  // The call above may have just asked this very question — see _probe. Nothing
+  // is remembered past PROBE_FRESH_MS, so this is the second half of one
+  // lookup rather than a cache of the answer.
+  if (_probe && Date.now() - _probe.at < PROBE_FRESH_MS) return _probe.version;
+  const r = await run(bin, ["--version"]);
   if (!r.ok) return null;
-  // "claude-swap 0.25.0" → "0.25.0"
-  const m = (r.stdout || r.stderr).trim().match(/(\d+\.\d+\.\d+\S*)/);
-  return m ? m[1] : "installed";
+  return versionIn(r);
 }
 /**
@@ -536,8 +574,19 @@ async function findUpgrader(owner) {
  *
  * Returns a small status the CLI prints verbatim:
  *   { state: "present" | "installed" | "upgrading" | "skipped" | "unavailable", ... }
+ *
+ * `onInstalling` is called at most once, at the moment this stops asking
+ * questions and commits to an install — which is the moment the answer stops
+ * being seconds away and starts being minutes away. #742: the boot used to have
+ * no way to tell those two apart, so it waited out its whole deadline on a
+ * machine whose answer was already decided. Everything before that call is
+ * probes; everything after it is a uv download and an environment build.
+ *
+ * Deliberately a callback and not a state on the return value: what the caller
+ * needs is the news, not the outcome, and the outcome is the thing that takes
+ * three minutes to arrive.
  */
-export async function ensureCswap() {
+export async function ensureCswap({ onInstalling = null } = {}) {
   if (process.env.AGENTS_DECK_NO_INSTALL === "1") {
     const version = await cswapVersion();
     return version ? { state: "present", version } : { state: "skipped" };
@@ -565,6 +614,10 @@ export async function ensureCswap() {
     return { state: "present", version: existing };
   }
+  // Said before the install starts rather than after it, because after it is
+  // three minutes later and the whole point is not to be waited for.
+  try { onInstalling?.(); } catch { /* a caller's notification is not our problem */ }
   const result = await installCswap();
   if (!result.ok) return { state: "unavailable", ...result };
   // Something was just installed, so any path resolved before it is a guess made

package/src/server/hwmonitor.mjs ADDED Viewed

@@ -0,0 +1,56 @@
+// Windows' temperature, when something else on the machine already has it.
+//
+// #747. On a modern Intel laptop Windows publishes no CPU temperature that an
+// ordinary process may read. Measured on a physical Windows 11 machine, both
+// elevated and not: the firmware declares zero ACPI thermal zones, MSAcpi
+// answers "Not supported" even to an administrator, Win32_TemperatureProbe is a
+// stub whose every field reads 32768, and the one source that DOES have the
+// numbers — Intel Dynamic Tuning's `EsifDeviceInformation` — is Access denied
+// without admin. That is the state of Windows, not a gap in this deck: there is
+// no standard user-mode API for it, which is why every tool that shows one
+// installs a kernel driver.
+//
+// LibreHardwareMonitor is such a tool. It installs that driver, reads the
+// registers directly, and — if its web server is switched on — publishes
+// everything as plain HTTP on localhost. Reading THAT needs no privileges at
+// all.
+//
+// SO THIS IS A READ, NEVER A REQUEST. The deck does not install
+// LibreHardwareMonitor, does not ask anybody to, and does not mention it: a
+// user must do nothing but install ccdeck. If the tool happens to be running —
+// and on the machines where this matters it often is, because the person who
+// wants a temperature has already gone and got one — the deck uses it. If not,
+// the section is not drawn, exactly as before.
+import { readTemps } from "./lhm-parse.mjs";
+/** LibreHardwareMonitor's default, and Open Hardware Monitor's before it. Not
+ *  probed across a range: a scan of somebody's loopback ports is not a thing to
+ *  do unasked, and a user who moved the port can say so. */
+export const LHM_URL = "http://127.0.0.1:8085/data.json";
+/** Short. A refused connection returns at once; this bounds the case where
+ *  something else holds the port open and never answers. */
+const TIMEOUT_MS = 1_500;
+export function lhmUrl(env = process.env) {
+  const port = Number(env.AGENTS_DECK_LHM_PORT);
+  return Number.isInteger(port) && port > 0 && port < 65536
+    ? `http://127.0.0.1:${port}/data.json`
+    : LHM_URL;
+}
+/**
+ * CPU and GPU degrees from a running LibreHardwareMonitor, or nothing.
+ *
+ * Never throws: nothing listening is the ordinary answer, and it arrives as a
+ * rejected fetch.
+ */
+export async function readHwMonitorTemps({ env = process.env, fetchFn = fetch } = {}) {
+  try {
+    const res = await fetchFn(lhmUrl(env), { signal: AbortSignal.timeout(TIMEOUT_MS) });
+    if (!res.ok) return {};
+    return readTemps(await res.json());
+  } catch {
+    return {};
+  }
+}

package/src/server/index.mjs CHANGED Viewed

@@ -5,12 +5,11 @@
 // describes. Nothing else in this file talks to anything but 127.0.0.1 clients.
 import { createServer, request as httpRequest } from "node:http";
 import { readFile, stat, mkdir, open, truncate, readdir, unlink } from "node:fs/promises";
-import { createReadStream, existsSync, readFileSync, realpath as realpathCb, realpathSync } from "node:fs";
+import { existsSync, readFileSync, realpath as realpathCb, realpathSync } from "node:fs";
 import { extname, join, resolve, sep, dirname as pdirname } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { dirname } from "node:path";
-import { createInterface } from "node:readline";
 import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
 import { promisify } from "node:util";
 import { claudeConfigDir } from "./claude-dir.mjs";
@@ -19,6 +18,7 @@ import { PRODUCT } from "./brand.mjs";
 import { invokedName, renameNotice } from "./invoked-as.mjs";
 import { appendLogLine, codexCwdInWorkspace, electWriters, foldsCase, writesCodexLog } from "./log-writer.mjs";
 import { historySnapshot, readProcesses, startSystemMetrics, systemSnapshot } from "./system-metrics.mjs";
+import { linesFromEnd, linesFromStart } from "./log-tail.mjs";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PKG_ROOT = resolve(__dirname, "..", "..");
@@ -3360,9 +3360,34 @@ function pushEvent(raw, source, opts = {}) {
  *   two replays.
  */
 export function replayScope(workspace, platform = process.platform) {
-  if (!workspace || typeof workspace !== "string") return () => true;
+  if (!workspace || typeof workspace !== "string") {
+    const all = () => true;
+    // Every caller gets the same answer for the same payload, forever. That is
+    // what lets replayLog read the log from its end — see `orderDependent` on
+    // the scoped predicate below for the half that cannot.
+    all.orderDependent = false;
+    return all;
+  }
   const bySession = new Map();
-  return function admits(payload) {
+  /**
+   * THE ANSWER DEPENDS ON WHAT CAME BEFORE, and #742 is why that is now stated
+   * out loud rather than left as an implementation detail.
+   *
+   * The synthetic enrichment events — ModelObserved, UsageObserved,
+   * SessionNamed, ContextObserved — carry a session_id and no cwd, so the only
+   * thing that can decide them is a cwd-bearing event for the same session,
+   * and that event is EARLIER in the log. Fed the log backwards, this predicate
+   * meets the enrichment first, has nothing in `bySession`, and drops it: the
+   * session lands on the canvas with no model and no tokens.
+   *
+   * So the flag is not advice. replayLog reads it, and reads the file forwards
+   * whenever it is set. Making a scoped replay cheap needs an index of where a
+   * workspace's lines are, which is a different change from this one.
+   */
+  admits.orderDependent = true;
+  return admits;
+  function admits(payload) {
     if (!payload || typeof payload !== "object") return false;
     if (payload.hook_event_name === "__clear") return true;
     const sid = typeof payload.session_id === "string" ? payload.session_id : null;
@@ -3408,38 +3433,92 @@ export function replayScope(workspace, platform = process.platform) {
  * declining a session it was told not to capture is the flag doing its job. They
  * are two different things and only the first is ever printed.
  *
- * WHAT THE FILTER COSTS AT BOOT, honestly: nothing is saved on the read. Every
- * line is still streamed off disk and still JSON.parsed, because the cwd being
- * judged is inside the JSON — a 30 MB log is 30 MB of reading and parsing on a
- * scoped deck exactly as on an unscoped one. What it saves is everything after
- * the parse: no redaction pass, no envelope, no ring insert, no character
- * accounting and no eviction pressure for a line this deck should never have
- * held. The ring is bounded by MAX_BUFFER events AND MAX_BUFFER_CHARS, so on a
- * busy machine the out-of-scope traffic was not merely extra — it was evicting
- * the in-scope sessions the user started the deck to watch.
+ * WHAT THE FILTER COSTS AT BOOT, honestly: nothing is saved on the read of any
+ * line this reaches, because the cwd being judged is inside the JSON. What it
+ * saves is everything after the parse: no redaction pass, no envelope, no ring
+ * insert, no character accounting and no eviction pressure for a line this deck
+ * should never have held. The ring is bounded by MAX_BUFFER events AND
+ * MAX_BUFFER_CHARS, so on a busy machine the out-of-scope traffic was not
+ * merely extra — it was evicting the in-scope sessions the user started the
+ * deck to watch.
+ *
+ * READ BACKWARDS, AND ONLY AS FAR AS THE RING (#742). This used to stream the
+ * whole file from the front, and the whole file is where the boot's time went:
+ * 12,079 lines and 31 MB on the machine it was measured on, 690ms of
+ * JSON.parse, growing with every session until rotation cuts it at 50 MB — to
+ * fill a ring that holds two thousand events. Five sixths of that parse was
+ * feeding the eviction loop, on the critical path of a boot, every time.
+ *
+ * So the lines arrive newest-first and the loop stops the moment the ring is
+ * full, which makes the cost a property of MAX_BUFFER rather than of how long
+ * the user has been running the deck. Nothing is lost by it: what a forward
+ * replay left in the ring was always the NEWEST admitted events that fit, and
+ * that is exactly the set this collects. A young log — too few events to fill
+ * the ring — is read to its start, and costs what it always did.
+ *
+ * The order of the pushes is still oldest-first. `seq` is assigned by pushEvent
+ * in the order it is called, and a ring numbered backwards would hand every
+ * resuming client a Last-Event-ID that means the opposite of what it says.
+ *
+ * A SCOPED DECK STILL READS FORWARDS, and that is not an oversight. Its
+ * predicate decides the cwd-less enrichment events — ModelObserved,
+ * UsageObserved, SessionNamed, ContextObserved — from the cwd-bearing event
+ * earlier in the log, so backwards it meets the answer after the question and
+ * drops them: the session arrives on the canvas with no model and no tokens.
+ * `replayScope` says which kind of predicate it handed over rather than this
+ * inferring it from the workspace string, so the two cannot drift apart. Making
+ * that case cheap needs an index of where a workspace's lines are, which is a
+ * different change from this one.
  */
 async function replayLog(filePath, workspace = "") {
   if (!existsSync(filePath)) return 0;
-  let count = 0;
   let skipped = 0;
   let skippedBytes = 0;
   const admits = replayScope(workspace);
-  const rl = createInterface({ input: createReadStream(filePath, { encoding: "utf8" }) });
-  for await (const line of rl) {
-    if (!line) continue;
+  const replay = (evt) =>
+    pushEvent(evt.payload, evt.source ?? "replay", { receivedAt: evt.receivedAt, replay: true });
+  const parse = (line) => {
     try {
-      const evt = JSON.parse(line);
-      if (evt && typeof evt === "object" && evt.payload) {
-        if (!admits(evt.payload)) continue;
-        pushEvent(evt.payload, evt.source ?? "replay", { receivedAt: evt.receivedAt, replay: true });
-        count++;
-      }
+      return JSON.parse(line);
     } catch {
       skipped++;
       skippedBytes += Buffer.byteLength(line, "utf8");
+      return null;
+    }
+  };
+  const usable = (evt) => evt && typeof evt === "object" && evt.payload;
+  let count = 0;
+  if (admits.orderDependent) {
+    for await (const line of linesFromStart(filePath)) {
+      if (!line) continue;
+      const evt = parse(line);
+      if (!usable(evt) || !admits(evt.payload)) continue;
+      replay(evt);
+      count++;
+    }
+  } else {
+    // Newest first, so this is filled back to front and then walked in reverse
+    // to push. Bounded by MAX_BUFFER, which is what makes the memory here a
+    // property of the ring rather than of the file.
+    const newestFirst = [];
+    for await (const line of linesFromEnd(filePath)) {
+      if (!line) continue;
+      const evt = parse(line);
+      if (!usable(evt) || !admits(evt.payload)) continue;
+      newestFirst.push(evt);
+      // Everything older than this would be evicted by the events already held,
+      // so reading further is work whose only result is throwing it away.
+      if (newestFirst.length >= MAX_BUFFER) break;
     }
+    for (let i = newestFirst.length - 1; i >= 0; i--) replay(newestFirst[i]);
+    count = newestFirst.length;
   }
   if (skipped > 0) {
+    // "in the part of the log it read", because that is now a part rather than
+    // the whole: a damaged line older than the ring is never reached, and
+    // claiming to have counted every unreadable line in the file would be a
+    // number this no longer has.
     const kb = (skippedBytes / 1024).toFixed(0);
     console.warn(`${PRODUCT}: skipped ${skipped} unreadable line(s) (${kb}KB) while replaying the event log`);
   }

package/src/server/lhm-parse.mjs ADDED Viewed

@@ -0,0 +1,91 @@
+// Reading LibreHardwareMonitor's sensor tree, out of the shape its own source
+// produces rather than out of an example.
+//
+// `GenerateJsonForNode` in HttpServer.cs builds every node as
+//
+//   { id, Text, Min, Value, Max }
+//
+// and a SENSOR node adds
+//
+//   SensorId : "/intelcpu/0/temperature/0"     the stable identifier
+//   Type     : "Temperature"                    the SensorType enum, as text
+//   Value    : "52.0 °C"                        formatted for a human
+//   RawValue : 52.0                             the number, unformatted
+//
+// Two of those decide this file.
+//
+// RAWVALUE, NEVER VALUE. `Value` is formatted with the machine's culture, so on
+// a German or Russian Windows it reads "52,0 °C" — a comma — and every naive
+// parse of it either throws away the decimal or produces 520. `RawValue` is the
+// number itself. This is the same trap the deck already hit once with `ps`
+// output and fixed with LC_NUMERIC.
+//
+// AND RAWVALUE CAN BE THE STRING "NaN". The server serialises with
+// JsonNumberHandling.AllowNamedFloatingPointLiterals, which writes a NaN as a
+// quoted "NaN" rather than failing — so a sensor that has not read yet arrives
+// as text where a number is expected. `Number("NaN")` is NaN and is rejected
+// below, which is the right answer, but it is rejected on purpose rather than
+// by luck.
+//
+// TYPE, NEVER THE NAME. `Type` comes from an enum and is the same word on every
+// machine in every language; the `Text` beside it is a display name that
+// differs between vendors and driver versions.
+/** A plausible temperature. The same floor the rest of the thermal code uses:
+ *  0 is a sensor that has not read, and nothing above this is a temperature. */
+const plausible = (c) => Number.isFinite(c) && c > 0 && c < 150;
+/**
+ * Every temperature sensor in the tree, flattened.
+ *
+ * Exported for its own test, and because "what did that machine actually
+ * publish" is the question anybody debugging this will have first.
+ */
+export function flattenSensors(root) {
+  const out = [];
+  const walk = (n, depth) => {
+    // The tree is four or five deep in practice — root, computer, hardware,
+    // type, sensor. The bound is against a cycle, which JSON cannot contain but
+    // a hand-written fixture can.
+    if (!n || typeof n !== "object" || depth > 12) return;
+    if (n.Type === "Temperature") {
+      out.push({
+        id: String(n.SensorId ?? ""),
+        name: String(n.Text ?? ""),
+        celsius: Number(n.RawValue),
+      });
+    }
+    if (Array.isArray(n.Children)) for (const c of n.Children) walk(c, depth + 1);
+  };
+  walk(root, 0);
+  return out;
+}
+/**
+ * Which sensor is the CPU, and which is the GPU.
+ *
+ * Chosen by SensorId rather than by name. The identifier is built from the
+ * hardware type — `/intelcpu/0/…`, `/amdcpu/0/…`, `/gpu-nvidia/0/…` — and is
+ * the same on every machine, while `Text` is a display name that reads "CPU
+ * Package" on one driver and "Core (Tctl/Tdie)" on another.
+ *
+ * The HOTTEST of a hardware's sensors is taken, not the first. A CPU publishes
+ * a package reading and one per core; the package is usually the highest and is
+ * what a person means by "the CPU temperature", and where a vendor publishes no
+ * package the hottest core is the honest stand-in. Taking the first would
+ * report core #1 while core #6 is thermal-throttling.
+ */
+export function readTemps(root) {
+  const sensors = flattenSensors(root).filter(s => plausible(s.celsius));
+  const hottest = (re) => {
+    const mine = sensors.filter(s => re.test(s.id));
+    if (!mine.length) return null;
+    return Math.round(Math.max(...mine.map(s => s.celsius)));
+  };
+  const out = {};
+  const cpu = hottest(/^\/(intel|amd)cpu\//i);
+  const gpu = hottest(/^\/gpu-/i);
+  if (cpu != null) out.cpu = cpu;
+  if (gpu != null) out.gpu = gpu;
+  return out;
+}