claude-code-kanban 4.3.0 → 4.5.0

package/server.js

@@ -3,7 +3,7 @@
 const express = require('express');
 const path = require('path');
 const fs = require('fs').promises;
-const { existsSync, readdirSync, readFileSync, writeFileSync, statSync, createReadStream, unlinkSync, mkdirSync, renameSync } = require('fs');
+const { existsSync, readdirSync, readFileSync, writeFileSync, statSync, createReadStream, unlinkSync, mkdirSync, renameSync, openSync, readSync, closeSync } = require('fs');
 const readline = require('readline');
 const chokidar = require('chokidar');
 const os = require('os');
@@ -159,6 +159,10 @@ function isAgentFresh(agent) {
   return (Date.now() - new Date(ts).getTime()) < AGENT_TTL_MS;
 }
 
+function isAgentLive(agent) {
+  return agent.status === 'active' || agent.status === 'idle';
+}
+
 // Claude Code records gitBranch from the launch-time repo and never updates it
 // when cwd shifts (Bash `cd`, submodule, sibling repo). Resolve on-demand from
 // the live cwd instead. Cached per-cwd with a short TTL so a list refresh
@@ -216,7 +220,7 @@ function checkAgentStatus(agentDir, stale, logMtime, isTeam) {
     for (const file of readdirSync(agentDir).filter(f => f.endsWith('.jsonl') && !f.startsWith('_'))) {
       try {
         const agent = readAgentJsonl(path.join(agentDir, file));
-        if (isTeam && (agent.status === 'active' || agent.status === 'idle')) {
+        if (isTeam && isAgentLive(agent)) {
           result.hasActive = true;
           if (agent.status === 'active') result.hasRunning = true;
         } else if (isAgentFresh(agent)) {
@@ -456,6 +460,9 @@ function refreshSessionMetadataPath(jsonlPath) {
   if (info.cwd) existing.cwd = info.cwd;
   if (info.gitBranch) existing.gitBranch = info.gitBranch;
   if (info.customTitle) existing.customTitle = info.customTitle;
+  // Direct assign (not guarded) so a /goal clear propagates as null.
+  existing.goal = info.goal || null;
+  if (info.logicalParentUuid) existing.logicalParentUuid = info.logicalParentUuid;
   return true;
 }
 
@@ -540,7 +547,9 @@ function loadSessionMetadata() {
           cwd: sessionInfo.cwd || null,
           gitBranch: sessionInfo.gitBranch || null,
           customTitle: sessionInfo.customTitle || null,
-          jsonlPath: jsonlPath
+          goal: sessionInfo.goal || null,
+          jsonlPath: jsonlPath,
+          logicalParentUuid: sessionInfo.logicalParentUuid || null
         };
         sessionIds.push(sessionId);
       }
@@ -688,6 +697,7 @@ function buildSessionObject(id, meta, overrides = {}) {
     description: meta.description || null,
     gitBranch: resolveSessionGitBranch(meta),
     customTitle: meta.customTitle || null,
+    goal: meta.goal || null,
     taskCount: 0,
     completed: 0,
     inProgress: 0,
@@ -727,6 +737,7 @@ app.get('/api/sessions', async (req, res) => {
 
     const pinnedParam = req.query.pinned;
     const pinnedIds = pinnedParam ? new Set(pinnedParam.split(',').filter(Boolean)) : new Set();
+    const activeFilter = req.query.filter === 'active';
 
     const metadata = loadSessionMetadata();
     const sessionsMap = new Map();
@@ -749,6 +760,24 @@ app.get('/api/sessions', async (req, res) => {
           const logAge = logMtime ? Date.now() - logMtime : Infinity;
           const stale = logAge > AGENT_STALE_MS;
 
+          const isTeam = isTeamSession(entry.name);
+          const teamConfig = isTeam ? loadTeamConfig(entry.name) : null;
+          const resolvedAgentDir = path.join(AGENT_ACTIVITY_DIR, teamConfig?.leadSessionId || entry.name);
+          const agentStatus = checkAgentStatus(resolvedAgentDir, stale, logMtime, isTeam);
+
+          // Cheap-probe: when filter=active, skip expensive enrichment for inactive non-pinned sessions.
+          // Mirrors the post-filter predicate using only signals already computed above.
+          if (activeFilter && !pinnedIds.has(entry.name)) {
+            const hasRecentLog = logAge <= SESSION_STALE_MS;
+            const cheaplyActive = logStat.hasMessages && (
+              hasRecentLog
+              || agentStatus.hasActive
+              || !!agentStatus.waitingForUser
+              || (pending > 0 || inProgress > 0)
+            );
+            if (!cheaplyActive) continue;
+          }
+
           // Use newest of: task file mtime, JSONL mtime, directory mtime
           let modifiedAt = newestTaskMtime ? newestTaskMtime.toISOString() : stat.mtime.toISOString();
           if (logMtime) {
@@ -756,17 +785,9 @@ app.get('/api/sessions', async (req, res) => {
             if (jsonlMtime > modifiedAt) modifiedAt = jsonlMtime;
           }
 
-          const isTeam = isTeamSession(entry.name);
-          const teamConfig = isTeam ? loadTeamConfig(entry.name) : null;
           const memberCount = teamConfig?.members?.length || 0;
           const planInfo = getPlanInfo(meta.slug);
 
-          const resolvedAgentDir = (() => {
-            const rid = teamConfig?.leadSessionId || entry.name;
-            return path.join(AGENT_ACTIVITY_DIR, rid);
-          })();
-          const agentStatus = checkAgentStatus(resolvedAgentDir, stale, logMtime, isTeam);
-
           sessionsMap.set(entry.name, buildSessionObject(entry.name, meta, {
             _logStat: logStat,
             taskCount,
@@ -842,14 +863,24 @@ app.get('/api/sessions', async (req, res) => {
         const logMtime = logStat.mtime;
         const logAge = logMtime ? Date.now() - logMtime : Infinity;
         const stale = logAge > AGENT_STALE_MS;
+        const metaIsTeam = isTeamSession(sessionId);
+        const metaAgentDir = path.join(AGENT_ACTIVITY_DIR, sessionId);
+        const metaAgentStatus = checkAgentStatus(metaAgentDir, stale, logMtime, metaIsTeam);
+
+        // Cheap-probe: no tasks here (metadata-only), so active = recent log OR live agent.
+        if (activeFilter && !pinnedIds.has(sessionId)) {
+          const hasRecentLog = logAge <= SESSION_STALE_MS;
+          const cheaplyActive = logStat.hasMessages && (
+            hasRecentLog || metaAgentStatus.hasActive || !!metaAgentStatus.waitingForUser
+          );
+          if (!cheaplyActive) continue;
+        }
+
         let modifiedAt = meta.created || null;
         if (logMtime) {
           const jsonlMtime = new Date(logMtime).toISOString();
           if (!modifiedAt || jsonlMtime > modifiedAt) modifiedAt = jsonlMtime;
         }
-        const metaIsTeam = isTeamSession(sessionId);
-        const metaAgentDir = path.join(AGENT_ACTIVITY_DIR, sessionId);
-        const metaAgentStatus = checkAgentStatus(metaAgentDir, stale, logMtime, metaIsTeam);
         sessionsMap.set(sessionId, buildSessionObject(sessionId, meta, {
           _logStat: logStat,
           modifiedAt: modifiedAt || new Date(0).toISOString(),
@@ -898,16 +929,21 @@ app.get('/api/sessions', async (req, res) => {
             existing.memberCount = cfg.members?.length || 0;
             existing.name = existing.name || cfg.name || dir.name;
             teamLeaderIds.add(leaderId);
-            // Attach team-named task directory if present
+            // Attach team-named task directory if present.
+            // Prefer team task dir over an empty session-UUID task dir — when a team session has
+            // both a UUID-named dir (often empty: just .lock/.highwatermark) and a team-named dir
+            // holding the real tasks, the leader card otherwise shows 0/0.
             const teamTaskDir = path.join(TASKS_DIR, dir.name);
-            if (!existing.tasksDir && existsSync(teamTaskDir)) {
+            if (existsSync(teamTaskDir)) {
               const counts = getTaskCounts(teamTaskDir);
-              existing.taskCount = counts.taskCount;
-              existing.completed = counts.completed;
-              existing.inProgress = counts.inProgress;
-              existing.pending = counts.pending;
-              existing.tasksDir = teamTaskDir;
-              existing.sharedTaskList = dir.name;
+              if (!existing.tasksDir || counts.taskCount > (existing.taskCount || 0)) {
+                existing.taskCount = counts.taskCount;
+                existing.completed = counts.completed;
+                existing.inProgress = counts.inProgress;
+                existing.pending = counts.pending;
+                existing.tasksDir = teamTaskDir;
+                existing.sharedTaskList = dir.name;
+              }
             }
             // Re-check agent status with isTeam=true
             const agentDir = path.join(AGENT_ACTIVITY_DIR, leaderId);
@@ -933,14 +969,28 @@ app.get('/api/sessions', async (req, res) => {
       if (group.length < 2) continue;
       group.sort((a, b) => new Date(a.modifiedAt) - new Date(b.modifiedAt));
       const planSession = group.find(s => s.hasPlan);
-      const implSession = group.find(s => s !== planSession && new Date(s.modifiedAt) >= new Date(planSession?.modifiedAt || 0));
-      if (planSession && implSession) {
+      const linkedSession = group.find(s => s !== planSession && !s.hasPlan && new Date(s.modifiedAt) >= new Date(planSession?.modifiedAt || 0));
+      if (planSession && linkedSession) {
         planSession.hasWaitingForUser = false;
-        planSession.planImplementationSessionId = implSession.id;
-        implSession.planSourceSessionId = planSession.id;
+        planSession.planImplementationSessionId = linkedSession.id;
+        linkedSession.planSourceSessionId = planSession.id;
       }
     }
 
+    // Suppress parent sessions that have a compact continuation — compaction is involuntary
+    // (context limit hit), not an intentional fork. Only the continuation is shown.
+    const compactSuppressed = new Set();
+    for (const [sid] of sessionsMap) {
+      const compactAnchor = metadata[sid]?.logicalParentUuid;
+      if (!compactAnchor) continue;
+      const parent = lookupParentSession(sid);
+      if (parent.parentSessionId && sessionsMap.has(parent.parentSessionId)) {
+        compactSuppressed.add(parent.parentSessionId);
+        sessionsMap.get(sid).continuedFromSessionId = parent.parentSessionId;
+      }
+    }
+    for (const sid of compactSuppressed) sessionsMap.delete(sid);
+
     // Backfill contextStatus for already-built sessions that are pinned
     for (const pid of pinnedIds) {
       const s = sessionsMap.get(pid);
@@ -968,6 +1018,22 @@ app.get('/api/sessions', async (req, res) => {
       }));
     }
 
+    // Server-side activity filter (mirrors the client predicate in public/app.js).
+    // Pinned IDs bypass — they should always be in the response.
+    if (activeFilter) {
+      const isActive = (s) =>
+        s.hasMessages && (
+          (!s.sharedTaskList && (s.pending > 0 || s.inProgress > 0))
+          || s.hasActiveAgents
+          || s.hasWaitingForUser
+          || s.hasRecentLog
+        );
+      for (const [id, s] of sessionsMap) {
+        if (pinnedIds.has(id)) continue;
+        if (!isActive(s)) sessionsMap.delete(id);
+      }
+    }
+
     // Convert map to array and sort by most recently modified
     let sessions = Array.from(sessionsMap.values());
     sessions.sort((a, b) => new Date(b.modifiedAt) - new Date(a.modifiedAt));
@@ -1226,7 +1292,7 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
         const agentTs = agent.updatedAt || agent.startedAt;
         const agentStale = !sessionStale && agentTs && (Date.now() - new Date(agentTs).getTime()) > AGENT_STALE_MS;
         if (!isAgentFresh(agent) || sessionStale || agentStale) {
-          if (agent.status === 'active' || agent.status === 'idle') {
+          if (isAgentLive(agent)) {
             const agentName = agentDisplayName(agent);
             const isTeamMember = isTeam && agentName && teamMemberNames.has(agentName);
             if (!isTeamMember) {
@@ -1238,7 +1304,7 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
         agents.push(agent);
       } catch (e) { /* skip invalid */ }
     }
-    const liveAgents = agents.filter(a => a.status === 'active' || a.status === 'idle');
+    const liveAgents = agents.filter(isAgentLive);
     if (liveAgents.length && meta.jsonlPath) {
       try {
         const terminated = getTerminatedTeammates(meta.jsonlPath);
@@ -1264,7 +1330,7 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
           getSessionDigest(meta.jsonlPath);
         if (rejectedAgentIds.size || rejectedPrompts.size || killedAgentIds.size) {
           for (const agent of liveAgents) {
-            if (agent.status !== 'active' && agent.status !== 'idle') continue;
+            if (!isAgentLive(agent)) continue;
             let reason = null;
             if (killedAgentIds.has(agent.agentId)) reason = 'killed-by-harness';
             else if (rejectedAgentIds.has(agent.agentId) || (agent.prompt && rejectedPrompts.has(agent.prompt))) {
@@ -1282,13 +1348,16 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
 
     const dirty = new Set();
 
-    const agentsNeedingPrompt = agents.filter(a => !a.prompt && !a.promptUnavailable);
-    const agentsNeedingName = agents.filter(a => !a.agentName && !a.agentNameUnavailable);
-    const agentsNeedingDesc = agents.filter(a => !a.description && !a.descriptionUnavailable);
-    if ((agentsNeedingPrompt.length || agentsNeedingName.length || agentsNeedingDesc.length) && meta.jsonlPath) {
-      let byAgentId = {};
-      let nameByAgentId = {};
-      let descByAgentId = {};
+    // Agents may be missing prompt/name/description because the parent's agent_progress
+    // event or the subagent's own transcript hadn't been written yet at last poll. While
+    // the agent is still active, keep retrying instead of latching *Unavailable permanently
+    // (same pattern as agentsNeedingModel below). Each field shares the same resolve flow:
+    // look up in progressMap by agentId, fall back to per-field extractor, persist only
+    // on actual change.
+    const byAgentId = {};
+    const nameByAgentId = {};
+    const descByAgentId = {};
+    if (meta.jsonlPath) {
       try {
         const progressMap = getProgressMap(meta.jsonlPath);
         for (const entry of Object.values(progressMap)) {
@@ -1297,33 +1366,52 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
           if (entry.description && !descByAgentId[entry.agentId]) descByAgentId[entry.agentId] = entry.description;
         }
       } catch (_) {}
-      for (const agent of agentsNeedingPrompt) {
-        const prompt = byAgentId[agent.agentId]
-          || (() => { try { return extractPromptFromTranscript(subagentJsonlPath(meta, agent.agentId)); } catch (_) { return null; } })();
-        if (prompt) agent.prompt = prompt;
-        else agent.promptUnavailable = true;
-        dirty.add(agent);
-      }
-      for (const agent of agentsNeedingName) {
-        if (nameByAgentId[agent.agentId]) agent.agentName = nameByAgentId[agent.agentId];
-        else agent.agentNameUnavailable = true;
-        dirty.add(agent);
-      }
-      for (const agent of agentsNeedingDesc) {
-        if (descByAgentId[agent.agentId]) agent.description = descByAgentId[agent.agentId];
-        else agent.descriptionUnavailable = true;
-        dirty.add(agent);
+    }
+    const reconcileFields = [
+      {
+        field: 'prompt',
+        flag: 'promptUnavailable',
+        lookup: (a) => {
+          if (byAgentId[a.agentId]) return byAgentId[a.agentId];
+          try { return extractPromptFromTranscript(subagentJsonlPath(meta, a.agentId)); } catch (_) { return null; }
+        },
+      },
+      { field: 'agentName',   flag: 'agentNameUnavailable',   lookup: (a) => nameByAgentId[a.agentId] || null },
+      { field: 'description', flag: 'descriptionUnavailable', lookup: (a) => descByAgentId[a.agentId] || null },
+    ];
+    if (meta.jsonlPath) {
+      for (const { field, flag, lookup } of reconcileFields) {
+        for (const agent of agents) {
+          if (agent[field]) continue;
+          if (agent[flag] && !isAgentLive(agent)) continue;
+          const value = lookup(agent);
+          if (value) {
+            agent[field] = value;
+            delete agent[flag];
+            dirty.add(agent);
+          } else if (!isAgentLive(agent) && !agent[flag]) {
+            agent[flag] = true;
+            dirty.add(agent);
+          }
+        }
       }
     }
 
-    const agentsNeedingModel = agents.filter(a => !a.model && !a.modelUnavailable);
+    // 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'));
     if (agentsNeedingModel.length && meta.jsonlPath) {
       for (const agent of agentsNeedingModel) {
         let model = null;
         try { model = extractModelFromTranscript(subagentJsonlPath(meta, agent.agentId)); } catch (_) {}
-        if (model) agent.model = model;
-        else agent.modelUnavailable = true;
-        dirty.add(agent);
+        if (model) {
+          agent.model = model;
+          delete agent.modelUnavailable;
+          dirty.add(agent);
+        } else if (agent.status === 'stopped' && !agent.modelUnavailable) {
+          agent.modelUnavailable = true;
+          dirty.add(agent);
+        }
       }
     }
 
@@ -1462,41 +1550,61 @@ function resolveSubagentJsonl(meta, sessionId, agentId) {
   return found || primary;
 }
 
-// Claude Code marks fork lineage in two ways:
-//   1. `logicalParentUuid` on a system record (when present) points to a uuid
-//      in the parent session's JSONL.
-//   2. When absent, the fork copies the parent's early records verbatim, so
-//      the earliest `uuid` in this session also exists (same uuid+timestamp)
-//      in the parent's JSONL.
-// We try (1) first, then fall back to (2).
+// Claude Code creates child sessions in two ways:
+//   Fork: copies the parent's early messages verbatim (same UUIDs). Anchor = first UUID.
+//   Compact: writes a compact_boundary record with logicalParentUuid in the preamble.
+// Birthtime (not mtime) identifies the parent — mtime changes on resume, birthtime is immutable.
 const parentSessionCache = new Map();
-// Both anchor signals live in the first few records (system marker on top,
-// fork-copy starts at line 0), so cap the scan instead of reading the whole file.
 const FORK_ANCHOR_SCAN_LINES = 10;
 function findForkAnchorUuid(jsonlPath) {
   let text;
   try { text = readFileSync(jsonlPath, 'utf8'); } catch { return null; }
-  let firstUuid = null;
-  let scanned = 0;
+  let firstUuid = null, scanned = 0;
   for (const l of text.split('\n')) {
     if (!l) continue;
     if (scanned++ >= FORK_ANCHOR_SCAN_LINES) break;
-    try {
-      const d = JSON.parse(l);
-      if (d.logicalParentUuid) return d.logicalParentUuid;
-      if (!firstUuid && d.uuid) firstUuid = d.uuid;
-    } catch { /* skip malformed */ }
+    try { const d = JSON.parse(l); if (!firstUuid && d.uuid) firstUuid = d.uuid; } catch { /* skip malformed */ }
   }
   return firstUuid;
 }
-function findSessionContainingUuid(projectDir, targetUuid, excludeJsonlPath) {
+// Fallback when metadata cache lacks logicalParentUuid (older entries, cold cache).
+// Hot path reads from metadata directly; this never runs from the suppression loop.
+// Bounded read (~1 MB) mirrors readSessionInfoFromJsonl's HEAD_MAX — compact_boundary
+// always sits in the preamble before the first user/assistant record.
+const COMPACT_ANCHOR_READ_MAX = 1048576;
+function findCompactAnchorUuid(jsonlPath) {
+  let fd;
+  try {
+    fd = openSync(jsonlPath, 'r');
+    const buf = Buffer.alloc(COMPACT_ANCHOR_READ_MAX);
+    const n = readSync(fd, buf, 0, COMPACT_ANCHOR_READ_MAX, 0);
+    const text = buf.toString('utf8', 0, n);
+    const lastNl = text.lastIndexOf('\n');
+    const complete = lastNl >= 0 ? text.slice(0, lastNl) : text;
+    for (const l of complete.split('\n')) {
+      if (!l) continue;
+      try {
+        const d = JSON.parse(l);
+        if (d.type === 'user' || d.type === 'assistant') return null;
+        if (d.subtype === 'compact_boundary' && d.logicalParentUuid) return d.logicalParentUuid;
+      } catch { /* skip malformed */ }
+    }
+    return null;
+  } catch { return null; }
+  finally { if (fd !== undefined) { try { closeSync(fd); } catch {} } }
+}
+function findSessionContainingUuid(projectDir, targetUuid, excludeJsonlPath, maxBirthtimeMs) {
   let files;
   try { files = readdirSync(projectDir); } catch { return null; }
-  const candidates = [];
+  let best = null;
   for (const f of files) {
     if (!f.endsWith('.jsonl')) continue;
     const fp = path.join(projectDir, f);
     if (fp === excludeJsonlPath) continue;
+    let birthtime = 0;
+    try { birthtime = statSync(fp).birthtimeMs; } catch { continue; }
+    if (maxBirthtimeMs != null && birthtime >= maxBirthtimeMs) continue;
+    if (best && birthtime >= best.birthtime) continue;
     let text;
     try { text = readFileSync(fp, 'utf8'); } catch { continue; }
     if (!text.includes(targetUuid)) continue;
@@ -1505,31 +1613,33 @@ function findSessionContainingUuid(projectDir, targetUuid, excludeJsonlPath) {
       try {
         const d = JSON.parse(l);
         if (d.uuid === targetUuid && d.sessionId) {
-          let mtime = 0;
-          try { mtime = statSync(fp).mtimeMs; } catch { /* ignore */ }
-          candidates.push({ parentSessionId: d.sessionId, parentJsonlPath: fp, mtime });
+          best = { parentSessionId: d.sessionId, parentJsonlPath: fp, birthtime };
           break;
         }
       } catch { /* skip */ }
     }
   }
-  if (!candidates.length) return null;
-  candidates.sort((a, b) => a.mtime - b.mtime);
-  const { parentSessionId, parentJsonlPath } = candidates[0];
-  return { parentSessionId, parentJsonlPath };
+  if (!best) return null;
+  return { parentSessionId: best.parentSessionId, parentJsonlPath: best.parentJsonlPath };
 }
 function lookupParentSession(sessionId) {
   if (parentSessionCache.has(sessionId)) return parentSessionCache.get(sessionId);
   const meta = loadSessionMetadata()[sessionId];
-  const result = { parentSessionId: null, parentJsonlPath: null };
+  const result = { parentSessionId: null, parentJsonlPath: null, isCompact: false };
   if (meta?.jsonlPath) {
-    const anchorUuid = findForkAnchorUuid(meta.jsonlPath);
+    const compactAnchor = meta.logicalParentUuid || findCompactAnchorUuid(meta.jsonlPath);
+    result.isCompact = !!compactAnchor;
+    const anchorUuid = compactAnchor ?? findForkAnchorUuid(meta.jsonlPath);
     if (anchorUuid) {
-      const hit = findSessionContainingUuid(path.dirname(meta.jsonlPath), anchorUuid, meta.jsonlPath);
-      if (hit) Object.assign(result, hit);
+      let selfBirthtime;
+      try { selfBirthtime = statSync(meta.jsonlPath).birthtimeMs; } catch { /* ignore */ }
+      if (selfBirthtime != null) {
+        const hit = findSessionContainingUuid(path.dirname(meta.jsonlPath), anchorUuid, meta.jsonlPath, selfBirthtime);
+        if (hit) Object.assign(result, hit);
+      }
     }
   }
-  if (result.parentSessionId) parentSessionCache.set(sessionId, result);
+  parentSessionCache.set(sessionId, result);
   return result;
 }
 app.get('/api/sessions/:sessionId/parent', (req, res) => {
@@ -1678,6 +1788,117 @@ app.get('/api/sessions/:sessionId/tool-result/:toolUseId', (req, res) => {
   res.json({ toolUseId: req.params.toolUseId, content });
 });
 
+const toolStatsCache = new Map();
+
+function buildToolStats(jsonlPath) {
+  const toolUseById = {};     // tool_use_id -> { displayName, isSkill }
+  const seenResults = new Set();
+  const toolMap = {};         // displayName -> { count, success, failed, outputBytes }
+  const skillPromptIds = {};  // promptId -> [skillDisplayName, ...]
+  const promptOutputBytes = {}; // promptId -> total outputBytes in that turn
+
+  const content = readFileSync(jsonlPath, 'utf8');
+  for (const line of content.split('\n')) {
+    if (!line) continue;
+    let obj;
+    try { obj = JSON.parse(line); } catch (_) { continue; }
+
+    if (obj.type === 'assistant' && Array.isArray(obj.message?.content)) {
+      for (const block of obj.message.content) {
+        if (block.type === 'tool_use' && block.name && block.id) {
+          const isSkill = block.name === 'Skill';
+          const displayName = isSkill && block.input?.skill
+            ? `Skill(${block.input.skill})`
+            : block.name === 'Agent' && block.input?.subagent_type
+            ? `Agent(${block.input.subagent_type})`
+            : block.name;
+          toolUseById[block.id] = { displayName, isSkill };
+        }
+      }
+    } else if (obj.type === 'user' && Array.isArray(obj.message?.content)) {
+      const promptId = obj.promptId;
+      for (const block of obj.message.content) {
+        if (block.type !== 'tool_result' || !block.tool_use_id) continue;
+        const entry = toolUseById[block.tool_use_id];
+        if (!entry) continue;
+        const { displayName, isSkill } = entry;
+        seenResults.add(block.tool_use_id);
+        if (!toolMap[displayName]) toolMap[displayName] = { count: 0, success: 0, failed: 0, rejected: 0, outputBytes: 0 };
+        toolMap[displayName].count++;
+        const raw = typeof block.content === 'string' ? block.content
+          : Array.isArray(block.content) ? block.content.map(b => b.text || '').join('\n') : '';
+        const bytes = raw.length;
+        toolMap[displayName].outputBytes += bytes;
+        if (promptId) {
+          promptOutputBytes[promptId] = (promptOutputBytes[promptId] || 0) + bytes;
+          if (isSkill) {
+            if (!skillPromptIds[promptId]) skillPromptIds[promptId] = [];
+            skillPromptIds[promptId].push(displayName);
+          }
+        }
+        const isRejected = typeof obj.toolUseResult === 'string' && /rejected/i.test(obj.toolUseResult);
+        if (isRejected) toolMap[displayName].rejected++;
+        else {
+          const lower = raw.toLowerCase();
+          const failed = /^error/i.test(raw.trimStart())
+            || /exit code [1-9]/.test(lower)
+            || lower.includes('command failed')
+            || (lower.includes('failed') && lower.includes('error'));
+          if (failed) toolMap[displayName].failed++;
+          else toolMap[displayName].success++;
+        }
+      }
+    }
+  }
+
+  // Count tool_use blocks that never got a tool_result
+  for (const [id, { displayName }] of Object.entries(toolUseById)) {
+    if (seenResults.has(id)) continue;
+    if (!toolMap[displayName]) toolMap[displayName] = { count: 0, success: 0, failed: 0, rejected: 0, outputBytes: 0 };
+    toolMap[displayName].count++;
+  }
+
+  // Approximate Skill impact: replace tiny dispatch bytes with the full turn's output
+  for (const [promptId, skillNames] of Object.entries(skillPromptIds)) {
+    const turnBytes = promptOutputBytes[promptId] || 0;
+    for (const name of skillNames) {
+      if (toolMap[name]) toolMap[name].outputBytes = turnBytes;
+    }
+  }
+
+  let totalCalls = 0, totalFailed = 0, totalRejected = 0, totalOutputBytes = 0;
+  for (const s of Object.values(toolMap)) {
+    totalCalls += s.count;
+    totalFailed += s.failed;
+    totalRejected += s.rejected;
+    totalOutputBytes += s.outputBytes || 0;
+  }
+  const uniqueTools = Object.keys(toolMap).length;
+
+  const tools = [];
+  for (const [name, stats] of Object.entries(toolMap)) {
+    const impact = totalOutputBytes > 0 ? Math.round((stats.outputBytes || 0) / totalOutputBytes * 100) : 0;
+    const displayName = name.startsWith('mcp__') ? name.split('__').slice(2).join('__') || name : name;
+    tools.push({ name: displayName, count: stats.count, success: stats.success, failed: stats.failed, rejected: stats.rejected, impact });
+  }
+
+  return { totalCalls, uniqueTools, totalFailed, totalRejected, tools };
+}
+
+app.get('/api/sessions/:sessionId/tool-stats', (req, res) => {
+  const metadata = loadSessionMetadata();
+  const meta = metadata[req.params.sessionId];
+  const jsonlPath = meta?.jsonlPath;
+  if (!jsonlPath) return res.status(404).json({ error: 'session not found' });
+  try {
+    const data = cachedByMtime(toolStatsCache, jsonlPath, jsonlPath, () => buildToolStats(jsonlPath), null);
+    if (!data) return res.status(404).json({ error: 'could not parse session' });
+    res.json({ sessionId: req.params.sessionId, ...data });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
 app.get('/api/sessions/:sessionId/user-image/:msgUuid/:blockIndex', (req, res) => {
   const metadata = loadSessionMetadata();
   const meta = metadata[req.params.sessionId];
@@ -2251,13 +2472,38 @@ cleanupContextStatus();
 setInterval(cleanupAgentActivity, CLEANUP_INTERVAL_MS);
 setInterval(cleanupContextStatus, 30 * 60 * 1000);
 
-const server = app.listen(PORT, () => {
+// Warm the metadata + loop-info caches in the background so the first user
+// request lands warm. The cheap-probe in /api/sessions skips per-session
+// enrichment for inactive sessions, so we no longer drive a full self-request
+// here — that was 690× wasted work for an active-filter first hit.
+// Yields to the event loop periodically so any inbound request isn't starved.
+async function prewarmCaches() {
+  const t0 = Date.now();
+  try {
+    const metadata = loadSessionMetadata();
+
+    let i = 0;
+    for (const meta of Object.values(metadata)) {
+      if (meta?.jsonlPath) {
+        try { refreshLoopInfoState(meta.jsonlPath); } catch {}
+      }
+      if (++i % 50 === 0) await new Promise(r => setImmediate(r));
+    }
+
+    console.log(`[prewarm] done in ${Date.now() - t0}ms (${Object.keys(metadata).length} sessions)`);
+  } catch (e) {
+    console.warn('[prewarm] failed:', e.message);
+  }
+}
+
+  const server = app.listen(PORT, () => {
     const actualPort = server.address().port;
     console.log(`Claude Task Kanban running at http://localhost:${actualPort}`);
 
     if (process.argv.includes('--open')) {
       import('open').then(open => open.default(`http://localhost:${actualPort}`));
     }
+    setImmediate(prewarmCaches);
   });
 
   server.on('error', (err) => {
@@ -2270,6 +2516,7 @@ const server = app.listen(PORT, () => {
         if (process.argv.includes('--open')) {
           import('open').then(open => open.default(`http://localhost:${actualPort}`));
         }
+        setImmediate(prewarmCaches);
       });
     } else {
       throw err;