claude-code-kanban 4.4.0 → 4.6.0

package/server.js

@@ -22,6 +22,7 @@ const {
   extractModelFromTranscript,
   readFullToolResult,
   readUserImage,
+  readCachedImage,
   updateLoopInfo,
   buildLoopInfoFromState
 } = require('./lib/parsers');
@@ -159,6 +160,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 +221,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 +461,8 @@ 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;
 }
@@ -541,6 +548,7 @@ function loadSessionMetadata() {
           cwd: sessionInfo.cwd || null,
           gitBranch: sessionInfo.gitBranch || null,
           customTitle: sessionInfo.customTitle || null,
+          goal: sessionInfo.goal || null,
           jsonlPath: jsonlPath,
           logicalParentUuid: sessionInfo.logicalParentUuid || null
         };
@@ -690,6 +698,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,
@@ -729,6 +738,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();
@@ -751,6 +761,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) {
@@ -758,17 +786,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,
@@ -844,14 +864,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(),
@@ -900,16 +930,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);
@@ -984,6 +1019,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));
@@ -1242,7 +1293,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) {
@@ -1254,7 +1305,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);
@@ -1280,7 +1331,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))) {
@@ -1298,13 +1349,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)) {
@@ -1313,22 +1367,34 @@ 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);
+          }
+        }
       }
     }
 
@@ -1758,7 +1824,7 @@ function buildToolStats(jsonlPath) {
         if (!entry) continue;
         const { displayName, isSkill } = entry;
         seenResults.add(block.tool_use_id);
-        if (!toolMap[displayName]) toolMap[displayName] = { count: 0, success: 0, failed: 0, outputBytes: 0 };
+        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') : '';
@@ -1771,13 +1837,17 @@ function buildToolStats(jsonlPath) {
             skillPromptIds[promptId].push(displayName);
           }
         }
-        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++;
+        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++;
+        }
       }
     }
   }
@@ -1785,7 +1855,7 @@ function buildToolStats(jsonlPath) {
   // 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, outputBytes: 0 };
+    if (!toolMap[displayName]) toolMap[displayName] = { count: 0, success: 0, failed: 0, rejected: 0, outputBytes: 0 };
     toolMap[displayName].count++;
   }
 
@@ -1797,10 +1867,11 @@ function buildToolStats(jsonlPath) {
     }
   }
 
-  let totalCalls = 0, totalFailed = 0, totalOutputBytes = 0;
+  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;
@@ -1809,10 +1880,10 @@ function buildToolStats(jsonlPath) {
   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, impact });
+    tools.push({ name: displayName, count: stats.count, success: stats.success, failed: stats.failed, rejected: stats.rejected, impact });
   }
 
-  return { totalCalls, uniqueTools, totalFailed, tools };
+  return { totalCalls, uniqueTools, totalFailed, totalRejected, tools };
 }
 
 app.get('/api/sessions/:sessionId/tool-stats', (req, res) => {
@@ -1842,6 +1913,14 @@ app.get('/api/sessions/:sessionId/user-image/:msgUuid/:blockIndex', (req, res) =
   res.end(buf);
 });
 
+app.get('/api/sessions/:sessionId/cached-image/:n', (req, res) => {
+  const img = readCachedImage(req.params.sessionId, req.params.n);
+  if (!img) return res.status(404).end();
+  res.setHeader('Content-Type', img.mediaType);
+  res.setHeader('Cache-Control', 'no-store');
+  res.end(img.buffer);
+});
+
 app.get('/api/version', (req, res) => {
   const pkg = require('./package.json');
   res.json({ version: pkg.version });
@@ -2402,13 +2481,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) => {
@@ -2421,6 +2525,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;