ccdeck 3.22.3 → 3.22.5

package/dist/web/index.html

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccdeck",
-  "version": "3.22.3",
+  "version": "3.22.5",
   "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

@@ -394,5 +394,11 @@
       "title": "🖥️ A first run now opens This machine too",
       "body": "Accounts and usage already opened themselves the first time you ran the deck; the machine panel did not, and now does. It is the panel that answers \"is this box coping\" — cores, memory, load, temperature — and somebody meeting the deck for the first time cannot ask for a panel they do not know is there.\n\nIt only does this when you have never said otherwise. Close it once and it stays closed, on that browser, for good — the same rule the other two panels have always followed. Nothing reopens it behind you.\n\nWhile it is open it polls this machine once every few seconds, and it stops the moment you close it or switch tabs."
     }
+  ],
+  "3.22.4": [
+    {
+      "title": "📈 A card stops looking idle while it is thinking",
+      "body": "The activity chart on each card counted tool calls and nothing else, so the time an agent spends reading, reasoning and writing drew as a flat line — measured on this machine, 16.5% of all working time, more than the time spent inside the tools themselves. A session that was busy looked exactly like one that had died, and the only way to tell them apart was to wait and see whether anything ever appeared.\n\nIt marks that work now. A chart with bars in it means the agent is doing something, whether or not it has called a tool in the last minute; a flat chart means it genuinely is not. Hover it for the split — how many tool calls and how many blocks of thinking and writing landed in the last 60 seconds.\n\nNothing was added to the card and nothing new is polled. The deck already reads each session's transcript for its token counts; this reads the same file for what the model has finished writing, and a session that is quiet costs one file check per second and a half."
+    }
   ]
 }

package/src/server/index.mjs

@@ -27,6 +27,9 @@ import { CODEX_HOME, CODEX_SESSIONS_DIR, STOP, walkRolloutDays } from "./codex-d
 import { PRODUCT } from "./brand.mjs";
 import { createBlockNotifier } from "./block-notify.mjs";
 import { createActivity } from "./activity.mjs";
+// What a session is producing between its tool calls — the 16.5% of measured
+// time the hooks cannot see. See output-watch.mjs.
+import { createOutputWatch } from "./output-watch.mjs";
 import { AWAY_BOOT_GRACE_MS, AWAY_RECHECK_MS, AWAY_TICK_MS, awayGate, awayUpdateStep } from "./auto-update.mjs";
 import { createPresence } from "./presence.mjs";
 import { DEFAULTS as PREF_DEFAULTS, cleanAlias, isAliasKey, notificationsOn, notificationsVetoed, publicPrefs, readPrefs, writePrefs } from "./deck-prefs.mjs";
