ccdeck 3.37.1 → 3.38.1

package/dist/web/index.html

@@ -64,8 +64,8 @@
           stored === "light" || (stored !== "dark" && light) ? "light" : "dark");
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-DDxnWaTa.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-B0SOa-XB.css">
+    <script type="module" crossorigin src="/assets/index-DnnkOgia.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-D-HX6Mea.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccdeck",
-  "version": "3.37.1",
+  "version": "3.38.1",
   "description": "Local dashboard for Claude Code and Codex CLI sessions: which Claude Code session needs input, every tool call and Claude Code subagent live, token cost and quota, several Claude accounts. Run npx ccdeck.",
   "type": "module",
   "bin": {

package/release-notes.json

@@ -69,7 +69,9 @@
     "3.36.7",
     "3.36.8",
     "3.36.9",
-    "3.37.0"
+    "3.37.0",
+    "3.38.0",
+    "3.38.1"
   ],
   "3.37.1": [
     {

package/src/server/claude-jobs.mjs

@@ -0,0 +1,152 @@
+// Claude Code's own account of a background session, read from the file its
+// agent view draws from.
+//
+// WHAT IT IS. A session started with `claude --bg`, or dispatched from
+// `claude agents`, is a background job, and Claude Code keeps one folder per job
+// at `<config dir>/jobs/<short id>/`. Its `state.json` is what the agent view
+// prints: `state` (working, blocked, done, failed, stopped), a one-line `detail`,
+// the question it is stuck on (`needs`), the reply Claude Code would suggest
+// (`suggestedReply`) and the headline of a finished job (`output.result`).
+//
+// Those lines are written by Claude Code's classifier: a pattern match on the
+// session's last words ("result:", "needs input:", "failed:"), and a small model
+// when the pattern finds nothing — at every turn end, and inside a long turn
+// once a minute or so. Read off the 2.1.289 bundle and this machine's job
+// folders on 2026-10-05.
+//
+// WHY THE DECK READS IT. That classifier has already been paid for, by Claude
+// Code, and it answers the question the deck's waiting queue cannot: not that a
+// session stopped, but what it is asking and what it got done. For a background
+// session the deck would otherwise show nothing at all between hooks.
+//
+// WHY EVERY FIELD IS CHECKED. Claude Code's documentation says in as many words
+// that these files "are not a stable interface" (code.claude.com/docs/en/
+// agent-view), and `claude agents --json`, the supported reader, carries the
+// state but none of the words. So the shape is treated as untrusted: an unknown
+// state is no job, a field of the wrong type is absent, a file that stops
+// parsing is a session with no line. Nothing here may throw, and nothing here
+// can make the deck worse than it was before it read the file.
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { claudeConfigDir } from "./claude-dir.mjs";
+
+/** The states the agent view groups by. `stopped` is a job somebody ended,
+ *  or one the supervisor found dead; it says nothing worth a line. */
+const JOB_STATES = new Set(["working", "blocked", "done", "failed", "stopped"]);
+
+/** Claude Code caps its own `detail` at 800 characters. A line on a card is
+ *  far shorter than that, but cutting is the renderer's job; this only bounds
+ *  what a malformed file could put on the wire. */
+const JOB_TEXT_MAX_CHARS = 800;
+const REPLY_MAX_CHARS = 200;
+
+/** How many job folders one pass will look at. The folders are removed when a
+ *  job is deleted, so this is tens on a working machine; the bound is for the
+ *  one that never deletes anything. */
+const MAX_JOB_DIRS = 500;
+
+function text(raw, max) {
+  if (typeof raw !== "string") return "";
+  const t = raw.replace(/\s+/g, " ").trim();
+  return t.length > max ? t.slice(0, max - 1).trimEnd() + "…" : t;
+}
+
+/**
+ * One `state.json`, as the deck can use it, or null.
+ *
+ * `updatedAt` is the file's own clock: the client compares it against the
+ * session's recap to show whichever is newer, and the deck may be reading a
+ * file written while it was down. A job with no session id cannot be matched to
+ * anything the deck draws, so it is not a job here.
+ */
+export function jobStatusOf(raw, jobId) {
+  if (!raw || typeof raw !== "object") return null;
+  const state = raw.state;
+  if (!JOB_STATES.has(state)) return null;
+  const sessionId = typeof raw.sessionId === "string" && raw.sessionId ? raw.sessionId : null;
+  if (!sessionId) return null;
+  const updatedAt = typeof raw.updatedAt === "string" ? Date.parse(raw.updatedAt) : NaN;
+  const out = {
+    id: typeof jobId === "string" ? jobId : "",
+    state,
+    detail: text(raw.detail, JOB_TEXT_MAX_CHARS),
+    updatedAt: Number.isFinite(updatedAt) ? updatedAt : 0,
+  };
+  const needs = text(raw.needs, JOB_TEXT_MAX_CHARS);
+  if (needs && state === "blocked") out.needs = needs;
+  const reply = text(raw.suggestedReply, REPLY_MAX_CHARS);
+  if (reply && state === "blocked") out.suggestedReply = reply;
+  const result = text(raw.output?.result, JOB_TEXT_MAX_CHARS);
+  if (result) out.result = result;
+  return { sessionId, resumeSessionId: typeof raw.resumeSessionId === "string" ? raw.resumeSessionId : null, job: out };
+}
+
+/**
+ * The watch over `<config dir>/jobs`.
+ *
+ * Shaped like the output watch: `io` is injectable so the suite can drive a
+ * folder that grows, changes and loses files without arranging any of it for
+ * real. A file is re-read only when its size or mtime moved, so a quiet machine
+ * costs one `readdir` and one `stat` per job per pass.
+ */
+export function createJobWatch(io = {}) {
+  const jobsDir = io.dir ?? (() => join(claudeConfigDir(), "jobs"));
+  const listDir = io.readdir ?? (p => readdir(p, { withFileTypes: true }));
+  const statFile = io.stat ?? (p => stat(p));
+  const readText = io.readFile ?? (p => readFile(p, "utf8"));
+  /** jobId -> { size, mtimeMs, parsed } — the last read of each file. */
+  const files = new Map();
+  let polling = false;
+
+  /**
+   * One pass. Answers `Map<sessionId, job>` for every job folder that holds a
+   * readable state, or null when a pass is already running — an overlapping
+   * caller has nothing new to say, and answering with the same map would only
+   * re-run the caller's change gate for nothing.
+   *
+   * Two folders naming one session is a job that was resumed or re-dispatched;
+   * the one written most recently is the one the agent view is showing.
+   */
+  async function poll() {
+    if (polling) return null;
+    polling = true;
+    try {
+      const out = new Map();
+      let entries;
+      try { entries = await listDir(jobsDir()); } catch { files.clear(); return out; }
+      const seen = new Set();
+      for (const e of entries.slice(0, MAX_JOB_DIRS)) {
+        if (!e?.isDirectory?.()) continue;
+        const id = e.name;
+        seen.add(id);
+        const path = join(jobsDir(), id, "state.json");
+        let st;
+        try { st = await statFile(path); } catch { files.delete(id); continue; }
+        const size = Number(st?.size ?? 0);
+        const mtimeMs = Number(st?.mtimeMs ?? 0);
+        let entry = files.get(id);
+        if (!entry || entry.size !== size || entry.mtimeMs !== mtimeMs) {
+          let parsed = null;
+          // A file caught mid-write fails the parse; the next pass reads it whole.
+          try { parsed = jobStatusOf(JSON.parse(await readText(path)), id); } catch { parsed = null; }
+          entry = { size, mtimeMs, parsed };
+          files.set(id, entry);
+        }
+        const p = entry.parsed;
+        if (!p) continue;
+        for (const sid of new Set([p.sessionId, p.resumeSessionId].filter(Boolean))) {
+          const prev = out.get(sid);
+          if (!prev || p.job.updatedAt >= prev.updatedAt) out.set(sid, p.job);
+        }
+      }
+      for (const id of files.keys()) if (!seen.has(id)) files.delete(id);
+      return out;
+    } finally {
+      polling = false;
+    }
+  }
+
+  function clear() { files.clear(); }
+
+  return { poll, clear };
+}

package/src/server/deck-prefs.mjs

@@ -133,8 +133,11 @@ export const DEFAULTS = Object.freeze({
     // WHAT MAKES IT SURVIVABLE IS THE GATE THAT NEVER CHANGED: `shared` is
     // empty, so a deck that pairs is offered NOTHING until somebody ticks a
     // login here. Pairing is a name in a list; a login is the thing worth
-    // having, and it still takes a deliberate tick on this machine. A deck on a
-    // network it does not own turns this off in the dialog, in one press.
+    // having, and it still takes a deliberate tick on this machine. The other
+    // direction is not gated by a tick here, since 3.38.1: a deck the switch
+    // pairs adds and repairs the logins a person ticked on it, as any paired
+    // deck does (see roundWith), and never replaces one that works. So a deck
+    // on a network it does not own turns this off in the dialog, in one press.
     autoAsk: true,
     autoAccept: true,
     pairingMode: "automatic",

package/src/server/lan-engine.mjs

@@ -397,7 +397,8 @@ export function createEngine({
    * is new.
    *
    * Or one the accept switch chose for them, which `auto` says and the pin
-   * keeps — see addTrusted, and roundWith for what such a deck may not do.
+   * keeps — see addTrusted, and sharedWith in lan-sync.mjs for what such a
+   * deck is not handed.
    */
   const pin = ({ fp, pub, name }, { auto = false } = {}) => {
     const { list, added } = addTrusted(cfg.trusted, { fp, pub, name, at: now(), ...(auto ? { auto: true } : {}) });
@@ -727,11 +728,11 @@ export function createEngine({
       if (!stillPaired()) throw new Error("peer no longer paired");
       if (theirs?.t !== "manifest" || !Array.isArray(theirs.accounts)) throw new Error("no manifest");
       const list = keepManifest(conn.key, theirs, conn.peerFp);
-      // FROM A DECK SOMEBODY HERE CHOSE, NEITHER AN ADD NOR A HEAL NEEDS MY
-      // TICK. Adding is the case the owner asked for by name: an account that
-      // appears among the decks I paired with appears on all of them, which is
-      // the whole of "I do not want to paste blobs any more". What can reach
-      // this is what a deck somebody here pressed accept on chose to offer.
+      // FROM ANY PAIRED DECK, NEITHER AN ADD NOR A HEAL NEEDS MY TICK. Adding
+      // is the case the owner asked for by name: an account that appears among
+      // the decks I paired with appears on all of them, which is the whole of
+      // "I do not want to paste blobs any more". What can reach this is what a
+      // paired deck chose to offer.
       //
       // A heal used to need the tick, on the reasoning that it replaces a slot
       // I already have. It replaces only one claude-swap has quarantined, with
@@ -746,13 +747,28 @@ export function createEngine({
       // so this is the ordinary case between one person's machines, not an
       // edge.
       //
-      // WHICH IS ONLY TRUE OF A DECK SOMEBODY CHOSE. The accept switch presses
-      // accept for the owner, so "somebody here pressed accept" is not a
-      // premise about a deck it paired: nobody here chose that deck, and the
-      // logins this store holds would be whatever it decided to offer. What a
-      // deck the switch paired offers comes in — added or healed — only for an
-      // account ticked here, and a person's own press or invite takes the mark
-      // off its pin (see addTrusted).
+      // A DECK THE SWITCH PAIRED INCLUDED, which is what 3.33.0 got wrong. It
+      // held such a deck to the tick — what it offered came in only for an
+      // account ticked here — on the reasoning that nobody here chose it. On
+      // the shipped defaults that was a deadlock rather than a gate. The
+      // accept switch ships on, so two of one person's machines pair by it;
+      // the setup dialog lists only this deck's own accounts, so a login this
+      // deck lacks cannot be ticked here; so an add from such a deck could
+      // never pass. A Mac ticked eight working logins, the deck it had paired
+      // with by the switch received none of them, ever, and its round line
+      // read "all logins fine". The owner chose fully automatic (2026-10-06):
+      // whoever made the pairing, a round takes everything plan() returns.
+      //
+      // What stands between a deck nobody here chose and this store does not
+      // rest on the tick, and none of it moved. plan() never replaces a login
+      // that works here (syncAction never asks for a forced import). A giving
+      // deck hands a deck its switch paired only what a PERSON ticked on it,
+      // not what an arrival ticked onward (sharedWith in lan-sync.mjs). And
+      // nothing that arrives from one is ticked onward here (ticksOnArrival).
+      // What it costs is the switch's own: on a network the owner does not
+      // control, a deck the switch pairs can add the logins ticked on it — so
+      // the dialog and the README say to turn the switch off there.
+      //
       // OVER `list`, NOT THE RAW ARRAY. `offered`, which keepManifest runs the
       // list through above (see lan-manifest.mjs), slices to 50 and type-
       // filters `key` and `email`; this line read `theirs.accounts` and got
@@ -763,15 +779,7 @@ export function createEngine({
       // the store lock, while the panel drew 50 and every other paired deck
       // waited behind it. `step.key` also reached transferChallenge and
       // importAccount untyped, which `offered`'s filter would have caught.
-      const chosen = () => trustedPeer(cfg.trusted, conn.peerFp)?.auto !== true;
-      const takes = step => chosen() || cfg.shared.includes(step.key);
-      const wanted = plan(mine, list).filter(takes);
-      // TWO CHECKS, BECAUSE THEY END DIFFERENT THINGS. Losing the session —
-      // LAN switched off, the peer unpaired (`stillPaired`, above) — ends the
-      // round. From a deck the switch paired, an account unticked mid-round
-      // ends only that step: the next one may still be ticked, and the skipped
-      // row says why rather than vanishing.
-      const stillWanted = takes;
+      const wanted = plan(mine, list);
       /** One login, asked for and opened: a `want` carrying its own proof that
        *  names the account (see transferChallenge), and the `have` opened under
        *  the additional data it was sealed with. The login, or why there is
@@ -790,15 +798,16 @@ export function createEngine({
         return blob ? { blob } : { why: "could not open" };
       };
       let cut = false;
+      // Losing the session — LAN switched off, the peer unpaired — ends the
+      // round, checked before each question and again before each import. A
+      // tick changed here mid-round ends nothing: no step reads one.
       for (const step of wanted) {
         if (!stillPaired()) { cut = true; break; }
-        if (!stillWanted(step)) { done.push({ ...step, ok: false, why: "not shared" }); continue; }
         const { blob, why } = await wantLogin(step);
         if (!blob) { done.push({ ...step, ok: false, why }); continue; }
-        // Unpairing, disabling LAN, or unticking a heal while export was in
-        // progress takes effect before the received credential touches disk.
+        // Unpairing or disabling LAN while export was in progress takes effect
+        // before the received credential touches disk.
         if (!stillPaired()) { cut = true; break; }
-        if (!stillWanted(step)) { done.push({ ...step, ok: false, why: "not shared" }); continue; }
         // A verdict rather than a boolean, because "refused" and "kept the
         // slot it already has" are different things to tell somebody and the
         // second one used to be reported as success. A bare `true` is still
@@ -825,11 +834,11 @@ export function createEngine({
         // be asleep or on another network. Nothing new is exposed — the login
         // came FROM the group, so the group has it.
         //
-        // ONLY AN ADD, and only from the local network. A heal already needed
-        // the tick to happen at all (the filter above), so there is nothing to
-        // add for one; and a tailnet reaches further than the person's own
-        // machines, which is a decision they make for themselves rather than
-        // one an arrival makes for them.
+        // ONLY AN ADD, only from the local network, and only from a deck
+        // somebody here chose — see ticksOnArrival for why each. A healed slot
+        // was here already and its tick is somebody's decision either way; a
+        // tailnet reaches further than the person's own machines; and what a
+        // deck the switch paired brings is not passed on in this deck's name.
         // The store can finish an import after the owner disabled LAN or
         // revoked this peer. Keep the imported slot, but do not turn it into
         // a newly shared credential on behalf of an obsolete transfer.
@@ -1026,9 +1035,6 @@ export function createEngine({
     const card = id => ({
       ...heardOf(id),
       pairedAt: trustedPeer(cfg.trusted, id)?.at ?? null,
-      // And whether a switch said that yes rather than a person, which is
-      // what the dialog needs to say which logins will not arrive from it.
-      ...(trustedPeer(cfg.trusted, id)?.auto ? { autoPaired: true } : {}),
     });
     for (const p of [...beacon.peers.values(), ...dials.rows()]) {
       if (!stillListed(p, now())) continue;

package/src/server/lan-reach.mjs

@@ -536,6 +536,27 @@ export function reachability({ platform, probe, aliases = [], exePath = "", inbo
   return windowsReach({ probe, aliases, exePath, inbound });
 }
 
+/**
+ * The verdict as the status route serves it: `said` is the last one taken, and
+ * `inboundAt` is when a connection from another machine last got in, as the
+ * engine knows it NOW.
+ *
+ * A VERDICT IS TAKEN AT MOST EVERY FIVE MINUTES (see refreshReach in
+ * lan-deck.mjs), and a complaint in it was true only of the moment it was
+ * taken. Reported from the Omarchy box this module's Linux block describes:
+ * its owner ran the two `ufw allow` lines, decks connected straight away —
+ * ufw applies a rule the moment it is added — and the panel went on saying
+ * "ufw is running here…" until the cached verdict expired, because it was
+ * taken before anything had connected. The connection that got in is the
+ * same measurement every platform here already puts above whatever it read,
+ * so it outranks a verdict taken before it, too. The answer is the one the
+ * next probe will give; every other answer is served as it was.
+ */
+export function servedReach(said, inboundAt) {
+  if (!said?.blocked || !inboundAt) return said ?? null;
+  return { blocked: false, why: "inbound seen", category: said.category ?? "", alias: said.alias ?? "" };
+}
+
 // ── the machine nothing can be asked about ──────────────────────────────────
 //
 // Every block above depends on the operating system answering a question.

package/src/server/lan-routes.mjs

@@ -10,6 +10,7 @@
 import { cleanAlias, isAliasKey, lanEnabled, withAlias, withManualEntry } from "./deck-prefs.mjs";
 import { heldPrefs } from "./prefs-state.mjs";
 import { lanEngine, lastReach, refreshReach, tailnet } from "./lan-deck.mjs";
+import { servedReach } from "./lan-reach.mjs";
 import { IDLE_MS as TAILNET_IDLE_MS } from "./tailscale.mjs";
 import { readBody, send } from "./http-io.mjs";
 
@@ -21,7 +22,9 @@ export function handleLanStatus(req, res) {
   // Behind the answer, like the reach probe: the dialog's poll is what finds a
   // Tailscale somebody installed while the deck was running.
   if (lanEnabled(heldPrefs.current())) void tailnet.freshen(TAILNET_IDLE_MS);
-  return send(res, 200, { ok: true, ...lanEngine.status(), reach: lastReach() });
+  // Read against what has got in since it was taken — see servedReach.
+  const status = lanEngine.status();
+  return send(res, 200, { ok: true, ...status, reach: servedReach(lastReach(), status.inboundAt) });
 }
 
 /**

package/src/server/lan-sync.mjs

@@ -464,11 +464,12 @@ export function trustedPeer(trusted, fp) {
  * told nothing changed.
  *
  * `auto` SAYS A SWITCH MADE THE PIN, not a person — the accept switch pressing
- * accept for the owner. A pin that says so may take what this deck shares and
- * may not place logins here: see roundWith in lan-engine.mjs. A person's pin
- * of the same key takes the mark away, because pressing accept, or pairing by
- * invite, is the choice the switch only stood in for; a switch never puts it
- * back on a pin a person made.
+ * accept for the owner. A pin that says so is handed only what a person ticked
+ * here (see sharedWith), and what it brings is not ticked onward here (see
+ * ticksOnArrival in lan-engine.mjs); it places logins here like any paired
+ * deck, since 3.38.1 — see roundWith. A person's pin of the same key takes the
+ * mark away, because pressing accept, or pairing by invite, is the choice the
+ * switch only stood in for; a switch never puts it back on a pin a person made.
  */
 export function addTrusted(trusted, entry) {
   const list = Array.isArray(trusted) ? trusted : [];

package/src/server/ring-bounds.mjs

@@ -73,8 +73,16 @@ export const MAX_BUFFER = 2000;     // recent HOOK events kept for late SSE subs
  * `OutputObserved` is deliberately NOT here. It says something landed at a
  * given moment, which is history — two of them are two events, not one value
  * twice.
+ *
+ * `ActivityObserved` and `JobObserved` are: each says what the session is doing
+ * or what its background job says NOW, and the next one replaces it outright.
+ * The activity line moves about once per reply the model writes, which is the
+ * same cadence as the tool calls the budget is there to protect.
  */
-const LAST_VALUE_WINS = new Set(["ModelObserved", "UsageObserved", "ContextObserved", "SessionNamed"]);
+const LAST_VALUE_WINS = new Set([
+  "ModelObserved", "UsageObserved", "ContextObserved", "SessionNamed",
+  "ActivityObserved", "JobObserved",
+]);
 
 /**
  * Whether this payload is enrichment MAX_BUFFER does not count — see

package/src/server/session-activity.mjs

@@ -0,0 +1,176 @@
+// What a session is doing right now, in one line, read off its transcript.
+//
+// WHERE THE RULE COMES FROM. Claude Code's agent view (`claude agents`) prints
+// one line beside every background session saying what it is doing, and while
+// a turn is running that line is not a summary at all. It is the newest
+// assistant message, read for the first thing a person can read: a text block
+// of more than eight characters, and failing that the `description` the model
+// wrote on its tool call — "Run the API tests" — and failing that what the call
+// is touching. Read off the 2.1.289 bundle on 2026-10-05; the model-written
+// summary that replaces it a minute into a long turn is the half that costs a
+// request, and the deck takes that half from the job's own file when there is
+// one (see claude-jobs.mjs). This half costs nothing, needs only the transcript
+// the output watch is already reading, and is as true of an interactive
+// session as of a background one.
+//
+// WHY THE MESSAGE AND NOT THE LINE. Claude Code writes one transcript line per
+// content block, and the blocks of one reply share `message.id`: "Now I'll read
+// the reducer" lands a moment before the Read it introduces. Folded by message,
+// the sentence outranks the call it explains, as it does in the agent view;
+// folded by line, the call would replace the sentence a second after it
+// appeared, and the line would read like a tool log.
+//
+// WHEN A MESSAGE SAYS NOTHING. A reply holding only thinking, or a call this
+// cannot name, leaves the line where it was. Thinking is the model working on
+// what the line already says, and a blank line would claim it had stopped.
+//
+// What it does NOT decide is whether the line is still true. A line describes
+// the turn that wrote it, and the next prompt makes it history; the client
+// holds that rule (session-status.ts), because a prompt reaches the deck
+// through its hook before the model has written a word.
+
+/** The cheap test every line gets before anything is parsed. */
+const ASSISTANT_MARK = '"type":"assistant"';
+
+/** Claude Code's own floor for a text block worth showing: "ok", "Done." and
+ *  "Let me" say nothing about what is happening, and its line skips them. */
+const MIN_SAID_CHARS = 8;
+
+/** A row is one line of a 300px sidebar, three at most. Past this the text is
+ *  cut at a word and marked, so a model that opens with a paragraph does not
+ *  push the row's own figures off the panel. */
+const ACTIVITY_MAX_CHARS = 160;
+
+/**
+ * The first line of what the model wrote, as plain words.
+ *
+ * Markdown is the model's formatting for a terminal and reads as noise in a
+ * one-line row: `**bold**`, backticks, a heading's hashes, a bullet's dash. Only
+ * the first non-empty line is taken — the rest of a long reply is the answer,
+ * not the activity.
+ */
+export function cleanSaid(raw) {
+  if (typeof raw !== "string") return "";
+  const first = raw.split("\n").map(l => l.trim()).find(Boolean) ?? "";
+  let text = first
+    .replace(/^#{1,6}\s+/, "")
+    .replace(/^(?:[-*+]|\d+[.)])\s+/, "")
+    .replace(/\*\*|__|`/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (text.length > ACTIVITY_MAX_CHARS) {
+    const cut = text.slice(0, ACTIVITY_MAX_CHARS - 1);
+    const space = cut.lastIndexOf(" ");
+    text = (space > ACTIVITY_MAX_CHARS * 0.6 ? cut.slice(0, space) : cut).trimEnd() + "…";
+  }
+  return text;
+}
+
+/** The last path segment, for a call whose subject is a file. */
+function baseName(path) {
+  if (typeof path !== "string" || !path) return "";
+  const parts = path.split(/[\\/]/).filter(Boolean);
+  return parts[parts.length - 1] ?? "";
+}
+
+/** A host, for a fetch: the whole address is a query string as often as not. */
+function hostOf(url) {
+  if (typeof url !== "string") return "";
+  try { return new URL(url).host; } catch { return ""; }
+}
+
+/**
+ * What one tool call is doing, in words, or "" when it says nothing a person
+ * could read.
+ *
+ * The model's own `description` first: it is a sentence written for exactly
+ * this reader, and Bash, Task and Agent carry one on nearly every call. The
+ * rest are the calls that carry none but name their subject plainly — a file,
+ * a pattern, a host. Anything else is left unnamed rather than printed as a
+ * tool id: "Using mcp__github__list_pulls" is a log line, not an activity.
+ */
+export function toolActivity(name, input) {
+  const desc = typeof input?.description === "string" ? input.description : "";
+  if (desc.trim()) return cleanSaid(desc);
+  const say = (verb, subject) => (subject ? cleanSaid(`${verb} ${subject}`) : "");
+  switch (name) {
+    case "Read": return say("Reading", baseName(input?.file_path));
+    case "Edit":
+    case "MultiEdit": return say("Editing", baseName(input?.file_path));
+    case "Write": return say("Writing", baseName(input?.file_path));
+    case "NotebookEdit": return say("Editing", baseName(input?.notebook_path));
+    case "Grep": return say("Searching for", typeof input?.pattern === "string" ? input.pattern : "");
+    case "Glob": return say("Finding", typeof input?.pattern === "string" ? input.pattern : "");
+    case "WebFetch": return say("Fetching", hostOf(input?.url));
+    case "WebSearch": return say("Searching the web for", typeof input?.query === "string" ? input.query : "");
+    default: return "";
+  }
+}
+
+/**
+ * What one transcript line adds to the line, or null for a line that is not
+ * the main chain's model writing.
+ *
+ * `said` is the newest readable text block on the line, `did` the newest
+ * nameable call; either may be "" when the line carries neither. A subagent's
+ * sidechain is not the session's own reply — current Claude Code writes those
+ * to their own files anyway, and the parent's Task call already says what the
+ * subagent was sent to do.
+ */
+export function activityOfLine(line) {
+  if (!line || !line.includes(ASSISTANT_MARK)) return null;
+  let rec;
+  try { rec = JSON.parse(line); } catch { return null; }
+  if (!rec || rec.type !== "assistant" || rec.isSidechain === true) return null;
+  const content = rec.message?.content;
+  if (!Array.isArray(content)) return null;
+  let said = "";
+  let did = "";
+  for (const block of content) {
+    if (block?.type === "text" && typeof block.text === "string") {
+      const text = cleanSaid(block.text);
+      if (text.length > MIN_SAID_CHARS) said = text;
+    } else if (block?.type === "tool_use") {
+      const text = toolActivity(block.name, block.input);
+      if (text) did = text;
+    }
+  }
+  const at = typeof rec.timestamp === "string" ? Date.parse(rec.timestamp) : NaN;
+  return {
+    messageId: typeof rec.message?.id === "string" ? rec.message.id : null,
+    said,
+    did,
+    at: Number.isFinite(at) ? at : null,
+  };
+}
+
+/** A session's fold, before it has read anything. */
+export function newActivityState() {
+  return { messageId: null, said: "", did: "", shown: null };
+}
+
+/**
+ * Fold one transcript line into `st.shown` — `{ text, source, at }`, or null
+ * until something readable has been written.
+ *
+ * Pure apart from `st`, and shaped like foldRecapLine beside it so the output
+ * watch's tap can run both over the same tail. A new `message.id` starts a new
+ * reply; within one reply what was said outranks what was done, whichever line
+ * came last. A line with no message id is its own reply, which is what an
+ * older transcript or a hand-written fixture looks like.
+ */
+export function foldActivityLine(st, line) {
+  const a = activityOfLine(line);
+  if (!a) return;
+  if (!a.messageId || a.messageId !== st.messageId) {
+    st.messageId = a.messageId;
+    st.said = "";
+    st.did = "";
+  }
+  if (a.said) st.said = a.said;
+  if (a.did) st.did = a.did;
+  const text = st.said || st.did;
+  if (!text) return;
+  if (st.shown && st.shown.text === text) return;
+  st.shown = { text, source: st.said ? "said" : "tool", at: a.at ?? Date.now() };
+}