ccdeck 3.37.1 → 3.38.0

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-C_h8mR-c.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-0cUs2Jed.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccdeck",
-  "version": "3.37.1",
+  "version": "3.38.0",
   "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,8 @@
     "3.36.7",
     "3.36.8",
     "3.36.9",
-    "3.37.0"
+    "3.37.0",
+    "3.38.0"
   ],
   "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/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() };
+}

package/src/server/session-enrichment.mjs

@@ -1,7 +1,9 @@
 // What the deck learns about a session that its hooks never say: the model,
-// the token spend, the session's name and recap, and the context it is
-// carrying — each read off the session's transcript (or, for a Codex session's
-// memory files, off its working tree) and sent on as a synthetic event.
+// the token spend, the session's name and recap, what it is doing now, and the
+// context it is carrying — each read off the session's transcript (or, for a
+// Codex session's memory files, off its working tree) and sent on as a
+// synthetic event. And, for a background session, the line Claude Code's own
+// agent view shows, read off its job folder (see claude-jobs.mjs).
 //
 // This lived in src/server/index.mjs, between the log rotation and the Codex
 // rollout reader. pushEvent asks it to look at every live hook event, and it
@@ -18,6 +20,9 @@ import { join } from "node:path";
 import { scanAgentsMdFiles, scanClaudeMdFiles } from "./memory-files.mjs";
 // Claude Code's "※ recap:" line — see session-recap.mjs.
 import { RECAP_MARK } from "./session-recap.mjs";
+// What the session is doing now, folded off the same tail — see
+// session-activity.mjs.
+import { foldActivityLine, newActivityState } from "./session-activity.mjs";
 // The shared transcript cursor every pass below reads through — see
 // transcript-scan.mjs.
 import { copyUsageBucket, hasSpend, mergeUsageByModel, newUsageTotals, scanTranscript } from "./transcript-scan.mjs";
@@ -495,6 +500,60 @@ function onRecapTail(sid, text, path) {
     .catch(() => {});
 }
 
+// ─── Session activity ────────────────────────────────────────────────────
+// What the session is doing now — the line Claude Code's agent view prints
+// beside a working session, by the same rule and with no model call (see
+// session-activity.mjs). Folded off the output watch's tail rather than the
+// transcript cursor: the watch is what reads a file BETWEEN hook events, and
+// between hook events is the whole of when this line changes. The cursor runs
+// off hooks and would hold a sentence the model wrote until the next tool call.
+//
+// The fold is per session and survives across ticks, because one reply's blocks
+// can land on either side of a tick and the sentence has to outrank the call it
+// introduced whichever tick read it. The emit is gated on the text changing, so
+// a reply that is still thinking says nothing.
+const activityBySession = new Map();    // sid -> the fold, see newActivityState
+
+function onActivityTail(sid, text) {
+  if (!sid || !text) return;
+  let st = activityBySession.get(sid);
+  if (!st) { st = newActivityState(); activityBySession.set(sid, st); }
+  const before = st.shown;
+  for (const line of text.split("\n")) foldActivityLine(st, line);
+  if (!st.shown || st.shown === before) return;
+  pushEvent({
+    hook_event_name: "ActivityObserved",
+    session_id: sid,
+    activity: { text: st.shown.text, source: st.shown.source, at: st.shown.at },
+  }, "internal");
+}
+
+/** Everything the output watch's tail feeds, in one tap: the recap and the
+ *  activity line read the same bytes for different questions. */
+function onTranscriptTail(sid, text, path) {
+  onRecapTail(sid, text, path);
+  onActivityTail(sid, text);
+}
+
+// ─── Background job ──────────────────────────────────────────────────────
+// Claude Code's own line for a background session — its state, what it is
+// doing or asking, and what it got done — read from the job folder its agent
+// view reads (see claude-jobs.mjs). Gated on a CHANGE like the recap, and on
+// the words rather than the file's clock: the classifier rewrites `updatedAt`
+// every fifteen seconds of a working turn, mostly to say the same thing. A
+// session with no job emits nothing at all, and a job that goes away (deleted
+// in the agent view) is said once, as null.
+const jobBySession = new Map();         // sid -> signature last sent, "" once gone
+
+function noteJob(sid, job) {
+  const sig = job ? JSON.stringify([job.state, job.detail, job.needs, job.suggestedReply, job.result]) : "";
+  const prev = jobBySession.get(sid);
+  if (prev === sig) return;
+  if (prev === undefined && !job) return;
+  jobBySession.set(sid, sig);
+  pushEvent({ hook_event_name: "JobObserved", session_id: sid, job: job ?? null }, "internal");
+}
+
 // ─── Context enrichment ──────────────────────────────────────────────────
 // Approximation of `/context` since CC doesn't expose its breakdown via
 // hooks. We scan the transcript JSONL for message counts (user / assistant
