claude-code-kanban 4.10.0 → 4.12.0

package/lib/parsers.js

@@ -551,6 +551,7 @@ function readRecentMessages(jsonlPath, limit = 10) {
     const messages = [];
     const toolResults = new Map();
     const toolResultExtras = new Map();
+    const toolResultImageCounts = new Map();
     let readSize = Math.min(65536, stat.size);
 
     while (messages.length < limit) {
@@ -567,6 +568,7 @@ function readRecentMessages(jsonlPath, limit = 10) {
       messages.length = 0;
       toolResults.clear();
       toolResultExtras.clear();
+      toolResultImageCounts.clear();
       for (const line of clean.split('\n')) {
         if (!line.trim()) continue;
         try {
@@ -823,6 +825,15 @@ function readRecentMessages(jsonlPath, limit = 10) {
                       .filter(c => c.type === 'text' && c.text)
                       .map(c => c.text)
                       .join('\n');
+                    // A Read on an image file (e.g. .png) returns the image as a
+                    // base64 block inside the tool_result. Count them so the
+                    // renderer can request each by index and show what the agent
+                    // saw; the bytes are fetched lazily per image via the endpoint.
+                    let imgCount = 0;
+                    for (const c of block.content) {
+                      if (c && c.type === 'image' && c.source && c.source.type === 'base64') imgCount++;
+                    }
+                    if (imgCount) toolResultImageCounts.set(block.tool_use_id, imgCount);
                   }
                   if (resultText) {
                     toolResults.set(block.tool_use_id, resultText);
@@ -900,6 +911,9 @@ function readRecentMessages(jsonlPath, limit = 10) {
         }
         msg.toolResultTruncated = truncated;
       }
+      if (msg.type === 'tool_use' && msg.toolUseId && toolResultImageCounts.has(msg.toolUseId)) {
+        msg.toolResultImageCount = toolResultImageCounts.get(msg.toolUseId);
+      }
       if (msg.type === 'tool_use' && msg.tool === 'AskUserQuestion'
           && msg.toolUseId && toolResultExtras.has(msg.toolUseId)) {
         const extra = toolResultExtras.get(msg.toolUseId);
@@ -981,6 +995,36 @@ function readUserImage(jsonlPath, msgUuid, blockIndex) {
   return null;
 }
 
+// Read the Nth base64 image embedded in a tool_result block (e.g. the output of
+// a Read on an image file). Scans for the tool_result matching toolUseId.
+function readToolResultImage(jsonlPath, toolUseId, n) {
+  if (!toolUseId || !jsonlPath) return null;
+  const idx = Number(n);
+  if (!Number.isInteger(idx) || idx < 0) return null;
+  try {
+    const content = readFileSync(jsonlPath, 'utf8');
+    const lines = content.split('\n');
+    for (const line of lines) {
+      if (!line || line.indexOf(toolUseId) === -1) continue;
+      let obj;
+      try { obj = JSON.parse(line); } catch (_) { continue; }
+      const blocks = obj?.message?.content;
+      if (!Array.isArray(blocks)) continue;
+      for (const block of blocks) {
+        if (block?.type !== 'tool_result' || block.tool_use_id !== toolUseId) continue;
+        if (!Array.isArray(block.content)) continue;
+        const images = block.content.filter(
+          (c) => c && c.type === 'image' && c.source && c.source.type === 'base64',
+        );
+        const img = images[idx];
+        if (!img) return null;
+        return { mediaType: img.source.media_type || 'image/png', data: img.source.data };
+      }
+    }
+  } catch (_) {}
+  return null;
+}
+
 const CACHED_IMAGE_MIME = {
   png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', webp: 'image/webp',
 };
@@ -1438,6 +1482,7 @@ module.exports = {
   readMessagesPage,
   readFullToolResult,
   readUserImage,
+  readToolResultImage,
   readCachedImage,
   updateLoopInfo,
   buildLoopInfoFromState,

package/package.json

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

package/public/app.js

@@ -1643,17 +1643,24 @@ function _renderPinToDetail(pin) {
   if (pin.type === 'tool_use') {
     document.getElementById('msg-detail-title').textContent = pin.tool || 'Tool';
     const fullText = pin.fullDetail || pin.detail || '';
-    const pinParamsHtml = renderToolParamsHtml(pin.params);
-    const pinResultHtml = renderToolResultHtml(
-      pin.toolResult,
-      pin.toolResultTruncated,
-      pin.toolResultFull,
-      pin.toolUseId,
-    );
+    const pinFindings = pin.tool === 'ReportFindings';
+    const pinParamsHtml = pinFindings
+      ? renderFindingsReport(pin.params, pin.toolResult)
+      : renderToolParamsHtml(pin.params);
+    const pinResultHtml = pinFindings
+      ? ''
+      : renderToolResultHtml(pin.toolResult, pin.toolResultTruncated, pin.toolResultFull, pin.toolUseId);
     const pinDetailEscaped = escapeHtml(fullText);
     const pinDetailRendered = pin.tool === 'Bash' ? highlightBash(pinDetailEscaped) : pinDetailEscaped;
+    // Tool-result images are intentionally omitted here: their URL is built from
+    // the global currentSessionId, but a pin can belong to a different session,
+    // so rendering them would point at the wrong session's image.
     body.innerHTML =
-      (fullText ? `<pre class="${TINTED_PRE_CLASS}">${pinDetailRendered}</pre>` : '<em>No details</em>') +
+      (fullText
+        ? `<pre class="${TINTED_PRE_CLASS}">${pinDetailRendered}</pre>`
+        : pinFindings
+          ? ''
+          : '<em>No details</em>') +
       pinParamsHtml +
       pinResultHtml;
   } else if (pin.type === 'agent') {
@@ -1679,6 +1686,17 @@ const linkSvg = (size) =>
 //#endregion
 
 //#region MODALS
+// Shared markup for an attachment image and the labeled section that holds a grid
+// of them — used by both user-pasted images and agent tool-result images.
+function attachImageTag(url, alt) {
+  return `<img src="${url}" loading="lazy" alt="${alt}" class="user-attach-image" />`;
+}
+function attachImageSection(label, imgsHtml) {
+  return imgsHtml
+    ? `<div class="user-attach-section"><div class="user-attach-label">${label}</div><div class="user-attach-images">${imgsHtml}</div></div>`
+    : '';
+}
+
 function renderUserAttachments(m) {
   const parts = [];
   if (m.images?.length && currentSessionId) {
@@ -1687,20 +1705,17 @@ function renderUserAttachments(m) {
       .map((img) => {
         // Cache-kind images live on disk (image-cache/<sessionId>/<n>.png); base64
         // images are read from the JSONL block and need the message uuid.
-        let url;
-        if (img.kind === 'cache') {
-          url = `/api/sessions/${sid}/cached-image/${img.n}`;
-        } else if (m.uuid) {
-          url = `/api/sessions/${sid}/user-image/${encodeURIComponent(m.uuid)}/${img.blockIndex}`;
-        } else {
-          return '';
-        }
-        return `<img src="${url}" loading="lazy" alt="user image" class="user-attach-image" />`;
+        if (img.kind === 'cache') return attachImageTag(`/api/sessions/${sid}/cached-image/${img.n}`, 'user image');
+        if (m.uuid)
+          return attachImageTag(
+            `/api/sessions/${sid}/user-image/${encodeURIComponent(m.uuid)}/${img.blockIndex}`,
+            'user image',
+          );
+        return '';
       })
       .join('');
-    parts.push(
-      `<div class="user-attach-section"><div class="user-attach-label">Attached images</div><div class="user-attach-images">${imgs}</div></div>`,
-    );
+    const section = attachImageSection('Attached images', imgs);
+    if (section) parts.push(section);
   }
   if (m.toolResultRefs?.length) {
     const refs = m.toolResultRefs
@@ -1761,11 +1776,15 @@ function showMsgDetail(idx) {
       agentBtn.style.display = 'none';
     }
     const sendProto = m.tool === 'SendMessage' && m.params?.protocol;
-    const toolParamsHtml = renderToolParamsHtml(
-      sendProto ? Object.fromEntries(Object.entries(m.params).filter(([k]) => k !== 'protocol')) : m.params,
-    );
-    const hideResult = m.tool === 'SendMessage' || TASK_TOOLS.has(m.tool);
+    const isFindings = m.tool === 'ReportFindings';
+    const toolParamsHtml = isFindings
+      ? ''
+      : renderToolParamsHtml(
+          sendProto ? Object.fromEntries(Object.entries(m.params).filter(([k]) => k !== 'protocol')) : m.params,
+        );
+    const hideResult = m.tool === 'SendMessage' || TASK_TOOLS.has(m.tool) || isFindings;
     const taskResultHtml = TASK_TOOLS.has(m.tool) ? renderTaskResult(m.toolResult) : '';
+    const findingsHtml = isFindings ? renderFindingsReport(m.params, m.toolResult) : '';
     const toolResultHtml = hideResult
       ? ''
       : renderToolResultHtml(m.toolResult, m.toolResultTruncated, m.toolResultFull, m.toolUseId);
@@ -1777,8 +1796,8 @@ function showMsgDetail(idx) {
       mainHtml = `${descHtml}<div class="markdown-body">${renderMarkdown(fullText)}</div>`;
     } else if (hasAgentTabs) {
       mainHtml = descHtml || '';
-    } else if (taskResultHtml) {
-      mainHtml = '';
+    } else if (taskResultHtml || findingsHtml) {
+      mainHtml = descHtml || '';
     } else if (fullText) {
       const detailEscaped = escapeHtml(fullText);
       const detailRendered = m.tool === 'Bash' ? highlightBash(detailEscaped) : detailEscaped;
@@ -1787,8 +1806,16 @@ function showMsgDetail(idx) {
       mainHtml = TASK_TOOLS.has(m.tool) ? '' : '<em>No details</em>';
     }
     const answersHtml = m.answerPayload ? renderAnswerPayloadHtml(m.answerPayload) : '';
+    const toolResultImagesHtml = renderToolResultImagesHtml(m.toolResultImageCount, m.toolUseId);
     body.innerHTML =
-      mainHtml + toolParamsHtml + answersHtml + taskResultHtml + (hasAgentTabs ? '' : toolResultHtml) + agentExtraHtml;
+      mainHtml +
+      toolParamsHtml +
+      answersHtml +
+      taskResultHtml +
+      findingsHtml +
+      (hasAgentTabs ? '' : toolResultHtml) +
+      toolResultImagesHtml +
+      agentExtraHtml;
   } else if (m.type === 'teammate') {
     document.getElementById('msg-detail-title').textContent = m.teammateId || 'Teammate';
     document.getElementById('msg-detail-agent-btn').style.display = 'none';
@@ -1978,6 +2005,7 @@ function formatTaskToolDetail(params) {
 }
 function getToolDetail(tool, params, detail) {
   if (TASK_TOOLS.has(tool)) return formatTaskToolDetail(params);
+  if (tool === 'ReportFindings') return formatFindingsToolDetail(params);
   if (!detail) return '';
   let extra = '';
   if (tool === 'Read' && params) {
@@ -2044,6 +2072,66 @@ function renderAnswerPayloadHtml(answerPayload) {
   </div>`;
 }
 
+//#region FINDINGS
+const FINDING_VERDICT_COLORS = {
+  CONFIRMED: 'var(--danger, #ef5350)',
+  PLAUSIBLE: 'var(--warning, #f0b429)',
+};
+const FINDING_OUTCOME_COLORS = {
+  fixed: 'var(--success, #3ecf8e)',
+  no_change_needed: 'var(--info, #60a5fa)',
+  skipped: 'var(--text-muted)',
+};
+function findingBadge(label, color) {
+  return `<span class="finding-badge" style="color:${color}">${escapeHtml(label)}</span>`;
+}
+function formatFindingsToolDetail(params) {
+  const findings = Array.isArray(params?.findings) ? params.findings : [];
+  const parts = [
+    `<span style="color:var(--text-secondary)">${findings.length} finding${findings.length === 1 ? '' : 's'}</span>`,
+  ];
+  const confirmed = findings.filter((f) => f && f.verdict === 'CONFIRMED').length;
+  const plausible = findings.filter((f) => f && f.verdict === 'PLAUSIBLE').length;
+  if (confirmed) parts.push(`<span style="color:${FINDING_VERDICT_COLORS.CONFIRMED}">${confirmed} confirmed</span>`);
+  if (plausible) parts.push(`<span style="color:${FINDING_VERDICT_COLORS.PLAUSIBLE}">${plausible} plausible</span>`);
+  if (params?.level) parts.push(findingBadge(params.level, 'var(--text-muted)'));
+  return ` ${parts.join(' <span style="color:var(--text-muted)">·</span> ')}`;
+}
+function renderFindingsReport(params, toolResult) {
+  const findings = Array.isArray(params?.findings) ? params.findings : [];
+  let html = '<div class="protocol-detail findings-report">';
+  html += `<span class="protocol-type-badge">${findings.length} finding${findings.length === 1 ? '' : 's'}</span>`;
+  if (params?.level) html += ` ${findingBadge(`level: ${params.level}`, 'var(--text-muted)')}`;
+  if (!findings.length) {
+    html += '<div class="finding-scenario">No findings survived verification.</div>';
+  } else {
+    html += '<div class="findings-list">';
+    findings.forEach((f, i) => {
+      if (!f || typeof f !== 'object') return;
+      const badges = [];
+      if (f.verdict && FINDING_VERDICT_COLORS[f.verdict]) {
+        badges.push(findingBadge(f.verdict, FINDING_VERDICT_COLORS[f.verdict]));
+      }
+      if (f.outcome && FINDING_OUTCOME_COLORS[f.outcome]) {
+        badges.push(findingBadge(f.outcome.replace(/_/g, ' '), FINDING_OUTCOME_COLORS[f.outcome]));
+      }
+      const loc = f.file ? `${f.file}${f.line != null ? `:${f.line}` : ''}` : '';
+      html += `<div class="finding-card">
+          <span class="finding-rank">${i + 1}</span>
+          <div class="finding-main">
+            ${badges.length || loc ? `<div class="finding-badges">${badges.join('')}${loc ? `<span class="finding-file">${escapeHtml(loc)}</span>` : ''}</div>` : ''}
+            ${f.summary ? `<div class="finding-summary">${escapeHtml(f.summary)}</div>` : ''}
+            ${f.failure_scenario ? `<div class="finding-scenario">${escapeHtml(f.failure_scenario)}</div>` : ''}
+          </div>
+        </div>`;
+    });
+    html += '</div>';
+  }
+  if (toolResult) html += `<div class="findings-result-note">${escapeHtml(toolResult.trim())}</div>`;
+  return `${html}</div>`;
+}
+//#endregion
+
 function renderToolParamsHtml(params) {
   if (!params) return '';
   const BLOCK_KEYS = new Set(['old_string', 'new_string', 'content', 'contentFull', 'plan']);
@@ -2240,6 +2328,18 @@ function renderToolResultHtml(toolResult, isTruncated, fullResult, toolUseId) {
       </div>`;
 }
 
+// Render base64 images returned by a tool (e.g. a Read on a .png) so the user
+// can see what the agent saw, mirroring how user-attached images are shown.
+function renderToolResultImagesHtml(count, toolUseId) {
+  if (!count || !currentSessionId || !toolUseId) return '';
+  const sid = encodeURIComponent(currentSessionId);
+  const tid = encodeURIComponent(toolUseId);
+  const imgs = Array.from({ length: count }, (_, i) =>
+    attachImageTag(`/api/sessions/${sid}/tool-result-image/${tid}/${i}`, 'tool result image'),
+  ).join('');
+  return attachImageSection('Image output', imgs);
+}
+
 async function _toggleToolResultExpand(btn) {
   const f = document.getElementById(btn.dataset.expandId);
   if (!f) return;

package/public/style.css

@@ -2337,7 +2337,7 @@ body::before {
   z-index: 1;
   line-height: 0;
 }
-.session-item:hover .session-pin-btn:not(.pinned) {
+.session-item:hover .session-pin-btn:not(.pinned):not(.sticky) {
   opacity: 0.5;
 }
 .session-pin-btn:hover {
@@ -2833,6 +2833,75 @@ body::before {
 
 /* #endregion */
 
+/* #region FINDINGS */
+.findings-list {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  margin-top: 8px;
+}
+.finding-card {
+  display: flex;
+  gap: 10px;
+  padding: 8px 10px;
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  background: var(--bg-surface);
+}
+.finding-rank {
+  color: var(--text-muted);
+  font-weight: 600;
+  font-size: 0.8rem;
+  min-width: 1.6em;
+  text-align: right;
+  line-height: 1.7;
+}
+.finding-main {
+  flex: 1;
+  min-width: 0;
+}
+.finding-badges {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 6px;
+  margin-bottom: 4px;
+}
+.finding-badge {
+  display: inline-block;
+  font-size: 0.68rem;
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  padding: 1px 6px;
+  border-radius: 3px;
+  border: 1px solid currentColor;
+  white-space: nowrap;
+}
+.finding-file {
+  font-family: var(--mono);
+  font-size: 0.78rem;
+  color: var(--text-secondary);
+  word-break: break-all;
+}
+.finding-summary {
+  font-size: 0.88rem;
+  color: var(--text-primary);
+  margin-bottom: 2px;
+}
+.finding-scenario {
+  font-size: 0.8rem;
+  color: var(--text-muted);
+}
+.findings-result-note {
+  margin-top: 10px;
+  padding-top: 8px;
+  border-top: 1px solid var(--border);
+  font-size: 0.8rem;
+  color: var(--text-muted);
+}
+/* #endregion */
+
 /* #region AGENT_FOOTER */
 .agent-footer {
   display: none;
@@ -4355,7 +4424,8 @@ pre.mermaid svg {
 }
 .session-item.stale:hover,
 .session-item.stale.active,
-.session-item.stale.kb-selected {
+.session-item.stale.kb-selected,
+.session-item.stale:has(.session-pin-btn.sticky) {
   opacity: 1;
 }
 .session-item.stale .session-time {

package/server.js

@@ -22,6 +22,7 @@ const {
   extractModelFromTranscript,
   readFullToolResult,
   readUserImage,
+  readToolResultImage,
   readCachedImage,
   updateLoopInfo,
   buildLoopInfoFromState
@@ -74,6 +75,7 @@ const TASKS_DIR = path.join(CLAUDE_DIR, 'tasks');
 const PROJECTS_DIR = path.join(CLAUDE_DIR, 'projects');
 const TEAMS_DIR = path.join(CLAUDE_DIR, 'teams');
 const PLANS_DIR = path.join(CLAUDE_DIR, 'plans');
+const SESSIONS_DIR = path.join(CLAUDE_DIR, 'sessions');
 const CCK_DIR = path.join(CLAUDE_DIR, '.cck');
 const AGENT_ACTIVITY_DIR = path.join(CCK_DIR, 'agent-activity');
 const CONTEXT_STATUS_DIR = path.join(CCK_DIR, 'context-status');
@@ -231,13 +233,13 @@ 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 && isAgentLive(agent)) {
+        // Idle agents never mark a session active (an idle teammate lingers and
+        // would pin the filter). Teams skip freshness so long-running teammates stay visible.
+        if (agent.status === 'active' && (isTeam || isAgentFresh(agent))) {
           result.hasActive = true;
-          if (agent.status === 'active') result.hasRunning = true;
-        } else if (isAgentFresh(agent)) {
-          if (agent.status === 'active') { result.hasActive = true; result.hasRunning = true; }
+          result.hasRunning = true;
         }
-        if (result.hasRunning && result.hasActive) break;
+        if (result.hasRunning) break;
       } catch (e) { /* skip invalid */ }
     }
   } catch (e) { /* ignore */ }
@@ -284,6 +286,87 @@ function isAutoSelfTeam(cfg) {
   return namedSession && soleLead;
 }
 
+// Claude Code 2.1.x stores a session's tasks in its self-team list (tasks/session-<id>/).
+// Usually `cfg.leadSessionId` is that session and already has a card. But a resumed /
+// continued session keeps writing to the original team's list while running under a new
+// session id, so `leadSessionId` points at the original (often a ghost with no card) and
+// the tasks can't be matched to the live session by id. The on-disk bridge is the
+// live-session registry (~/.claude/sessions/<pid>.json): the team's `createdAt` ≈ the
+// owning session's `startedAt` (both written at boot) and they share a cwd. Match on that.
+const SELF_TEAM_BOOT_WINDOW_MS = 60 * 1000;
+let liveSessionsCache = null;
+let lastLiveSessionsScan = 0;
+const LIVE_SESSIONS_TTL = 5000;
+
+function loadLiveSessions() {
+  const now = Date.now();
+  if (liveSessionsCache && now - lastLiveSessionsScan < LIVE_SESSIONS_TTL) return liveSessionsCache;
+  const sessions = [];
+  if (existsSync(SESSIONS_DIR)) {
+    try {
+      for (const file of readdirSync(SESSIONS_DIR).filter(f => f.endsWith('.json'))) {
+        try {
+          const s = JSON.parse(readFileSync(path.join(SESSIONS_DIR, file), 'utf8'));
+          if (s?.sessionId && s.kind === 'interactive') {
+            sessions.push({ sessionId: s.sessionId, cwd: s.cwd || null, startedAt: s.startedAt || 0, status: s.status || null });
+          }
+        } catch (_) { /* skip invalid */ }
+      }
+    } catch (_) { /* ignore */ }
+  }
+  liveSessionsCache = sessions;
+  lastLiveSessionsScan = now;
+  return sessions;
+}
+
+// An open-but-idle interactive session keeps touching its JSONL (metadata-line
+// rewrites), so mtime alone reads as activity for as long as the terminal stays
+// open. Claude Code's live-session registry knows the real state — trust its
+// 'idle' over the mtime. No registry entry (or any other status) falls back to
+// the mtime rule.
+function isRegistryIdle(sessionId) {
+  const live = loadLiveSessions().find(s => s.sessionId === sessionId);
+  return live?.status === 'idle';
+}
+
+function hasRecentLogActivity(sessionId, logAge) {
+  return logAge <= SESSION_STALE_MS && !isRegistryIdle(sessionId);
+}
+
+// Given a self-team config, return the live interactive session id that owns it
+// (same cwd, startedAt within the boot window of the team's createdAt), or null.
+function resolveSelfTeamOwner(cfg) {
+  if (!cfg?.createdAt) return null;
+  const teamCwd = cfg.members?.[0]?.cwd;
+  if (!teamCwd) return null;
+  let best = null, bestDelta = Infinity;
+  for (const s of loadLiveSessions()) {
+    if (s.cwd !== teamCwd) continue;
+    const delta = Math.abs(s.startedAt - cfg.createdAt);
+    if (delta <= SELF_TEAM_BOOT_WINDOW_MS && delta < bestDelta) {
+      best = s.sessionId;
+      bestDelta = delta;
+    }
+  }
+  return best;
+}
+
+// Attach a team-named task dir's counts to a session card, preferring it over an empty or
+// smaller task dir (a team session can also have a near-empty UUID-named dir). Caller passes
+// the already-computed counts.
+function attachTeamTasks(card, teamTaskDir, teamName, counts) {
+  if (!card.tasksDir || counts.taskCount > (card.taskCount || 0)) {
+    Object.assign(card, {
+      taskCount: counts.taskCount,
+      completed: counts.completed,
+      inProgress: counts.inProgress,
+      pending: counts.pending,
+      tasksDir: teamTaskDir,
+      sharedTaskList: teamName,
+    });
+  }
+}
+
 // SSE clients for live updates
 const clients = new Set();
 
@@ -381,17 +464,32 @@ function getCustomTaskDir(sessionId) {
     const dir = path.join(TASKS_DIR, taskListName);
     if (existsSync(dir)) return dir;
   }
-  // Check team-named task directory (teams store tasks under ~/.claude/tasks/<teamName>/)
+  // Check team-named task directory (teams store tasks under ~/.claude/tasks/<teamName>/).
+  // Match either the recorded leadSessionId, or — for 2.1.x self-teams whose lead is a
+  // team-lead agent id — the live interactive session that owns the team (see resolveSelfTeamOwner).
+  // A live session can own several team dirs at once — its own (often empty) self-team plus a
+  // resumed session's dir holding the real tasks — so pick the richest, mirroring attachTeamTasks'
+  // "prefer more tasks" rule. Returning the first match (readdir order) can pick the empty dir,
+  // making the board show 0 tasks while the session card counts the other dir.
   if (existsSync(TEAMS_DIR)) {
     try {
+      let bestDir = null, bestCount = -1;
       for (const dir of readdirSync(TEAMS_DIR, { withFileTypes: true })) {
         if (!dir.isDirectory()) continue;
         const cfg = loadTeamConfig(dir.name);
-        if (cfg?.leadSessionId === sessionId) {
-          const teamTaskDir = path.join(TASKS_DIR, dir.name);
-          if (existsSync(teamTaskDir)) return teamTaskDir;
+        if (!cfg) continue;
+        const owns = cfg.leadSessionId === sessionId
+          || (isAutoSelfTeam(cfg) && resolveSelfTeamOwner(cfg) === sessionId);
+        if (!owns) continue;
+        const teamTaskDir = path.join(TASKS_DIR, dir.name);
+        if (!existsSync(teamTaskDir)) continue;
+        const count = getTaskCounts(teamTaskDir).taskCount;
+        if (count > bestCount) {
+          bestCount = count;
+          bestDir = teamTaskDir;
         }
       }
+      if (bestDir) return bestDir;
     } catch (_) {}
   }
   return null;
@@ -735,7 +833,7 @@ function buildSessionObject(id, meta, overrides = {}) {
     hasActiveAgents: false,
     hasRunningAgents: false,
     hasWaitingForUser: false,
-    hasRecentLog: logAge <= SESSION_STALE_MS,
+    hasRecentLog: hasRecentLogActivity(id, logAge),
     jsonlPath: meta.jsonlPath || null,
     tasksDir: null,
     projectDir: meta.jsonlPath ? path.dirname(meta.jsonlPath) : null,
@@ -793,7 +891,7 @@ app.get('/api/sessions', async (req, res) => {
           // 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 hasRecentLog = hasRecentLogActivity(entry.name, logAge);
             const cheaplyActive = logStat.hasMessages && (
               hasRecentLog
               || agentStatus.hasActive
@@ -894,7 +992,7 @@ app.get('/api/sessions', async (req, res) => {
 
         // 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 hasRecentLog = hasRecentLogActivity(sessionId, logAge);
           const cheaplyActive = logStat.hasMessages && (
             hasRecentLog || metaAgentStatus.hasActive || !!metaAgentStatus.waitingForUser
           );
@@ -949,7 +1047,42 @@ app.get('/api/sessions', async (req, res) => {
           // auto-created session-<uuid> self-team dir leaves a duplicate session card whose
           // id (session-<uuid>) resolves no messages, so switching to it shows a stale log.
           if (sessionsMap.has(dir.name) && dir.name !== leaderId) sessionsMap.delete(dir.name);
-          if (isAutoSelfTeam(cfg)) continue;
+          if (isAutoSelfTeam(cfg)) {
+            // Self-teams are normally noise with an empty team-named task dir. But 2.1.x stores a
+            // session's tasks in the self-team list (tasks/session-<id>/), so when it's non-empty
+            // the tasks would be silently orphaned. Recover them (gated on taskCount > 0 to keep
+            // the empty-self-team noise case suppressed): attach to the owning card — the recorded
+            // leadSessionId when it has one, else the live session continuing it (resolved from the
+            // session registry), else a freshly-built fallback lead card.
+            const teamTaskDir = path.join(TASKS_DIR, dir.name);
+            if (!existsSync(teamTaskDir)) continue;
+            const counts = getTaskCounts(teamTaskDir);
+            if (counts.taskCount === 0) continue;
+
+            const ownerCard = sessionsMap.get(leaderId) || sessionsMap.get(resolveSelfTeamOwner(cfg));
+            if (ownerCard) {
+              attachTeamTasks(ownerCard, teamTaskDir, dir.name, counts);
+            } else {
+              const meta = metadata[leaderId] || {};
+              const logStat = getSessionLogStat(meta);
+              const logMtime = logStat.mtime;
+              const logAge = logMtime ? Date.now() - logMtime : Infinity;
+              const agentDir = path.join(AGENT_ACTIVITY_DIR, leaderId);
+              const agentStatus = checkAgentStatus(agentDir, logAge > AGENT_STALE_MS, logMtime, false);
+              const taskMtime = counts.newestTaskMtime ? counts.newestTaskMtime.getTime() : 0;
+              const card = buildSessionObject(leaderId, meta, {
+                _logStat: logStat,
+                name: getSessionDisplayName(leaderId, meta) || cfg.name || dir.name,
+                modifiedAt: new Date(Math.max(taskMtime, logMtime || 0)).toISOString(),
+                hasActiveAgents: agentStatus.hasActive,
+                hasRunningAgents: agentStatus.hasRunning,
+                hasWaitingForUser: !!agentStatus.waitingForUser,
+              });
+              attachTeamTasks(card, teamTaskDir, dir.name, counts);
+              sessionsMap.set(leaderId, card);
+            }
+            continue;
+          }
           const existing = sessionsMap.get(leaderId);
           if (existing) {
             existing.isTeam = true;
@@ -963,15 +1096,7 @@ app.get('/api/sessions', async (req, res) => {
             // holding the real tasks, the leader card otherwise shows 0/0.
             const teamTaskDir = path.join(TASKS_DIR, dir.name);
             if (existsSync(teamTaskDir)) {
-              const counts = getTaskCounts(teamTaskDir);
-              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;
-              }
+              attachTeamTasks(existing, teamTaskDir, dir.name, getTaskCounts(teamTaskDir));
             }
             // Re-check agent status with isTeam=true
             const agentDir = path.join(AGENT_ACTIVITY_DIR, leaderId);
@@ -1827,9 +1952,11 @@ app.get('/api/sessions/:sessionId/messages', (req, res) => {
       compactedMsgs[i].compactSummary = compactSummaries[i].summary;
     }
   }
+  // The client keeps needing toolUseId when it builds a follow-up URL from it:
+  // lazy-fetching a truncated tool result, or fetching each tool-result image.
+  const clientNeedsToolUseId = (msg) => msg.toolResultTruncated || msg.toolResultImageCount;
   for (const msg of messages) {
-    // Keep toolUseId on truncated tool results so the client can lazy-fetch the full text
-    if (msg.toolUseId && !msg.toolResultTruncated) delete msg.toolUseId;
+    if (msg.toolUseId && !clientNeedsToolUseId(msg)) delete msg.toolUseId;
     delete msg.promptId;
   }
   res.json({ messages, hasMore, sessionId: req.params.sessionId });
@@ -1969,6 +2096,19 @@ app.get('/api/sessions/:sessionId/user-image/:msgUuid/:blockIndex', (req, res) =
   res.end(buf);
 });
 
+app.get('/api/sessions/:sessionId/tool-result-image/:toolUseId/:n', (req, res) => {
+  const metadata = loadSessionMetadata();
+  const meta = metadata[req.params.sessionId] || metadata[resolveSessionId(req.params.sessionId)];
+  const jsonlPath = meta?.jsonlPath;
+  if (!jsonlPath) return res.status(404).end();
+  const img = readToolResultImage(jsonlPath, req.params.toolUseId, req.params.n);
+  if (!img) return res.status(404).end();
+  const buf = Buffer.from(img.data, 'base64');
+  res.setHeader('Content-Type', img.mediaType);
+  res.setHeader('Cache-Control', 'no-store');
+  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();