claude-code-kanban 6.1.0 → 6.1.2

package/cli.js

@@ -747,6 +747,7 @@ async function runSessionViewCli(args) {
     return 1;
   }
   const asJson = args.includes('--json');
+  const rateLimits = asJson ? null : cliGetJson('/api/rate-limits', 'Rate limits').catch(() => ({}));
   const resolved = await resolveSessionByIdOrPrefix(idArg);
   if (!resolved) return 1;
   let list;
@@ -775,7 +776,6 @@ async function runSessionViewCli(args) {
   if (ctx) {
     const cw = ctx.context_window || {};
     const cost = ctx.cost || {};
-    const rl = ctx.rate_limits || {};
     const modelName = ctx.model?.display_name || ctx.model?.id || '-';
     const modelExtras = [
       ctx.effort?.level,
@@ -790,9 +790,11 @@ async function runSessionViewCli(args) {
       ? ` · ${cost.total_api_duration_ms != null ? formatAge(cost.total_api_duration_ms) : '-'} api / ${formatAge(cost.total_duration_ms)} total · +${cost.total_lines_added || 0}/-${cost.total_lines_removed || 0}`
       : '';
     lines.push(`  Cost: ${fmtCost(cost.total_cost_usd)}${timing}`);
-    if (rl.five_hour || rl.seven_day) {
-      lines.push(`  Limits: 5h ${rl.five_hour?.used_percentage ?? '-'}% · 7d ${rl.seven_day?.used_percentage ?? '-'}%`);
-    }
+  }
+  // Account-wide, so not read from this session's file, which can be days old.
+  const rl = await rateLimits;
+  if (rl.five_hour || rl.seven_day) {
+    lines.push(`  Limits: 5h ${rl.five_hour?.used_percentage ?? '-'}% · 7d ${rl.seven_day?.used_percentage ?? '-'}%`);
   }
   console.log(lines.join('\n'));
   return 0;

package/lib/parsers.js

@@ -373,20 +373,50 @@ const modeOf = (data) => {
   return (data.type === 'user' || data.type === 'permission-mode') && data.permissionMode || null;
 };
 
+const isMainReply = (data) =>
+  data.type === 'assistant' && !data.isSidechain && data.message?.usage && data.message.model !== '<synthetic>';
+
 // The TTL of the last prompt-cache write, from the API's 5m/1h split of cache_creation.
 const cacheTtlOf = (data) => {
-  const cc = data.type === 'assistant' && !data.isSidechain && data.message?.usage?.cache_creation;
+  const cc = isMainReply(data) && data.message.usage.cache_creation;
   if (!cc) return null;
   return cc.ephemeral_1h_input_tokens > 0 ? '1h' : cc.ephemeral_5m_input_tokens > 0 ? '5m' : null;
 };
 
+// Copy of displayName in the plugin's hooks/context.ts; Node cannot import the mod.
+function modelDisplayName(model) {
+  const m = /^claude-([a-z]+)-(\d+)(?:-(\d{1,2})(?!\d))?/.exec(model || '');
+  if (!m) return model || null;
+  return `${m[1][0].toUpperCase()}${m[1].slice(1)} ${m[3] ? `${m[2]}.${m[3]}` : m[2]}`;
+}
+
+const isMainUser = (data) => data.type === 'user' && !data.isSidechain && data.timestamp;
+
+// `at` is when the request went out: the reply's own lines land seconds to tens of seconds later,
+// which would make the cache countdown run long.
+const replyOf = (data, requestTs) => {
+  const u = data.message.usage;
+  return {
+    at: Date.parse(requestTs || data.timestamp) || null,
+    model: data.message.model || null,
+    usage: {
+      input_tokens: u.input_tokens || 0,
+      cache_read_input_tokens: u.cache_read_input_tokens || 0,
+      cache_creation_input_tokens: u.cache_creation_input_tokens || 0,
+      output_tokens: u.output_tokens || 0,
+    },
+  };
+};
+// After a compaction the old usage overstates what the next request writes.
+const withoutUsage = (reply) => reply && { ...reply, usage: null };
+
 // gitBranch in the JSONL is pinned to the launch-time repo by Claude Code
 // and goes stale once cwd shifts (Bash `cd`, submodule). Callers needing the
 // live branch must resolve it from cwd separately. Cache is reset on inode
 // change or truncation (size < scannedUpTo).
 
 function readSessionInfoFromJsonl(jsonlPath) {
-  const result = { slug: null, projectPath: null, cwd: null, gitBranch: null, customTitle: null, logicalParentUuid: null, compactBoundaryUuid: null, permissionMode: null, cacheTtl: null };
+  const result = { slug: null, projectPath: null, cwd: null, gitBranch: null, customTitle: null, logicalParentUuid: null, compactBoundaryUuid: null, permissionMode: null, cacheTtl: null, lastReply: null };
   let stat;
   let fd;
   try {
@@ -408,6 +438,7 @@ function readSessionInfoFromJsonl(jsonlPath) {
       compactBoundaryUuid: cached.compactBoundaryUuid || null,
       permissionMode: cached.permissionMode || null,
       cacheTtl: cached.cacheTtl || null,
+      lastReply: cached.lastReply || null,
       customTitle: readCustomTitle(jsonlPath, stat)
     };
   }
@@ -421,9 +452,11 @@ function readSessionInfoFromJsonl(jsonlPath) {
     result.compactBoundaryUuid = cached.compactBoundaryUuid || null;
     result.permissionMode = cached.permissionMode || null;
     result.cacheTtl = cached.cacheTtl || null;
+    result.lastReply = cached.lastReply || null;
   }
 
   let lastCwdSeen = result.cwd;
+  let lastUserTs = canIncrement ? cached.lastUserTs || null : null;
   const applyLine = (line) => {
     try {
       const data = JSON.parse(line);
@@ -437,6 +470,9 @@ function readSessionInfoFromJsonl(jsonlPath) {
       if (mode) result.permissionMode = mode;
       const ttl = cacheTtlOf(data);
       if (ttl) result.cacheTtl = ttl;
+      if (isMainUser(data)) lastUserTs = data.timestamp;
+      else if (isMainReply(data)) result.lastReply = replyOf(data, lastUserTs);
+      if (data.subtype === 'compact_boundary') result.lastReply = withoutUsage(result.lastReply);
       if (data.subtype === 'compact_boundary' && data.logicalParentUuid && !result.logicalParentUuid) {
         result.logicalParentUuid = data.logicalParentUuid;
         // The boundary record's own uuid: a fork copies it verbatim from the
@@ -450,6 +486,8 @@ function readSessionInfoFromJsonl(jsonlPath) {
   const CHUNK_SIZE = 16384;
   const TAIL_SIZE = 16384;
   const HEAD_MAX = 1048576;
+  const BACK_CHUNK = 65536;
+  const BACK_MAX = 2097152;
   let scannedUpTo = canIncrement ? cached.scannedUpTo : 0;
 
   try {
@@ -502,29 +540,66 @@ function readSessionInfoFromJsonl(jsonlPath) {
 
       // Tail scan catches late cwd switches past HEAD_MAX. projectPath stays
       // anchored to the earliest cwd — it is never overwritten here.
+      // The first window is TAIL_SIZE. A tail of one long line (11% of transcripts over 1 MB)
+      // holds no reply, so it reads further back in BACK_CHUNK steps until it finds one.
       if (stat.size > offset) {
-        const tailStart = Math.max(offset, stat.size - TAIL_SIZE);
-        const tailBuf = Buffer.alloc(TAIL_SIZE);
-        const tn = fs.readSync(fd, tailBuf, 0, TAIL_SIZE, tailStart);
-        const lines = tailBuf.toString('utf8', 0, tn).split('\n');
         let latestTailCwd = null;
         let latestTailMode = null;
         let latestTailTtl = null;
-        for (let i = lines.length - 1; i >= 0; i--) {
-          try {
-            const data = JSON.parse(lines[i]);
-            if (!latestTailTtl) latestTailTtl = cacheTtlOf(data);
-            if (!result.slug && data.slug) result.slug = data.slug;
-            if (!result.projectPath && data.cwd) result.projectPath = data.cwd;
-            if (!result.gitBranch && data.gitBranch) result.gitBranch = data.gitBranch;
-            if (!latestTailCwd && data.cwd) latestTailCwd = data.cwd;
-            if (!latestTailMode) latestTailMode = modeOf(data);
-            if (latestTailCwd && latestTailMode && latestTailTtl && result.slug && result.projectPath && result.gitBranch) break;
-          } catch {}
+        let tailReply = null;
+        let tailRequestTs = null;
+        let compactedAfterReply = false;
+        let latestTailUserTs = null;
+        // Filled from the end; [start, end) holds read bytes not parsed yet.
+        const window = Buffer.allocUnsafe(Math.min(BACK_MAX, stat.size - offset));
+        let start = window.length;
+        let end = window.length;
+        let pos = stat.size;
+        while (!(tailReply && tailRequestTs) && start > 0) {
+          const len = Math.min(pos === stat.size ? TAIL_SIZE : BACK_CHUNK, start);
+          start -= len;
+          pos -= len;
+          if (fs.readSync(fd, window, start, len, pos) < len) break;
+          let from = start;
+          if (pos > offset) {
+            // Bytes before the first newline may be the end of a line that starts further back.
+            const nl = window.subarray(start, start + len).indexOf(10);
+            if (nl < 0) continue;
+            from = start + nl + 1;
+          }
+          const lines = window.toString('utf8', from, end).split('\n');
+          end = from - 1;
+          for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+              const data = JSON.parse(lines[i]);
+              if (!latestTailTtl) latestTailTtl = cacheTtlOf(data);
+              if (!result.slug && data.slug) result.slug = data.slug;
+              if (!result.projectPath && data.cwd) result.projectPath = data.cwd;
+              if (!result.gitBranch && data.gitBranch) result.gitBranch = data.gitBranch;
+              if (!latestTailCwd && data.cwd) latestTailCwd = data.cwd;
+              if (!latestTailMode) latestTailMode = modeOf(data);
+              if (!latestTailUserTs && isMainUser(data)) latestTailUserTs = data.timestamp;
+              if (!tailReply) {
+                if (data.subtype === 'compact_boundary') compactedAfterReply = true;
+                else if (isMainReply(data)) tailReply = data;
+              } else if (!tailRequestTs && isMainUser(data)) tailRequestTs = data.timestamp;
+              if (latestTailCwd && latestTailMode && latestTailTtl && tailRequestTs && result.slug && result.projectPath && result.gitBranch) break;
+            } catch {}
+          }
         }
+        const reachedHead = pos <= offset;
         if (latestTailCwd) lastCwdSeen = latestTailCwd;
         if (latestTailMode) result.permissionMode = latestTailMode;
         if (latestTailTtl) result.cacheTtl = latestTailTtl;
+        if (latestTailUserTs || !reachedHead) lastUserTs = latestTailUserTs;
+        if (tailReply) {
+          const reply = replyOf(tailReply, tailRequestTs);
+          result.lastReply = compactedAfterReply ? withoutUsage(reply) : reply;
+        } else if (!reachedHead) {
+          // No reply in the last BACK_MAX bytes: the head's reply is far older than any TTL.
+          result.lastReply = null;
+          result.cacheTtl = null;
+        }
       }
       scannedUpTo = stat.size;
     }
@@ -548,7 +623,9 @@ function readSessionInfoFromJsonl(jsonlPath) {
       logicalParentUuid: result.logicalParentUuid,
       compactBoundaryUuid: result.compactBoundaryUuid,
       permissionMode: result.permissionMode,
-      cacheTtl: result.cacheTtl
+      cacheTtl: result.cacheTtl,
+      lastReply: result.lastReply,
+      lastUserTs
     });
     if (sessionInfoCache.size > SESSION_INFO_CACHE_MAX) {
       const firstKey = sessionInfoCache.keys().next().value;
@@ -1592,35 +1669,78 @@ function extractPromptFromTranscript(jsonlPath) {
   return null;
 }
 
+// The last maxBytes of a file as whole lines: a cut first line is dropped.
+function readTailLines(jsonlPath, maxBytes) {
+  const size = statSync(jsonlPath).size;
+  const readSize = Math.min(maxBytes, size);
+  const start = size - readSize;
+  const buf = Buffer.alloc(readSize);
+  const fd = fs.openSync(jsonlPath, 'r');
+  try {
+    fs.readSync(fd, buf, 0, readSize, start);
+  } finally {
+    fs.closeSync(fd);
+  }
+  const text = buf.toString('utf8');
+  return (start > 0 ? text.slice(text.indexOf('\n') + 1) : text).split('\n');
+}
+
+function lineModel(line) {
+  if (!line.trim()) return null;
+  try {
+    const obj = JSON.parse(line);
+    return obj.model || obj.message?.model || null;
+  } catch (_) {
+    return null;
+  }
+}
+
 function extractModelFromTranscript(jsonlPath) {
   const { openSync, readSync, closeSync } = fs;
   const MAX_READ = 65536;
   const CHUNK = 4096;
   const fd = openSync(jsonlPath, 'r');
+  let size;
   try {
+    size = fs.fstatSync(fd).size;
     let accumulated = '';
+    let total = 0;
     const buf = Buffer.alloc(CHUNK);
-    while (accumulated.length < MAX_READ) {
+    while (total < MAX_READ) {
       const bytesRead = readSync(fd, buf, 0, CHUNK, null);
       if (bytesRead === 0) break;
+      total += bytesRead;
       accumulated += buf.toString('utf8', 0, bytesRead);
       for (let nlIdx = accumulated.indexOf('\n'); nlIdx !== -1; nlIdx = accumulated.indexOf('\n')) {
-        const line = accumulated.slice(0, nlIdx);
+        const model = lineModel(accumulated.slice(0, nlIdx));
         accumulated = accumulated.slice(nlIdx + 1);
-        if (!line.trim()) continue;
-        try {
-          const obj = JSON.parse(line);
-          const model = obj.model || obj.message?.model;
-          if (model) return model;
-        } catch (_) {}
+        if (model) return model;
       }
     }
   } finally {
     closeSync(fd);
   }
+  // A long prompt or tool result can push the first assistant line past the
+  // head window, so look at the newest lines too.
+  if (size <= MAX_READ) return null;
+  const lines = readTailLines(jsonlPath, MAX_READ);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const model = lineModel(lines[i]);
+    if (model) return model;
+  }
   return null;
 }
 
+// The meta file Claude Code writes next to a subagent transcript: agentType,
+// description, and the model the agent was asked for ("opus", "haiku", "inherit").
+function readSubagentMeta(jsonlPath) {
+  try {
+    return JSON.parse(readFileSync(jsonlPath.replace(/\.jsonl$/, '.meta.json'), 'utf8'));
+  } catch (_) {
+    return null;
+  }
+}
+
 // Full-file scan of a subagent transcript for roster stats: model, summed
 // output tokens, and first/last timestamps (for duration). COLD PATH ONLY —
 // used by the workflow run view on demand, never from the session-scan hot
@@ -1680,18 +1800,8 @@ function resultFromBlock(b) {
 }
 
 function extractAgentResultFromTranscript(jsonlPath) {
-  const { openSync, readSync, closeSync } = fs;
-  const stat = statSync(jsonlPath);
-  const readSize = Math.min(1048576, stat.size);
-  const start = stat.size - readSize;
-  const fd = openSync(jsonlPath, 'r');
+  const lines = readTailLines(jsonlPath, 1048576);
   try {
-    const buf = Buffer.alloc(readSize);
-    readSync(fd, buf, 0, readSize, start);
-    const text = buf.toString('utf8');
-    // Drop the leading partial line unless we read from the very start.
-    const clean = start > 0 ? text.slice(text.indexOf('\n') + 1) : text;
-    const lines = clean.split('\n');
     const lastAssistant = (needle, pick) => {
       for (let i = lines.length - 1; i >= 0; i--) {
         if (!needle(lines[i])) continue;
@@ -1710,10 +1820,7 @@ function extractAgentResultFromTranscript(jsonlPath) {
       (line) => line.includes('"type":"assistant"'),
       (content) => toolResultText(content).trim(),
     );
-  } catch (_) {
-  } finally {
-    closeSync(fd);
-  }
+  } catch (_) {}
   return null;
 }
 
@@ -1851,6 +1958,7 @@ function buildLoopInfoFromState(state) {
 }
 
 module.exports = {
+  modelDisplayName,
   parseTask,
   parseAgent,
   parseWaiting,
@@ -1881,6 +1989,7 @@ module.exports = {
   findTerminatedTeammates,
   extractPromptFromTranscript,
   extractModelFromTranscript,
+  readSubagentMeta,
   extractAgentResultFromTranscript,
   extractTranscriptStats,
   readLines

package/lib/rate-limits.js

@@ -0,0 +1,21 @@
+// Rate limits belong to the account, so each window comes from the freshest context-status
+// file that has it. A window whose `resets_at` (epoch seconds) has passed is dropped: its
+// percent is from before the reset. A window with no `resets_at` is kept.
+
+const WINDOWS = ['five_hour', 'seven_day'];
+
+function freshRateLimits(entries, nowSec) {
+  const best = {};
+  for (const e of entries) {
+    for (const w of WINDOWS) {
+      const limit = e?.rate_limits?.[w];
+      if (limit?.used_percentage == null) continue;
+      if (limit.resets_at != null && limit.resets_at <= nowSec) continue;
+      const at = e._updatedAt || 0;
+      if (!best[w] || at > best[w].at) best[w] = { at, limit };
+    }
+  }
+  return Object.fromEntries(Object.entries(best).map(([w, b]) => [w, b.limit]));
+}
+
+module.exports = { freshRateLimits };

package/lib/retention.js

@@ -10,6 +10,7 @@ const DEFAULT_CLEANUP_DAYS = 30;
 // read that gap as a deleted transcript.
 const GRACE_MS = 60 * 60 * 1000;
 const MAX_DISPATCHED = 500;
+const MAX_CONTEXT_STATUS = 2000;
 
 // Only the config dir's settings: retention is per config dir, not per project.
 function retentionMs(claudeDir) {
@@ -94,6 +95,22 @@ async function scanTranscripts(projectsDir) {
   return ids.size ? { ids, dirs } : null;
 }
 
+async function expireFiles(dir, names, idOf, opts) {
+  let removed = 0;
+  const kept = [];
+  for (const f of names) {
+    const file = path.join(dir, f);
+    try {
+      const { mtimeMs } = await fs.stat(file);
+      if (isExpired(idOf(f), mtimeMs, opts)) {
+        await fs.rm(file, { force: true });
+        removed++;
+      } else kept.push({ file, mtimeMs });
+    } catch {}
+  }
+  return { removed, kept };
+}
+
 // `<dir>/<session id>/<ts>.md`, one folder per session.
 async function pruneSessionDirs(dir, { known, maxAgeMs, now = Date.now() }) {
   let removed = 0;
@@ -108,21 +125,46 @@ async function pruneSessionDirs(dir, { known, maxAgeMs, now = Date.now() }) {
     const sessionDir = path.join(dir, d.name);
     try {
       const files = await fs.readdir(sessionDir);
-      let kept = 0;
-      for (const f of files) {
-        const file = path.join(sessionDir, f);
-        const { mtimeMs } = await fs.stat(file);
-        if (isExpired(d.name, mtimeMs, { known, maxAgeMs, now })) {
-          await fs.rm(file, { force: true });
-          removed++;
-        } else kept++;
-      }
+      const res = await expireFiles(sessionDir, files, () => d.name, { known, maxAgeMs, now });
+      removed += res.removed;
       // An old mtime means no file was added since the read, so a review written right
       // now cannot lose its folder.
-      if (!kept && now - (await fs.stat(sessionDir)).mtimeMs >= GRACE_MS) await fs.rmdir(sessionDir);
+      if (!res.kept.length && now - (await fs.stat(sessionDir)).mtimeMs >= GRACE_MS) await fs.rmdir(sessionDir);
     } catch {}
   }
   return removed;
 }
 
-module.exports = { createDispatchedStore, scanTranscripts, pruneSessionDirs, retentionMs, GRACE_MS, MAX_DISPATCHED, DAY_MS };
+// `<dir>/<session id>.json`, written by the plugin mod. The cap guards users who keep
+// transcripts forever; it drops the oldest by mtime.
+async function pruneContextStatus(dir, { known, maxAgeMs, now = Date.now(), max = MAX_CONTEXT_STATUS }) {
+  let names;
+  try {
+    names = await fs.readdir(dir);
+  } catch {
+    return 0;
+  }
+  const jsonNames = names.filter((f) => f.endsWith('.json'));
+  let { removed, kept } = await expireFiles(dir, jsonNames, (f) => f.slice(0, -'.json'.length), { known, maxAgeMs, now });
+  if (kept.length > max) {
+    kept.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    for (const { file } of kept.slice(max)) {
+      try {
+        await fs.rm(file, { force: true });
+        removed++;
+      } catch {}
+    }
+  }
+  return removed;
+}
+
+module.exports = {
+  createDispatchedStore,
+  scanTranscripts,
+  pruneSessionDirs,
+  pruneContextStatus,
+  retentionMs,
+  GRACE_MS,
+  MAX_DISPATCHED,
+  DAY_MS,
+};

package/lib/session-cache.js

@@ -4,7 +4,7 @@ const { exportParentVerdicts, importParentVerdicts, parentVerdictsDirty } = requ
 const { exportTaskCounts, importTaskCounts, taskCountsDirty } = require('./task-counts');
 
 // Bump when an entry's shape or meaning changes: a file with another version is ignored.
-const VERSION = 4;
+const VERSION = 5;
 // A cache this large is not one cck wrote for a normal set of transcripts. Rebuild it cold.
 const MAX_BYTES = 8 * 1024 * 1024;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "6.1.0",
+  "version": "6.1.2",
   "description": "A web-based Kanban board for viewing Claude Code tasks with agent teams support",
   "main": "server.js",
   "type": "commonjs",

package/plugin/plugins/claude-code-kanban/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "2.23.0",
+  "version": "2.24.0",
   "description": "claude-code-kanban dashboard integration: agent activity tracking, context and cost tracking, skills to drive the board from a session and to follow it",
   "experimental": {
     "monitors": "./monitors.json"

package/plugin/plugins/claude-code-kanban/hooks/activity.ts

@@ -149,13 +149,14 @@ async function markStopped($: EngineInterface) {
 }
 
 // The name map lets TeammateIdle, which names the teammate, find its agent id.
-async function agentStarted($: EngineInterface, agentId: string, type: string, name?: string) {
+async function agentStarted($: EngineInterface, agentId: string, type: string, model: string, name?: string) {
   const dir = await sessionDir($)
   const ts = new Date().toISOString()
   await Promise.all([
     appendLine($, `${dir}/${agentId}.jsonl`, {
       agentId,
       type,
+      model,
       event: 'start',
       status: 'active',
       startedAt: ts,
@@ -248,7 +249,7 @@ export const register: Register = on => {
   })
   on('agent.spawn', async ($, e, next) => {
     const result = await next(e)
-    if (result.agentId) await agentStarted($, result.agentId, e.subagentType, e.name)
+    if (result.agentId) await agentStarted($, result.agentId, e.subagentType, result.model, e.name)
     return result
   })
   // An interrupted turn fires no Stop hook, so it does not mark the session unread either.

package/plugin/plugins/claude-code-kanban/hooks/context.ts

@@ -42,22 +42,17 @@ function cckDir($: EngineInterface) {
   return cck
 }
 
-let lastUsage: ModelUsage | undefined
-let lastModel: string | undefined
-let lastRequestAt: number | undefined
-const lastWritten = new Map<string, string>()
+// Keyed by session id: `/clear` keeps the process and changes the id.
+const sessions = new Map<string, { req?: { usage: ModelUsage; model: string; at: number }; written?: string }>()
 
-async function write($: EngineInterface, m: Measure) {
-  const [sessionId, model, dir] = await Promise.all([
-    $.session.id(),
-    lastModel ?? $.session.model(),
-    cckDir($),
-  ])
-  const text = JSON.stringify(toStatus(model, m, lastUsage, lastRequestAt))
-  const file = `${dir}/context-status/${sessionId}.json`
-  if (lastWritten.get(file) === text) return
-  await $.fs.write(file, text)
-  lastWritten.set(file, text)
+async function write($: EngineInterface, m: Measure, id?: string) {
+  const [sessionId, dir] = await Promise.all([id ?? $.session.id(), cckDir($)])
+  const s = sessions.get(sessionId) ?? {}
+  const model = s.req?.model ?? (await $.session.model())
+  const text = JSON.stringify(toStatus(model, m, s.req?.usage, s.req?.at))
+  if (s.written === text) return
+  await $.fs.write(`${dir}/context-status/${sessionId}.json`, text)
+  sessions.set(sessionId, { ...s, written: text })
 }
 
 export const register: Register = on => {
@@ -65,10 +60,9 @@ export const register: Register = on => {
     const result = yield* next(e)
     if (e.agentId === undefined && result.usage) {
       const { model, ...usage } = result.usage
-      lastUsage = usage
-      lastModel = model
-      lastRequestAt = Date.now()
-      await write($, await $.session.usage())
+      const sessionId = await $.session.id()
+      sessions.set(sessionId, { ...sessions.get(sessionId), req: { usage, model, at: Date.now() } })
+      await write($, await $.session.usage(), sessionId)
     }
     return result
   })
@@ -77,4 +71,9 @@ export const register: Register = on => {
     await write($, e)
     return next(e)
   })
+
+  on('session.end', async ($, e, next) => {
+    sessions.delete(e.sessionId)
+    return next(e)
+  })
 }

package/plugin/plugins/claude-code-kanban/skills/kanban/SKILL.md

@@ -28,6 +28,8 @@ claude-code-kanban help <command> <subcommand> # flags and examples
 | `view` / `peek` | `session view <id>`, `session peek <id>` |
 | tasks, projects | `task list`, `project list` |
 
+`preview` and `link` take markdown (`.md`) and HTML (`.html`). HTML renders as authored in a sandboxed iframe, and cck inlines its local stylesheets, scripts and images, `url()` refs in `<style>` blocks included. To show the user a page, a prototype or a collage of screenshots, write the HTML and preview that file: do not render it to an image first or serve it over HTTP.
+
 To be driven *by* the board instead — card moves arriving as instructions — the user types `/claude-code-kanban:follow`.
 
 ## Troubleshooting

package/plugin/plugins/claude-code-kanban/tests/activity.test.ts

@@ -253,7 +253,7 @@ test('a subagent spawn then finish records start and stop', async ($, on) => {
   await $.turn.complete(turn({ agentId: 'a1', answer: 'Task done with "quotes"' }))
 
   const [start, stop] = lines(files[`${SESSION}/a1.jsonl`])
-  expect(start).toMatchObject({ agentId: 'a1', type: 'general-purpose', event: 'start', status: 'active' })
+  expect(start).toMatchObject({ agentId: 'a1', type: 'general-purpose', model: 'haiku', event: 'start', status: 'active' })
   expect(stop).toMatchObject({ agentId: 'a1', event: 'stop', status: 'stopped', lastMessage: 'Task done with "quotes"' })
   expect('type' in stop).toBe(false)
   expect(files[`${SESSION}/_name-general-purpose.id`]).toBe('a1')

package/plugin/plugins/claude-code-kanban/tests/context.test.ts

@@ -12,14 +12,14 @@ const MEASURE: SessionMeasureInput = {
   changed: ['context', 'rateLimits', 'cost'],
 }
 
-function engine(on: On, env: Record<string, string>, sessionId: string) {
+function engine(on: On, env: Record<string, string>, sessionId: string | (() => string)) {
   const writes: { path: string; text: string }[] = []
   on('fs.write', (_$, e) => {
     writes.push({ path: e.path.replaceAll('\\', '/'), text: e.text })
     return { value: undefined }
   })
   on('env.get', (_$, e) => ({ value: env[e.name] }))
-  on('session.id', () => ({ value: sessionId }))
+  on('session.id', () => ({ value: typeof sessionId === 'function' ? sessionId() : sessionId }))
   on('session.model', () => ({ value: 'claude-opus-5-5' }))
   on('session.measure', (_$, e) => ({ changed: [...e.changed] }))
   return writes
@@ -53,6 +53,37 @@ test('session.measure writes no cache entry before the first request', async ($,
   expect(JSON.parse(writes[0]?.text ?? '{}').cache).toBeUndefined()
 })
 
+const USAGE = { input_tokens: 2, output_tokens: 100, cache_read_input_tokens: 5000, cache_creation_input_tokens: 300 }
+
+test('after /clear the new session id does not get the old request', async ($, on) => {
+  let sid = 'sid-old'
+  const writes = engine(on, { CLAUDE_CONFIG_DIR: 'C:/cfg' }, () => sid)
+  on('session.usage', () => ({ value: MEASURE }))
+  on('session.end', (_$, e) => ({ sessionId: e.sessionId }))
+  on('turn.step', async function* (_$, e) {
+    return { turnId: e.turnId, index: e.index, answer: 'ok', toolUses: [], stopReason: 'end_turn', usage: { ...USAGE, model: 'claude-fable-5-1' } }
+  })
+
+  const step = $.turn.step({ turnId: 't1', index: 0, model: 'claude-fable-5-1', messageCount: 1 })
+  for await (const _ of step);
+  await step.result
+  expect(writes.length).toBe(1)
+  const old = JSON.parse(writes.at(-1)?.text ?? '{}')
+  expect(old.cache?.last_request_at).toBeGreaterThan(0)
+  expect(old.context_window.current_usage).toEqual(USAGE)
+  expect(old.model.id).toBe('claude-fable-5-1')
+
+  await $.session.end({ reason: 'clear', sessionId: 'sid-old', resume: {} as never })
+  sid = 'sid-new'
+  await $.session.measure(MEASURE)
+
+  expect(writes.at(-1)?.path).toBe('C:/cfg/.cck/context-status/sid-new.json')
+  const fresh = JSON.parse(writes.at(-1)?.text ?? '{}')
+  expect(fresh.cache).toBeUndefined()
+  expect(fresh.context_window.current_usage).toBeNull()
+  expect(fresh.model.id).toBe('claude-opus-5-5')
+})
+
 test('toStatus adds the last request time', async () => {
   const status = toStatus('claude-opus-5-5', MEASURE, undefined, 1_790_000_000_000)
   expect(status.cache).toEqual({ last_request_at: 1_790_000_000_000 })

package/public/app.js

@@ -889,7 +889,12 @@ async function viewAgentLog(agentId) {
   if (!messagePanelOpen) toggleMessagePanel();
   const header = document.querySelector('.message-panel-header h3');
   if (header) {
-    header.innerHTML = `<span class="agent-log-title"><button class="agent-log-back" onclick="exitAgentLogMode()" title="Back to session log">&larr;</button> ${escapeHtml(agent.type || 'unknown')} <code class="agent-log-id">(${escapeHtml(shortId)})</code></span>`;
+    const fullModel = agentModel(agent);
+    const model = shortModelName(fullModel);
+    const modelHtml = model
+      ? `<span class="agent-log-model" title="${escapeHtml(fullModel)}">${escapeHtml(model)}</span> <span class="agent-ident-sep">·</span> `
+      : '';
+    header.innerHTML = `<span class="agent-log-title"><button class="agent-log-back" onclick="exitAgentLogMode()" title="Back to session log">&larr;</button> ${modelHtml}${escapeHtml(agent.type || 'unknown')} <code class="agent-log-id">(${escapeHtml(shortId)})</code></span>`;
   }
   fetchAgentMessages();
   if (agentLogSSE) {
@@ -3138,15 +3143,12 @@ function renderAgentFooter() {
               : `active · ${formatDuration(elapsed)}`;
         const descText = a.description || '';
         const promptTrimmed = stripAnsi(stripTeammateWrapper((a.prompt || '').trim())).replace(/[\r\n]+/g, ' ');
-        const displayText = descText || promptTrimmed;
-        const displayTrunc = displayText.length > 60 ? `${displayText.substring(0, 60)}…` : displayText;
-        const msgHtml = displayTrunc
-          ? `<div class="agent-message" title="${escapeHtml(displayText)}">${escapeHtml(displayTrunc)}</div>`
-          : '';
         const rawType = a.type || 'unknown';
         const colonIdx = rawType.indexOf(':');
         const typeNs = colonIdx > 0 ? rawType.substring(0, colonIdx + 1) : '';
         const typeName = colonIdx > 0 ? rawType.substring(colonIdx + 1) : rawType;
+        const displayText = descText || promptTrimmed || typeName;
+        const taskHtml = `<div class="agent-task" title="${escapeHtml(displayText)}">${escapeHtml(displayText)}</div>`;
         const agentNameVal = a.agentName || null;
         const nameColor = agentNameVal ? getOwnerColor(agentNameVal) : null;
         const nameBadgeHtml = nameColor
@@ -3155,15 +3157,16 @@ function renderAgentFooter() {
         const agentColor = resolveNamedColor(a.color);
         const colorStyle = agentColor ? ` style="border-left:3px solid ${agentColor.color}"` : '';
         const selectedClass = a.agentId === currentAgentModalId ? ' selected' : '';
-        const cardModel = shortModelName(a.model);
-        const modelChipHtml = cardModel
-          ? `<span class="agent-card-model" title="${escapeHtml(a.model)}">${escapeHtml(cardModel)}</span>`
+        const fullModel = agentModel(a);
+        const cardModel = shortModelName(fullModel);
+        const modelHtml = cardModel
+          ? `<span class="agent-card-model" title="${escapeHtml(fullModel)}">${escapeHtml(cardModel)}</span><span class="agent-ident-sep">·</span>`
           : '';
         return `<div class="agent-card${selectedClass}" data-agent-id="${escapeHtml(a.agentId)}"${colorStyle} onclick="showAgentModal('${escAttrJs(a.agentId)}')">
           ${agentLogButton(a.agentId, 'agent-card-log-btn')}
-          <div class="agent-type-row">${typeNs ? `<span class="agent-type-ns">${escapeHtml(typeNs)}</span>` : ''}<span class="agent-type-name">${escapeHtml(typeName)}</span>${nameBadgeHtml}</div>
-          <div class="agent-status-row"><span class="agent-dot ${a.status}"></span><span class="agent-status">${statusText}</span>${modelChipHtml}</div>
-          ${msgHtml}
+          ${taskHtml}
+          <div class="agent-ident-row">${modelHtml}<span class="agent-type-name" title="${escapeHtml(rawType)}">${typeNs ? `<span class="agent-type-ns">${escapeHtml(typeNs)}</span>` : ''}${escapeHtml(typeName)}</span>${nameBadgeHtml}</div>
+          <div class="agent-status-row"><span class="agent-dot ${a.status}"></span><span class="agent-status">${statusText}</span></div>
         </div>`;
       })
       .join('');
@@ -3266,7 +3269,7 @@ function showAgentModal(agentId) {
   const modalNameLabel = agent.agentName ? ` · ${escapeHtml(agent.agentName)}` : '';
   title.innerHTML = `${statusDot} ${escapeHtml(agent.type || 'unknown')}${modalNameLabel}`;
 
-  const shortModel = shortModelName(agent.model);
+  const shortModel = shortModelName(agentModel(agent));
   const shortId = agent.agentId ? agent.agentId.slice(0, 8) : '';
   const chip = (label, value, opts = {}) => {
     const cls = opts.cls ? ` ${opts.cls}` : '';
@@ -8948,10 +8951,10 @@ const INPUT_PRICE_PER_MTOK = [
 function cacheRewrite(usage, modelId, writeRate) {
   const price = INPUT_PRICE_PER_MTOK.find(([prefix]) => modelId?.startsWith(prefix))?.[1];
   const tokens =
-    (usage.input_tokens || 0) +
-    (usage.cache_read_input_tokens || 0) +
-    (usage.cache_creation_input_tokens || 0) +
-    (usage.output_tokens || 0);
+    (usage?.input_tokens || 0) +
+    (usage?.cache_read_input_tokens || 0) +
+    (usage?.cache_creation_input_tokens || 0) +
+    (usage?.output_tokens || 0);
   if (!price || !tokens) return null;
   return { tokens, usd: (tokens / 1e6) * price * writeRate };
 }
@@ -8982,47 +8985,48 @@ function tickCacheTimers() {
   }
 }
 
-function renderCacheTimer(lastRequestAt, ttl, usage, modelId) {
+function renderCacheTimer({ at, ttl, usage, model }) {
   const cache = CACHE_TTL[ttl];
-  if (!lastRequestAt || !cache) return '';
-  const expiresAt = lastRequestAt + cache.ms;
-  const rewrite = cacheRewrite(usage, modelId, cache.write);
+  if (!at || !cache) return '';
+  const expiresAt = at + cache.ms;
+  const rewrite = cacheRewrite(usage, model, cache.write);
   const expiredText = rewrite ? `expired · ~${formatCost(rewrite.usd)}` : 'expired';
   const { text, color } = formatCacheLeft(expiresAt, expiredText);
   cacheTimerInterval ??= setInterval(tickCacheTimers, 1000);
-  const at = new Date(expiresAt).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+  const clock = new Date(expiresAt).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
   const cost = rewrite
     ? ` It writes ${formatTokens(rewrite.tokens / 1000)} tokens again, about ${formatCost(rewrite.usd)} at list price.`
     : '';
-  const title = `Prompt cache, ${ttl} TTL. Expires at ${at}; the next request after that writes it again.${cost}`;
-  return `<div class="stat-item" title="${escapeHtml(title)}"><span class="stat-label">Cache</span><span class="stat-value cache-timer" data-expires="${expiresAt}" data-expired-text="${escapeHtml(expiredText)}" style="color:${color}">${text}</span></div>`;
+  const title = `Prompt cache, ${ttl} TTL. Expires at ${clock}; the next request after that writes it again.${cost}`;
+  return `<div class="stat-item" title="${escapeHtml(title)}"><span class="stat-label">Cache</span><span class="stat-value cache-timer" data-expires="${escapeHtml(expiresAt)}" data-expired-text="${escapeHtml(expiredText)}" style="color:${color}">${text}</span></div>`;
 }
 
+// The Cache row and the current-usage rows come from the transcript (session.cache); the rest needs the plugin's file.
 function renderContextDetail(session, { tokens = true } = {}) {
   const ctx = getCtx(session);
-  if (!ctx) return '';
-  const raw = session.contextStatus;
-  const totalK = ctx.size / 1000;
-  const color = getContextColor(ctx.usedTokens, ctx.modelName);
-
-  const cw = raw.context_window || {};
-  const usage = cw.current_usage || {};
-  const cost = raw.cost || {};
-  const tokenRows = tokens
-    ? `<div class="stat-item"><span class="stat-label">Cache read</span><span class="stat-value">${formatTokens((usage.cache_read_input_tokens || 0) / 1000)}</span></div>
-            <div class="stat-item"><span class="stat-label">Cache write</span><span class="stat-value">${formatTokens((usage.cache_creation_input_tokens || 0) / 1000)}</span></div>
-            <div class="stat-item"><span class="stat-label">Current input</span><span class="stat-value">${formatTokens((usage.input_tokens || 0) / 1000)}</span></div>
-            <div class="stat-item"><span class="stat-label">Current output</span><span class="stat-value">${formatTokens((usage.output_tokens || 0) / 1000)}</span></div>
-            <div class="stat-divider"></div>
-            <div class="stat-item"><span class="stat-label">Total input</span><span class="stat-value">${formatTokens(ctx.inputTokens / 1000)}</span></div>
+  const reply = session.cache;
+  if (!ctx && !reply) return '';
+  const usage = reply?.usage;
+  const cost = session.contextStatus?.cost || {};
+  const color = ctx && getContextColor(ctx.usedTokens, ctx.modelName);
+  const title = ctx?.modelName || reply?.modelName || 'Context Window';
+
+  const usageRows =
+    tokens && usage
+      ? `<div class="stat-item"><span class="stat-label">Cache read</span><span class="stat-value">${formatTokens(usage.cache_read_input_tokens / 1000)}</span></div>
+            <div class="stat-item"><span class="stat-label">Cache write</span><span class="stat-value">${formatTokens(usage.cache_creation_input_tokens / 1000)}</span></div>
+            <div class="stat-item"><span class="stat-label">Current input</span><span class="stat-value">${formatTokens(usage.input_tokens / 1000)}</span></div>
+            <div class="stat-item"><span class="stat-label">Current output</span><span class="stat-value">${formatTokens(usage.output_tokens / 1000)}</span></div>
+            <div class="stat-divider"></div>`
+      : '';
+  const totalRows =
+    tokens && ctx
+      ? `<div class="stat-item"><span class="stat-label">Total input</span><span class="stat-value">${formatTokens(ctx.inputTokens / 1000)}</span></div>
             ${ctx.outputTokens ? `<div class="stat-item"><span class="stat-label">Total output</span><span class="stat-value">${formatTokens(ctx.outputTokens / 1000)}</span></div>` : ''}
             <div class="stat-divider"></div>`
-    : '';
-
-  return `
-        <div class="detail-context">
-          <div class="detail-context-title">${ctx.modelName ? escapeHtml(ctx.modelName) : 'Context Window'}</div>
-          <div class="detail-context-bar">
+      : '';
+  const bar = ctx
+    ? `<div class="detail-context-bar">
             <div class="context-bar-track">
               <div class="context-bar-fill" style="width:${ctx.pct}%;background:${color}"></div>
               ${renderMarkers(ctx.markers)}
@@ -9030,12 +9034,19 @@ function renderContextDetail(session, { tokens = true } = {}) {
           </div>
           <div class="detail-context-summary">
             <span style="color:${color}">${Math.round(ctx.pct)}% used</span>
-            <span${ctx.compacts ? ` title="Auto-compact window · model window ${escapeHtml(formatTokens(ctx.modelSize / 1000))}"` : ''}>${formatTokens(ctx.usedTokens / 1000)} / ${formatTokens(totalK)}</span>
-          </div>
+            <span${ctx.compacts ? ` title="Auto-compact window · model window ${escapeHtml(formatTokens(ctx.modelSize / 1000))}"` : ''}>${formatTokens(ctx.usedTokens / 1000)} / ${formatTokens(ctx.size / 1000)}</span>
+          </div>`
+    : '';
+
+  return `
+        <div class="detail-context">
+          <div class="detail-context-title">${escapeHtml(title)}</div>
+          ${bar}
           <div class="detail-context-stats">
-            ${tokenRows}
-            <div class="stat-item"><span class="stat-label">Cost</span><span class="stat-value" style="color:${getCostColor(cost.total_cost_usd)}">${formatCost(cost.total_cost_usd)}</span></div>
-            ${renderCacheTimer(raw.cache?.last_request_at, session.cacheTtl, usage, raw.model?.id)}
+            ${usageRows}
+            ${totalRows}
+            ${ctx ? `<div class="stat-item"><span class="stat-label">Cost</span><span class="stat-value" style="color:${getCostColor(cost.total_cost_usd)}">${formatCost(cost.total_cost_usd)}</span></div>` : ''}
+            ${reply ? renderCacheTimer(reply) : ''}
             ${cost.total_duration_ms != null ? `<div class="stat-item"><span class="stat-label">Duration</span><span class="stat-value">${formatDuration(cost.total_duration_ms)}</span></div>` : ''}
             ${cost.total_api_duration_ms != null ? `<div class="stat-item"><span class="stat-label">API time</span><span class="stat-value">${formatDuration(cost.total_api_duration_ms)}</span></div>` : ''}
             ${cost.total_lines_added != null ? `<div class="stat-item"><span class="stat-label">Lines</span><span class="stat-value"><span style="color:${CONTEXT_COLORS.green}">+${(cost.total_lines_added || 0).toLocaleString()}</span> / <span style="color:${CONTEXT_COLORS.red}">-${(cost.total_lines_removed || 0).toLocaleString()}</span></span></div>` : ''}
@@ -10530,9 +10541,10 @@ function showInfoModal(session, teamConfig, tasks, planContent, parentInfo) {
   });
   html += `</div>`;
 
-  if (session.contextStatus) {
+  const contextHtml = renderContextDetail(session);
+  if (contextHtml) {
     html += `<hr style="border: none; border-top: 1px solid var(--border); margin: 12px 0;">`;
-    html += renderContextDetail(session);
+    html += contextHtml;
   }
 
   if (planContent) {
@@ -11266,6 +11278,10 @@ function shortModelName(model) {
   return model ? model.replace(/^claude-/, '').replace(/-\d{8}$/, '') : '';
 }
 
+function agentModel(agent) {
+  return agent.model || agent.modelAlias || '';
+}
+
 function renderWorkflowRun(run) {
   const body = document.getElementById('workflow-modal-body');
   const allDone = run.startedCount > 0 && run.doneCount >= run.startedCount;
@@ -13209,7 +13225,7 @@ msgContentEl.addEventListener('wheel', function (e) {
   }
 });
 
-const footerState = { version: null, plugin: null, limitsKey: null, timer: null };
+const footerState = { version: null, plugin: null, limitsKey: null, timer: null, resetTimer: null };
 function formatResetIn(epochSec) {
   if (!epochSec) return null;
   const ms = epochSec * 1000 - Date.now();
@@ -13298,14 +13314,10 @@ function refreshRateLimits() {
   if (footerState.timer) return;
   footerState.timer = setTimeout(() => {
     footerState.timer = null;
-    fetch('/api/context-status')
+    fetch('/api/rate-limits')
       .then((r) => r.json())
-      .then((all) => {
-        let freshest = null;
-        for (const e of Object.values(all || {})) {
-          if (e?.rate_limits && (!freshest || (e._updatedAt || 0) > (freshest._updatedAt || 0))) freshest = e;
-        }
-        const rl = freshest?.rate_limits || null;
+      .then((rl) => {
+        scheduleRateLimitReset(rl);
         const fh = rl?.five_hour?.used_percentage ?? null;
         const sd = rl?.seven_day?.used_percentage ?? null;
         const key = `${fh}|${sd}`;
@@ -13316,6 +13328,18 @@ function refreshRateLimits() {
       .catch(() => {});
   }, 1500);
 }
+
+// No context-update comes when a window resets on an idle board, so refetch at the earliest reset.
+function scheduleRateLimitReset(rl) {
+  clearTimeout(footerState.resetTimer);
+  footerState.resetTimer = null;
+  const resets = Object.values(rl || {})
+    .map((b) => b?.resets_at)
+    .filter((s) => s > 0);
+  if (!resets.length) return;
+  const ms = Math.min(...resets) * 1000 - Date.now() + 1000;
+  footerState.resetTimer = setTimeout(refreshRateLimits, Math.min(Math.max(ms, 0), 2 ** 31 - 1));
+}
 fetch('/api/version')
   .then((r) => r.json())
   .then((d) => {

package/public/style.css

@@ -4407,13 +4407,19 @@ body.booting .boot-splash {
 }
 .agent-log-title {
   display: flex;
-  align-items: center;
+  align-items: baseline;
   gap: 6px;
 }
 .agent-log-id {
   font-size: 11px;
   color: var(--text-tertiary);
 }
+.agent-log-model {
+  font-family: var(--mono);
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--text-primary);
+}
 .msg-agent-log-btn {
   flex-shrink: 0;
   margin-left: 0;
@@ -4636,7 +4642,8 @@ body.booting .boot-splash {
   border: 1px solid color-mix(in srgb, var(--border) 55%, transparent);
   border-radius: 8px;
   white-space: nowrap;
-  min-width: 0;
+  flex-shrink: 0;
+  min-width: 180px;
   overflow: hidden;
   transition:
     opacity 0.3s,
@@ -4675,21 +4682,33 @@ body.booting .boot-splash {
 .agent-card.fading {
   opacity: 0.4;
 }
-.agent-type-row {
+.agent-task {
+  max-width: 240px;
+  padding-right: 14px;
+  font-size: 12.5px;
+  font-weight: 600;
+  color: var(--text-primary);
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.agent-ident-row {
   display: flex;
   align-items: center;
-  gap: 4px;
+  gap: 5px;
   min-width: 0;
+  max-width: 240px;
+  font-size: 11px;
+  color: var(--text-secondary);
+}
+.agent-ident-sep {
+  color: var(--text-muted);
+  flex-shrink: 0;
 }
 .agent-type-ns {
-  font-size: 11px;
   color: var(--text-muted);
-  font-weight: 400;
 }
 .agent-type-name {
-  font-size: 13px;
-  font-weight: 600;
-  color: var(--text-primary);
+  min-width: 0;
   overflow: hidden;
   text-overflow: ellipsis;
 }
@@ -4697,8 +4716,8 @@ body.booting .boot-splash {
   font-size: 9px;
   padding: 2px 6px;
   border-radius: 3px;
-  margin-left: 6px;
-  vertical-align: middle;
+  margin-left: 2px;
+  flex-shrink: 0;
 }
 .agent-status-row {
   display: flex;
@@ -4728,30 +4747,13 @@ body.booting .boot-splash {
   color: var(--text-primary);
 }
 .agent-status {
-  font-size: 11px;
-  color: var(--text-tertiary);
+  font-size: 10px;
+  color: var(--text-muted);
 }
 .agent-card-model {
-  margin-left: auto;
-  padding: 1px 6px;
-  font-family: var(--font-mono, monospace);
-  font-size: 9.5px;
-  line-height: 1.4;
-  color: var(--text-tertiary);
-  border: 1px solid var(--border);
-  border-radius: 999px;
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  max-width: 45%;
-}
-.agent-message {
-  font-size: 11px;
-  color: var(--text-muted);
-  max-width: 220px;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+  flex-shrink: 0;
+  font-weight: 600;
+  color: var(--text-primary);
 }
 
 .agent-dismiss-btn {

package/server.js

@@ -22,12 +22,14 @@ const {
   readRecentMessages: _readRecentMessagesUncached,
   readMessagesPage: _readMessagesPageUncached,
   readSessionInfoFromJsonl,
+  modelDisplayName,
   buildSessionDigest,
   readCompactSummaries,
   readArtifactLinks,
   readScratchpadCreations,
   extractPromptFromTranscript,
   extractModelFromTranscript,
+  readSubagentMeta,
   extractAgentResultFromTranscript,
   extractTranscriptStats,
   readFullToolResult,
@@ -47,7 +49,8 @@ const { readLiveSessions, isPidAlive, isSessionLive } = require('./lib/live-sess
 const { createProcStats } = require('./lib/proc-stats');
 const { createDispatchRegistry } = require('./lib/dispatch');
 const { createGroupStore, isGroupName, suggestGroupName } = require('./lib/dispatch-groups');
-const { createDispatchedStore, scanTranscripts, pruneSessionDirs, retentionMs } = require('./lib/retention');
+const { createDispatchedStore, scanTranscripts, pruneSessionDirs, pruneContextStatus, retentionMs } = require('./lib/retention');
+const { freshRateLimits } = require('./lib/rate-limits');
 const { createWorktreeStore } = require('./lib/worktrees');
 const { readGitBranch, sessionGitBranch } = require('./lib/git-branch');
 const { createLinkedDocStore, linkUrl } = require('./lib/linked-docs');
@@ -208,7 +211,6 @@ const SESSION_STALE_MS = 5 * 60 * 1000;
 // never the "active" status (which stays accurate via hasRecentLog).
 const SESSION_GRACE_MS = 2 * 60 * 1000;
 const WAITING_RESOLVE_GRACE_MS = 15 * 1000;
-const CTX_CLEANUP_MAX_AGE_MS = 2 * 60 * 60 * 1000;
 const CLEANUP_MAX_AGE_MS = 2 * 24 * 60 * 60 * 1000;
 const CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
 const RETENTION_FIRST_RUN_MS = 5 * 60 * 1000;
@@ -302,11 +304,12 @@ function getContextStatus(sessionId, meta) {
 }
 
 function getContextFields(sessionId, meta) {
-  const contextStatus = getContextStatus(sessionId, meta);
+  // A team dir has no transcript of its own; its lead's transcript has the requests.
+  const m = meta?.teamLeaderId ? sessionMetadataCache[meta.teamLeaderId] : meta;
+  const reply = m?.lastReply;
   return {
-    contextStatus,
-    autoCompact: contextStatus ? getAutoCompact(CLAUDE_DIR, meta?.project) : null,
-    cacheTtl: meta?.cacheTtl || null,
+    contextStatus: getContextStatus(sessionId, meta),
+    cache: reply ? { ttl: m.cacheTtl || null, ...reply, modelName: modelDisplayName(reply.model) } : null,
   };
 }
 
@@ -828,6 +831,7 @@ function refreshSessionMetadataPath(jsonlPath) {
   if (info.compactBoundaryUuid) existing.compactBoundaryUuid = info.compactBoundaryUuid;
   existing.permissionMode = info.permissionMode;
   existing.cacheTtl = info.cacheTtl;
+  existing.lastReply = info.lastReply;
   return true;
 }
 
@@ -916,7 +920,8 @@ function loadSessionMetadata() {
           logicalParentUuid: sessionInfo.logicalParentUuid || null,
           compactBoundaryUuid: sessionInfo.compactBoundaryUuid || null,
           permissionMode: sessionInfo.permissionMode,
-          cacheTtl: sessionInfo.cacheTtl || null
+          cacheTtl: sessionInfo.cacheTtl || null,
+          lastReply: sessionInfo.lastReply || null
         };
         sessionIds.push(sessionId);
       }
@@ -1573,7 +1578,14 @@ app.get('/api/sessions', async (req, res) => {
     }
 
     // Loop info can mean a full read of the transcript, so only the rows sent pay for it.
-    for (const s of sessions) s.loopInfo = getLoopInfoSummary(s);
+    // Same for autoCompact: up to 3 settings stats per call.
+    const autoCompactByProject = new Map();
+    for (const s of sessions) {
+      s.loopInfo = getLoopInfoSummary(s);
+      if (!s.contextStatus) continue;
+      if (!autoCompactByProject.has(s.project)) autoCompactByProject.set(s.project, getAutoCompact(CLAUDE_DIR, s.project));
+      s.autoCompact = autoCompactByProject.get(s.project);
+    }
 
     res.json(withDispatchPlacement(sessions));
     startPrewarm();
@@ -2147,10 +2159,7 @@ app.get('/api/sessions/:sessionId/workflows/:wfId/run', async (req, res) => {
       for (const f of files) {
         const agentId = f.slice('agent-'.length, -'.jsonl'.length);
         const stats = (await extractTranscriptStats(path.join(runDir, f))) || {};
-        let type = null;
-        try {
-          type = JSON.parse(readFileSync(path.join(runDir, `agent-${agentId}.meta.json`), 'utf8')).agentType || null;
-        } catch (_) {}
+        const type = readSubagentMeta(path.join(runDir, f))?.agentType || null;
         const entry = journal.get(agentId);
         const durationMs = stats.firstTs && stats.lastTs ? new Date(stats.lastTs) - new Date(stats.firstTs) : null;
         if (stats.lastTs && (!stoppedAt || stats.lastTs > stoppedAt)) stoppedAt = stats.lastTs;
@@ -2382,6 +2391,8 @@ app.get('/api/teams/:name', (req, res) => {
 // The resultUnavailable latch is persisted on the agent record. Bump this when
 // extractAgentResultFromTranscript finds more, so agents latched earlier rescan once.
 const RESULT_SCAN = 3;
+// Same for the modelUnavailable latch and extractModelFromTranscript.
+const MODEL_SCAN = 2;
 
 app.get('/api/sessions/:sessionId/agents', async (req, res) => {
   const sessionId = resolveSessionId(req.params.sessionId);
@@ -2523,19 +2534,34 @@ app.get('/api/sessions/:sessionId/agents', async (req, res) => {
       }
     }
 
-    // Retry stopped agents even if modelUnavailable was set — it may have been marked
-    // unavailable while the agent was still active and its JSONL wasn't ready yet.
-    const agentsNeedingModel = agents.filter(a => !a.model && (!a.modelUnavailable || a.status === 'stopped'));
+    // The plugin's start record carries the model; this covers sessions without it.
+    const agentsNeedingModel = agents.filter(a => !a.model && a.modelUnavailable !== MODEL_SCAN);
     if (agentsNeedingModel.length && meta.jsonlPath) {
       for (const agent of agentsNeedingModel) {
+        const jsonl = subagentJsonlForExtraction(meta, agent.agentId);
         let model = null;
-        try { model = extractModelFromTranscript(subagentJsonlForExtraction(meta, agent.agentId)); } catch (_) {}
+        try { model = extractModelFromTranscript(jsonl); } catch (_) {}
         if (model) {
           agent.model = model;
           delete agent.modelUnavailable;
+          delete agent.modelAlias;
           dirty.add(agent);
-        } else if (agent.status === 'stopped' && !agent.modelUnavailable) {
-          agent.modelUnavailable = true;
+          continue;
+        }
+        // Until the transcript has an assistant line, show the requested alias.
+        // agent.model stays empty so the exact id is still looked up.
+        if (!agent.modelAlias) {
+          let alias = readSubagentMeta(jsonl)?.model || null;
+          if (alias === 'inherit') {
+            try { alias = extractModelFromTranscript(meta.jsonlPath); } catch (_) { alias = null; }
+          }
+          if (alias) {
+            agent.modelAlias = alias;
+            dirty.add(agent);
+          }
+        }
+        if (agent.status === 'stopped') {
+          agent.modelUnavailable = MODEL_SCAN;
           dirty.add(agent);
         }
       }
@@ -4063,6 +4089,10 @@ app.get('/api/context-status', (_req, res) => {
   res.json(Object.fromEntries(contextStatusCache));
 });
 
+app.get('/api/rate-limits', (_req, res) => {
+  res.json(freshRateLimits(contextStatusCache.values(), Date.now() / 1000));
+});
+
 app.use('/api', (_req, res) => {
   res.status(404).json({ error: 'Not found' });
 });
@@ -4246,47 +4276,35 @@ agentActivityWatcher.on('all', (event, filePath) => {
 const contextStatusWatcher = chokidar.watch(CONTEXT_STATUS_DIR, {
   persistent: true,
   ignoreInitial: false,
+  alwaysStat: true,
   depth: 0
 });
 
-contextStatusWatcher.on('all', (event, filePath) => {
+// The initial scan adds one event per kept file (up to MAX_CONTEXT_STATUS), so it broadcasts once at the end.
+let contextStatusReady = false;
+contextStatusWatcher.on('ready', () => {
+  contextStatusReady = true;
+  broadcast({ type: 'context-update', sessionId: null });
+});
+
+contextStatusWatcher.on('all', (event, filePath, stats) => {
   if (!filePath.endsWith('.json')) return;
   const sessionId = path.basename(filePath, '.json');
   if (event === 'add' || event === 'change') {
     try {
       const data = JSON.parse(readFileSync(filePath, 'utf8'));
-      try { data._updatedAt = statSync(filePath).mtimeMs; } catch (_) { data._updatedAt = Date.now(); }
+      data._updatedAt = stats?.mtimeMs ?? Date.now();
       contextStatusCache.set(sessionId, data);
-      evictStaleCache(contextStatusCache);
     } catch { /* ignore malformed */ }
-    broadcast({ type: 'context-update', sessionId });
   } else if (event === 'unlink') {
     contextStatusCache.delete(sessionId);
-    broadcast({ type: 'context-update', sessionId });
-  }
+  } else return;
+  if (contextStatusReady) broadcast({ type: 'context-update', sessionId });
 });
 
 // #endregion
 
 // #region CLEANUP
-async function cleanupContextStatus() {
-  try {
-    const entries = await fs.readdir(CONTEXT_STATUS_DIR);
-    const now = Date.now();
-    for (const f of entries) {
-      if (!f.endsWith('.json')) continue;
-      try {
-        const fp = path.join(CONTEXT_STATUS_DIR, f);
-        const st = statSync(fp);
-        if (now - st.mtimeMs > CTX_CLEANUP_MAX_AGE_MS) {
-          await fs.unlink(fp);
-          contextStatusCache.delete(path.basename(f, '.json'));
-        }
-      } catch { /* ignore */ }
-    }
-  } catch { /* dir may not exist */ }
-}
-
 async function cleanupAgentActivity() {
   try {
     const entries = await fs.readdir(AGENT_ACTIVITY_DIR, { withFileTypes: true });
@@ -4317,16 +4335,17 @@ async function cleanupAgentActivity() {
   } catch { /* agent-activity dir may not exist */ }
 }
 
-// Dispatch markers, reviews and worktrees: see docs/retention.md.
+// Dispatch markers, reviews, context status and worktrees: see docs/retention.md.
 async function runRetention() {
   try {
     const scan = await scanTranscripts(PROJECTS_DIR);
     const opts = { known: scan?.ids, maxAgeMs: retentionMs(CLAUDE_DIR) };
     const markers = dispatched.prune(opts);
     const reviews = await pruneSessionDirs(REVIEW_DIR, opts);
+    const contexts = await pruneContextStatus(CONTEXT_STATUS_DIR, opts);
     const wts = worktrees.prune(scan?.dirs);
-    if (markers || reviews || wts) {
-      console.log(`[retention] removed ${markers} dispatch markers, ${reviews} reviews, ${wts} worktrees`);
+    if (markers || reviews || contexts || wts) {
+      console.log(`[retention] removed ${markers} dispatch markers, ${reviews} reviews, ${contexts} context status files, ${wts} worktrees`);
     }
   } catch (e) {
     console.warn('[retention] failed:', e.message);
@@ -4334,9 +4353,7 @@ async function runRetention() {
 }
 
 cleanupAgentActivity();
-cleanupContextStatus();
 setInterval(cleanupAgentActivity, CLEANUP_INTERVAL_MS);
-setInterval(cleanupContextStatus, 30 * 60 * 1000);
 // Later than the startup scan and prewarm, so the first sweep never competes with them.
 setTimeout(() => {
   runRetention();