@@ -626,6 +685,10 @@ function forgetEnrichment(sid) {
   nameBySession.delete(sid);
   // The recap's gate, for the same reason — see noteRecap.
   recapBySession.delete(sid);
+  // And the activity fold and the job's gate: a session heard from again
+  // after this says what it is doing and what its job says afresh.
+  activityBySession.delete(sid);
+  jobBySession.delete(sid);
   nameReads.forget(sid);
   modelReads.forget(sid);
   usageReads.forget(sid);
@@ -641,6 +704,8 @@ function forgetEnrichment(sid) {
 function clearEnrichmentGates() {
   nameBySession.clear();
   recapBySession.clear();
+  activityBySession.clear();
+  jobBySession.clear();
   modelBySession.clear();
   // The read stamps go with them. Clearing only the signatures would leave
   // the next hook event inside MODEL_READ_THROTTLE_MS, so the transcript
@@ -658,5 +723,5 @@ function clearEnrichmentGates() {
 export {
   clearEnrichmentGates, forgetEnrichment, knownModelId, maybeResolveCodexMemory,
   maybeResolveContext, maybeResolveModel, maybeResolveSessionName, maybeResolveUsage,
-  onRecapTail,
+  noteJob, onRecapTail, onTranscriptTail,
 };

package/src/server/session-tracking.mjs

@@ -13,7 +13,10 @@ import { readBody, send } from "./http-io.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 { forgetEnrichment, onRecapTail } from "./session-enrichment.mjs";
+// Claude Code's own line for a background session, from its job folder. See
+// claude-jobs.mjs.
+import { createJobWatch } from "./claude-jobs.mjs";
+import { forgetEnrichment, noteJob, onTranscriptTail } from "./session-enrichment.mjs";
 import { forgetCodexSession } from "./codex-enrichment.mjs";
 // event-pipeline.mjs's pushEvent, reached without importing it — see
 // event-sink.mjs.
@@ -96,6 +99,14 @@ const RECAP_WATCH_WINDOW_MS = 12 * 60 * 60_000;
 const RECAP_WATCH_EVERY = 4;
 let outputWatchTicks = 0;
 
+/** The job folders, every other tick: three seconds, well inside the fifteen
+ *  Claude Code itself waits between rewrites of a working job's line. The
+ *  sessions asked about are the resting window's, not the live one's — a
+ *  background job blocked on a question fires no hook for as long as nobody
+ *  answers it, and that is the job whose line matters most. */
+const jobWatch = createJobWatch();
+const JOB_WATCH_EVERY = 2;
+
 /** 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`.
@@ -112,15 +123,23 @@ async function outputWatchOnce() {
   const now = Date.now();
   const cutoff = now - OUTPUT_WATCH_WINDOW_MS;
   const restingCutoff = now - RECAP_WATCH_WINDOW_MS;
-  const withResting = outputWatchTicks++ % RECAP_WATCH_EVERY === 0;
+  const tick = outputWatchTicks++;
+  const withResting = tick % RECAP_WATCH_EVERY === 0;
   const live = new Set();
   const polled = [];
+  const recent = [];
   for (const [sid, at] of sessionTouchedAt) {
     if (at >= cutoff) { live.add(sid); polled.push(sid); }
     else if (withResting && at >= restingCutoff) polled.push(sid);
+    if (at >= restingCutoff) recent.push(sid);
+  }
+  if (recent.length && tick % JOB_WATCH_EVERY === 0) {
+    const jobs = await jobWatch.poll().catch(() => null);
+    if (jobs) for (const sid of recent) noteJob(sid, jobs.get(sid) ?? null);
   }
   if (!polled.length) return;
-  const found = await outputWatch.poll(polled, onRecapTail);
+  // The recap and the activity line, off the same tail — see onTranscriptTail.
+  const found = await outputWatch.poll(polled, onTranscriptTail);
   for (const f of found) {
     if (!live.has(f.sid)) continue;
     pushEvent({