@@ -2781,7 +2784,49 @@ export function eventsSince(seq) {
 const sessionTouchedAt = new Map();   // sid -> ms of the last event seen
 const MAX_TRACKED_SESSIONS = 256;
 
+/** The transcript watch, and how far back a session stays worth polling.
+ *
+ *  A session is polled while its last HOOK event is recent — and the window has
+ *  to be generous for exactly the reason this watch exists: a session that is
+ *  thinking has, by definition, not fired a hook. Measured on this machine's
+ *  log, the gaps with no event at all run to p99 53s and 155s at the longest,
+ *  so five minutes clears the whole measured distribution and still keeps the
+ *  polled set to the sessions somebody is actually running. */
+const outputWatch = createOutputWatch();
+const OUTPUT_WATCH_WINDOW_MS = 5 * 60_000;
+const OUTPUT_WATCH_MS = 1_500;
+let outputWatchTimer = null;
+
+/** One tick: stat the recent sessions' transcripts, read only what grew, and
+ *  say what landed. Everything expensive about this is guarded inside the watch
+ *  — a session that wrote nothing costs one `stat`. */
+async function outputWatchOnce() {
+  const cutoff = Date.now() - OUTPUT_WATCH_WINDOW_MS;
+  const live = [];
+  for (const [sid, at] of sessionTouchedAt) if (at >= cutoff) live.push(sid);
+  if (!live.length) return;
+  const found = await outputWatch.poll(live);
+  for (const f of found) {
+    pushEvent({
+      hook_event_name: "OutputObserved",
+      session_id: f.sid,
+      kind: f.kind,
+      at: f.at,
+    }, "internal");
+  }
+}
+
+function startOutputWatch() {
+  if (outputWatchTimer) return outputWatchTimer;
+  outputWatchTimer = setInterval(() => { outputWatchOnce().catch(() => {}); }, OUTPUT_WATCH_MS);
+  // Unref'd like the Codex watcher beside it: a poll must never be the reason
+  // the process stays up.
+  if (outputWatchTimer.unref) outputWatchTimer.unref();
+  return outputWatchTimer;
+}
+
 function forgetSession(sid) {
+  outputWatch.forget(sid);
   modelBySession.delete(sid);
   // The two the session-naming work added (#520/#522) and did not list here.
   // Both are keyed by session id and nothing else ever removed an entry, which
@@ -3792,6 +3837,10 @@ function pushEvent(raw, source, opts = {}) {
       maybeResolveUsage(raw);
       maybeResolveContext(raw);
       maybeResolveSessionName(raw);
+      // Where the transcript IS, learned from the one place it is free. The
+      // four scanners above read it on this event; the watch reads it between
+      // events, which is the whole of what it adds.
+      if (raw?.transcript_path) outputWatch.note(raw.session_id, raw.transcript_path);
     } else {
       noteRefusedTranscript(raw.transcript_path);
     }
@@ -5175,6 +5224,7 @@ async function handleClear(res) {
   // The rule, for the next cache that gates an emit: anything answering
   // "has this changed" has to appear in BOTH places that mean the client no
   // longer has it — here, and in forgetSession.
+  outputWatch.clear();
   nameBySession.clear();
   modelBySession.clear();
   // The read stamps go with them. Clearing only the signatures would leave
@@ -5995,6 +6045,10 @@ export async function startServer({ port = 4317, host = "127.0.0.1", persist = n
       await tryListen(server, candidate, host);
       // Codex has no working hooks on Windows — tail its rollout files instead.
       if (codex) startCodexWatcher(workspace);
+      // What a session is producing between its tool calls. Claude only — it
+      // reads `transcript_path`, which Codex hooks never send — and unref'd
+      // like its neighbours.
+      startOutputWatch();
       // Both timers are unref'd, so this never holds the process open.
       startSystemMetrics();
       // LAN sync, from the prefs the import read — and only from here, so a

package/src/server/macmon.mjs

@@ -186,7 +186,15 @@ export function resetMacmonFetch() { _fetched = false; }
  */
 export function macmonAsset(release) {
   const tag = release?.tag_name;
-  const a = (release?.assets ?? []).find(x => typeof x?.name === "string" && x.name.endsWith(".tar.gz"));
+  // Named, not merely suffixed. Every macmon release back to v0.5.1 has
+  // published exactly ONE asset, so `.tar.gz` alone has always picked the right
+  // one — but it picks the FIRST match, and the day a release adds a second
+  // tarball beside the binary (a `source.tar.gz`, or per-arch builds) the wrong
+  // one is chosen silently: it downloads, it hashes against a digest that
+  // matches, and what lands is not an executable. The published name has been
+  // `macmon-v<X.Y.Z>.tar.gz` throughout, so requiring that shape costs nothing
+  // today and refuses to guess on the day it would otherwise guess wrong.
+  const a = (release?.assets ?? []).find(x => typeof x?.name === "string" && /^macmon-v[\d.]+\.tar\.gz$/.test(x.name));
   if (!a?.browser_download_url) return null;
   const m = /^sha256:([0-9a-f]{64})$/.exec(String(a.digest ?? ""));
   if (!m) return null;

package/src/server/output-watch.mjs

@@ -0,0 +1,222 @@
+// What a session is producing between its tool calls.
+//
+// THE HOLE THIS FILLS. The hooks fire at boundaries — a prompt goes in, a tool
+// starts, a tool ends, a turn ends — and nothing at all fires while the model
+// is working. Measured on this machine's transcripts over six hours: 86 minutes
+// in 648 thinking blocks, 16.5% of all measured time and MORE than the time
+// spent inside tool calls, with nothing drawn for any of it. A card that is
+// working looks exactly like a card that has died, and the only way to tell
+// them apart was to wait and see whether anything ever appeared.
+//
+// WHAT THE TRANSCRIPT KNOWS THAT THE HOOKS DO NOT. Claude Code appends one JSON
+// line per content block as that block completes, each with its own timestamp:
+//
+//     assistant  19:04:40.038  thinking
+//     assistant  19:04:41.446  text
+//     assistant  19:04:44.174  tool_use
+//
+// So the file advances DURING a turn, at a measured median of 4.1s between
+// blocks, and the deck already knows where that file is — every Claude hook
+// payload carries `transcript_path` and four scanners already read it. What
+// none of them do is look BETWEEN events, which is the only place this signal
+// lives.
+//
+// WHY THIS IS A STAT AND NOT A READ. The transcripts here run to megabytes and
+// the question being asked each tick is one bit: did it grow. So the poll stats
+// and nothing else, and only a file that moved is opened — and then only from
+// the byte where the last read stopped, never from the beginning. A session
+// that is quiet costs one `stat` per tick and no bytes at all.
+//
+// WHAT IT DELIBERATELY DOES NOT DO. It does not claim to know what the model is
+// doing NOW. A block is written when it FINISHES, so the honest statement is
+// "this session completed a thinking block 2 seconds ago" — and 2.1s is the
+// measured median for what follows one, with 99% landing inside 25.5s. The
+// freshness judgement belongs to the reader, which is why this emits a
+// timestamp and a kind and no verdict.
+import { open, stat } from "node:fs/promises";
+import { StringDecoder } from "node:string_decoder";
+
+/** Read no more than this from one file in one tick.
+ *
+ *  A tail is normally a few kilobytes — one block. This is the ceiling for the
+ *  case that is not normal: a session that was quiet while the deck was not
+ *  watching, or a file replaced under the same name. Past it the watch skips
+ *  to the end rather than reading megabytes to answer a one-bit question; the
+ *  next block to land is then seen normally. */
+const MAX_TAIL_BYTES = 256 * 1024;
+
+/** The block kinds worth telling apart, in the order a tie is broken.
+ *
+ *  One assistant record can carry several blocks — a thinking block and the
+ *  tool call it produced arrive together often enough to matter — and the
+ *  interesting one is the one that says the model was REASONING rather than
+ *  the mechanical result of it. */
+const KIND_ORDER = ["thinking", "tool_use", "text"];
+
+/**
+ * What one transcript line says was produced, or null for a line that says
+ * nothing about production.
+ *
+ * A `user` record carrying a tool_result is the tool answering, not the model
+ * producing, and counting it would make every tool call look like generation.
+ * Anything unparseable is null rather than a throw: this reads a file that is
+ * being appended to, and a torn final line is the ordinary case, not an error.
+ */
+export function blockKindOf(line) {
+  if (!line) return null;
+  let rec;
+  try { rec = JSON.parse(line); } catch { return null; }
+  if (!rec || rec.type !== "assistant") return null;
+  const content = rec.message?.content;
+  if (!Array.isArray(content)) return null;
+  const types = new Set(content.map(b => b?.type));
+  for (const kind of KIND_ORDER) if (types.has(kind)) return kind;
+  return null;
+}
+
+/** When that line says it happened, or null. Its own stamp rather than the
+ *  clock here: the deck may be reading a block that landed while it was busy,
+ *  and dating it `now` would report work as having just happened when it did
+ *  not. */
+export function blockTimeOf(line) {
+  if (!line) return null;
+  let rec;
+  try { rec = JSON.parse(line); } catch { return null; }
+  const t = rec?.timestamp ? Date.parse(rec.timestamp) : NaN;
+  return Number.isFinite(t) ? t : null;
+}
+
+/**
+ * EVERY block in a chunk of whole-ish lines, oldest first.
+ *
+ *  Not the newest one. This took only the last block and lost the interesting
+ *  half of nearly every turn: measured on this machine, consecutive blocks land
+ *  1.4s and 2.7s apart, so a `thinking` and the `tool_use` it produced arrive
+ *  inside one 1500ms tick more often than not — and reporting only the newest
+ *  meant the canvas saw `tool_use` forever and `thinking` never, which is the
+ *  one thing this whole watch exists to show. Confirmed on the live deck: two
+ *  ticks, two events, both `tool_use`, no thinking at all.
+ *
+ *  It also undercounted. Each block is a unit of work the model finished and
+ *  the activity chart marks one per block, so folding three into one drew a
+ *  third of the movement that happened.
+ */
+export function blocksIn(chunk) {
+  const out = [];
+  for (const line of chunk.split("\n")) {
+    const kind = blockKindOf(line);
+    if (kind) out.push({ kind, at: blockTimeOf(line) });
+  }
+  return out;
+}
+
+/**
+ * The watch.
+ *
+ * `io` is injectable so the whole of this can be tested without a filesystem,
+ * and so the suite can drive a file that grows, shrinks, vanishes and comes
+ * back without arranging any of that for real.
+ */
+export function createOutputWatch(io = {}) {
+  const statFile = io.stat ?? (p => stat(p));
+  const openFile = io.open ?? (p => open(p, "r"));
+  /** sid -> { path, offset, size } — where this session's file is and how far
+   *  into it the watch has already looked. */
+  const seen = new Map();
+
+  /** Remember where a session's transcript is. Called for every hook payload
+   *  that carries one, which is every Claude hook: the path is free there and
+   *  there is nowhere else to learn it. A path that changes for a session
+   *  replaces the entry and restarts at that file's end — see `note`. */
+  function note(sid, path) {
+    if (!sid || !path) return;
+    const prev = seen.get(sid);
+    if (prev && prev.path === path) return;
+    // Start at the END of a file the watch has not seen before. Everything
+    // already in it happened before the deck looked, and replaying it would
+    // report a morning's thinking as having just occurred.
+    seen.set(sid, { path, offset: null, size: null });
+  }
+
+  function forget(sid) { seen.delete(sid); }
+
+  /** For the suite, and for the one place the server clears everything. */
+  function clear() { seen.clear(); }
+  function size() { return seen.size; }
+
+  /**
+   * One tick. Stats each named session's file, reads only what is new, and
+   * answers with EVERY block that landed in it, oldest first — see blocksIn
+   * for why the newest alone was the wrong answer.
+   *
+   * Sessions the caller believes are live, and no others: a finished session's
+   * file can still be appended to by a later turn, and the deck has its own
+   * rules about what counts as live. This asks no questions about that.
+   */
+  async function poll(liveSids) {
+    const out = [];
+    for (const sid of liveSids) {
+      const entry = seen.get(sid);
+      if (!entry) continue;
+      let st;
+      try { st = await statFile(entry.path); } catch { continue; }
+      const size = Number(st?.size ?? 0);
+      // First sight: record where the end is and report nothing. The file's
+      // whole history is older than this deck's interest in it.
+      if (entry.offset == null) { entry.offset = size; entry.size = size; continue; }
+      // TRUNCATED OR REPLACED. A file that is now shorter than the byte this
+      // watch was going to read from is not the file it was reading; seeking to
+      // the old offset would return whatever now lives there. Start again at
+      // the new end rather than guessing which bytes are which.
+      if (size < entry.offset) { entry.offset = size; entry.size = size; continue; }
+      if (size === entry.offset) continue;
+      // Past the ceiling, skip to the end. See MAX_TAIL_BYTES.
+      if (size - entry.offset > MAX_TAIL_BYTES) { entry.offset = size; entry.size = size; continue; }
+
+      const from = entry.offset;
+      const want = size - from;
+      let fd;
+      let text = "";
+      try {
+        fd = await openFile(entry.path);
+        const buf = Buffer.allocUnsafe(want);
+        const { bytesRead } = await fd.read(buf, 0, want, from);
+        // A decoder rather than toString, because a tail can begin or end in
+        // the middle of a UTF-8 sequence and a replacement character in the
+        // middle of a JSON string breaks the parse for a whole block.
+        const dec = new StringDecoder("utf8");
+        text = dec.write(buf.subarray(0, Math.max(0, bytesRead))) + dec.end();
+        entry.offset = from + Math.max(0, bytesRead);
+        entry.size = size;
+      } catch {
+        continue;
+      } finally {
+        // Awaited, for the reason codex-usage.mjs gives: a close scheduled and
+        // abandoned leaves a handle open, and on Windows a file with a handle
+        // on it cannot be deleted.
+        await fd?.close().catch(() => {});
+      }
+
+      // A tail that ends mid-line is the ordinary case — the file is being
+      // appended to while this reads it. Rewind the offset to the start of the
+      // torn line so the next tick sees it whole rather than dropping it.
+      const lastNl = text.lastIndexOf("\n");
+      if (lastNl < 0) {
+        // No complete line at all yet. Give the bytes back and wait.
+        entry.offset = from;
+        continue;
+      }
+      if (lastNl < text.length - 1) {
+        entry.offset -= Buffer.byteLength(text.slice(lastNl + 1), "utf8");
+        text = text.slice(0, lastNl);
+      }
+
+      // Oldest first, so a reader that refuses to move backwards accepts the
+      // whole run rather than only its last member.
+      for (const b of blocksIn(text)) out.push({ sid, kind: b.kind, at: b.at });
+    }
+    return out;
+  }
+
+  return { note, forget, clear, size, poll };
+}

package/src/server/uv-bootstrap.mjs

@@ -36,7 +36,12 @@ const DOWNLOAD_BASE = "https://github.com/astral-sh/uv/releases/download";
 // Used when the releases API cannot be reached — rate limiting is per-IP and
 // unauthenticated, so this is a normal outcome rather than an error. Any
 // reasonably recent uv can install claude-swap; it self-updates later.
-const FALLBACK_VERSION = "0.12.3";
+//
+// Dated, because this constant rots silently: nothing fails when it falls
+// behind, it simply installs an older uv on the machines that reach it, so no
+// test and no user will ever report it. Checked against the releases API on the
+// date below; worth re-reading whenever this file is opened for another reason.
+const FALLBACK_VERSION = "0.12.13"; // latest as of 2026-09-13
 
 const DOWNLOAD_TIMEOUT_MS = 120_000;