ccdeck 3.37.0 → 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-wCbqcRJd.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.0",
+  "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,14 @@
     "3.36.7",
     "3.36.8",
     "3.36.9",
-    "3.37.0"
+    "3.37.0",
+    "3.38.0"
+  ],
+  "3.37.1": [
+    {
+      "title": "🔁 Expired logins repair from your other machines",
+      "body": "When a login stops working on this machine and a machine you paired with still has it working and ticked, Local network now copies it back on the next round, whether or not the account is ticked here. Before, it stayed marked expired until the account was ticked here as well, or deleted so that it arrived again. A machine that paired on its own, through Say yes to every deck that asks, still repairs only the accounts ticked here."
+    }
   ],
   "3.36.3": [
     {

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/lan-engine.mjs

@@ -139,10 +139,10 @@ export { anotherMachine };
 /**
  * Whether an account this round just placed is ticked for sharing here (#1188).
  *
- * ONLY AN ADD: a heal needed the tick to happen at all — roundWith asks for a
- * heal only for an account this deck already shares — so there is nothing to
- * add for one, and an account healed after somebody unticked it must not be
- * ticked again behind them.
+ * ONLY AN ADD: a healed slot was already here, so whether it is ticked is
+ * already somebody's decision — ticked, there is nothing to add; unticked,
+ * possibly on purpose, and an account healed after somebody unticked it must
+ * not be ticked again behind them.
  *
  * ONLY FROM THE LOCAL NETWORK: the reasoning for the default is that the login
  * came from the group and the group therefore has it, and a tailnet can reach
@@ -727,23 +727,32 @@ 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);
-      // Only accounts I have also ticked. Sharing is mutual by construction:
-      // a peer cannot push an account at me that I never agreed to hold.
-      // A HEAL NEEDS MY TICK; AN ADD DOES NOT, and the asymmetry is deliberate.
-      // Healing replaces a slot I already have, so it is only reasonable for an
-      // account I said I share. 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 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.
+      //
+      // 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
+      // the same account's working copy, through the same plain import an add
+      // uses — strictly less than an add does. And the tick is the owner's
+      // answer to "offer this account" (LanSetupModal), not to "repair it":
+      // gating the repair on it left a login dead here for as long as nobody
+      // ticked it, while deleting the dead slot turned the same transfer into
+      // an add that went straight through. So people deleted accounts to fix
+      // them. A copy dies on its own, too — claude-swap's refresh rotates the
+      // token, and every other deck holding the old one gets invalid_grant —
+      // 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. A deck
-      // the switch paired is treated as a heal is — what it offers comes in
-      // only for an account ticked here — and a person's own press or invite
-      // takes the mark off its pin (see addTrusted).
+      // 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).
       // 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
@@ -755,12 +764,13 @@ export function createEngine({
       // 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 => cfg.shared.includes(step.key) || (step.action === "add" && chosen());
+      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. A heal unticked mid-round ends only that heal: the adds behind
-      // it need no tick, and the skipped row says why rather than vanishing.
+      // 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;
       /** One login, asked for and opened: a `want` carrying its own proof that
        *  names the account (see transferChallenge), and the `have` opened under

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({