claude-code-kanban 4.14.0 → 4.14.1

package/lib/parsers.js

@@ -1291,33 +1291,31 @@ function findTerminatedTeammates(jsonlPath) {
 
 function extractPromptFromTranscript(jsonlPath) {
   const { openSync, readSync, closeSync } = fs;
-  const MAX_READ = 65536;
-  const CHUNK = 4096;
+  // statSync (outside try) throws on a missing path — callers rely on that.
+  const stat = statSync(jsonlPath);
+  // Workflow-spawned subagent prompts embed full task context and routinely
+  // exceed 64 KB, so read the whole first line up to a generous cap. One buffered
+  // read (vs. per-chunk decode) also avoids corrupting multi-byte chars at chunk
+  // boundaries for large prompts.
+  const readSize = Math.min(2097152, stat.size);
   const fd = openSync(jsonlPath, 'r');
   try {
-    let accumulated = '';
-    const buf = Buffer.alloc(CHUNK);
-    while (accumulated.length < MAX_READ) {
-      const bytesRead = readSync(fd, buf, 0, CHUNK, null);
-      if (bytesRead === 0) break;
-      accumulated += buf.toString('utf8', 0, bytesRead);
-      const nlIdx = accumulated.indexOf('\n');
-      if (nlIdx === -1) continue;
-      const firstLine = accumulated.slice(0, nlIdx);
-      try {
-        const obj = JSON.parse(firstLine);
-        if (obj.type === 'user') {
-          const content = obj.message?.content;
-          if (typeof content === 'string') return content;
-          if (Array.isArray(content)) {
-            for (const b of content) {
-              if (b.type === 'text' && b.text) return b.text;
-            }
-          }
+    const buf = Buffer.alloc(readSize);
+    readSync(fd, buf, 0, readSize, 0);
+    // Decode only the first line, not the whole (possibly large) read window.
+    const nlByte = buf.indexOf(0x0a);
+    const firstLine = (nlByte === -1 ? buf : buf.subarray(0, nlByte)).toString('utf8');
+    const obj = JSON.parse(firstLine);
+    if (obj.type === 'user') {
+      const content = obj.message?.content;
+      if (typeof content === 'string') return content;
+      if (Array.isArray(content)) {
+        for (const b of content) {
+          if (b.type === 'text' && b.text) return b.text;
         }
-      } catch (_) {}
-      break;
+      }
     }
+  } catch (_) {
   } finally {
     closeSync(fd);
   }
@@ -1354,6 +1352,82 @@ function extractModelFromTranscript(jsonlPath) {
   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
+// path (a full read per agent would blow the /api/sessions budget).
+function extractTranscriptStats(jsonlPath) {
+  let content;
+  try { content = readFileSync(jsonlPath, 'utf8'); } catch (_) { return null; }
+  let model = null;
+  let outputTokens = 0;
+  let firstTs = null;
+  let lastTs = null;
+  for (const line of content.split('\n')) {
+    if (!line.trim()) continue;
+    let obj;
+    try { obj = JSON.parse(line); } catch (_) { continue; }
+    if (obj.timestamp) {
+      if (!firstTs) firstTs = obj.timestamp;
+      lastTs = obj.timestamp;
+    }
+    const msg = obj.message;
+    if (msg && typeof msg === 'object') {
+      if (!model && msg.model) model = msg.model;
+      const out = msg.usage?.output_tokens;
+      if (typeof out === 'number') outputTokens += out;
+    }
+  }
+  return { model, outputTokens, firstTs, lastTs };
+}
+
+// Render a StructuredOutput tool input (arbitrary schema object) as markdown:
+// one section per field, prose kept verbatim, structured values as JSON blocks.
+function formatStructuredResult(input) {
+  const parts = [];
+  for (const [key, value] of Object.entries(input)) {
+    if (value == null || value === '') continue;
+    parts.push('### ' + key);
+    parts.push(typeof value === 'string' ? value : '```json\n' + JSON.stringify(value, null, 2) + '\n```');
+  }
+  return parts.length ? parts.join('\n\n') : null;
+}
+
+// Workflow-spawned subagents given a schema end their run on a forced
+// StructuredOutput tool call and never emit a text response — so their
+// lastMessage is empty. Tail-read the transcript, take the LAST StructuredOutput
+// tool_use, and format its input as the agent's result. Returns null when absent.
+function extractStructuredResultFromTranscript(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');
+  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;
+    if (!clean.includes('"StructuredOutput"')) return null;
+    // Scan from the end for the last StructuredOutput tool call.
+    const lines = clean.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (!lines[i].includes('"StructuredOutput"')) continue;
+      let obj;
+      try { obj = JSON.parse(lines[i]); } catch (_) { continue; }
+      const content = obj?.message?.content;
+      if (!Array.isArray(content)) continue;
+      const block = content.find(b => b?.type === 'tool_use' && b.name === 'StructuredOutput' && b.input && typeof b.input === 'object');
+      if (block) return formatStructuredResult(block.input);
+    }
+  } catch (_) {
+  } finally {
+    closeSync(fd);
+  }
+  return null;
+}
+
 // Incremental loop-tool scanner. JSONL is append-only, so we keep per-path
 // state and on each call read ONLY the bytes appended since scannedOffset.
 // Avoids the only full-file read that ran inside the /api/sessions hot path.
@@ -1492,5 +1566,7 @@ module.exports = {
   readCompactSummaries,
   findTerminatedTeammates,
   extractPromptFromTranscript,
-  extractModelFromTranscript
+  extractModelFromTranscript,
+  extractStructuredResultFromTranscript,
+  extractTranscriptStats
 };

package/package.json

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

package/public/app.js

@@ -2634,7 +2634,7 @@ function showAgentModal(agentId) {
   const modalNameLabel = agent.agentName ? ` · ${escapeHtml(agent.agentName)}` : '';
   title.innerHTML = `${statusDot} ${escapeHtml(agent.type || 'unknown')}${modalNameLabel}`;
 
-  const shortModel = agent.model ? agent.model.replace(/^claude-/, '').replace(/-\d{8}$/, '') : null;
+  const shortModel = shortModelName(agent.model);
   const shortId = agent.agentId ? agent.agentId.slice(0, 8) : '';
   const chip = (label, value, opts = {}) => {
     const cls = opts.cls ? ` ${opts.cls}` : '';
@@ -2648,7 +2648,7 @@ function showAgentModal(agentId) {
   // toolUseResult), not on the agent-activity record — so read them from there.
   const agentMsg = currentMessages.find((m) => m.tool === 'Agent' && m.agentId === agentId);
   const usageStats = agentMsg?.agentUsageStats || null;
-  const fmtTok = (t) => (t >= 1000 ? `${(t / 1000).toFixed(1).replace(/\.0$/, '')}k` : `${t}`);
+  const fmtTok = fmtTokens;
 
   const chips = [];
   if (agent.agentId) chips.push(chip('id', escapeHtml(shortId), { cls: 'agent-chip-mono', title: agent.agentId }));
@@ -2796,7 +2796,7 @@ function renderSessions() {
         ((!s.sharedTaskList && (s.pending > 0 || s.inProgress > 0)) ||
           s.hasActiveAgents ||
           s.hasWaitingForUser ||
-          s.hasRecentLog);
+          s.hasRecentActivity);
       if (isActive) activeSessionIds.add(s.id);
       return isActive;
     });
@@ -5707,8 +5707,12 @@ function filterBySessions(value) {
   sessionFilter = value;
   if (value !== 'active') activityFilter.clear();
   updateUrl();
+  // Instant feedback from cached data, then refetch — the cached list was fetched
+  // with the previous filter's server params (e.g. filter=active), so "All Sessions"
+  // needs a server round-trip to actually include inactive sessions.
   renderSessions();
   renderActivityChip();
+  fetchSessions(false);
 }
 
 // biome-ignore lint/correctness/noUnusedVariables: used in HTML
@@ -6502,6 +6506,7 @@ function renderWorkflowBadge(session) {
 
 let _workflowSessionId = null;
 let _workflowHeaderId = null;
+let _workflowList = [];
 
 // biome-ignore lint/correctness/noUnusedVariables: used in HTML
 function showWorkflowModal(sessionId) {
@@ -6513,7 +6518,18 @@ function showWorkflowModal(sessionId) {
   fetch(`/api/sessions/${sessionId}/workflows`)
     .then((r) => (r.ok ? r.json() : { workflows: [] }))
     .catch(() => ({ workflows: [] }))
-    .then((data) => renderWorkflowList(data.workflows || []));
+    .then((data) => {
+      _workflowList = data.workflows || [];
+      if (!_workflowList.length) {
+        setWorkflowHeader('Workflows', null);
+        body.innerHTML =
+          '<div style="padding:24px;text-align:center;color:var(--text-secondary);">No workflow scripts for this session.</div>';
+      } else if (_workflowList.length === 1) {
+        showWorkflowRun(_workflowList[0].id);
+      } else {
+        renderWorkflowPicker(_workflowList);
+      }
+    });
 }
 
 function setWorkflowHeader(name, wfId) {
@@ -6527,44 +6543,118 @@ function setWorkflowHeader(name, wfId) {
   if (headerBtn) headerBtn.style.display = wfId ? '' : 'none';
 }
 
-function renderWorkflowList(workflows) {
-  const body = document.getElementById('workflow-modal-body');
-  if (!workflows.length) {
-    setWorkflowHeader('Workflows', null);
-    body.innerHTML =
-      '<div style="padding:24px;text-align:center;color:var(--text-secondary);">No workflow scripts for this session.</div>';
-    return;
-  }
-  // Single workflow: promote its name to the header and open-button next to the close (X).
-  if (workflows.length === 1) {
-    const w = workflows[0];
-    setWorkflowHeader(w.name || w.id, w.id);
-    const when = w.modifiedAt ? formatDate(w.modifiedAt) : '';
-    body.innerHTML = `<div class="workflow-single">
-      <div class="workflow-row-meta"><code>${escapeHtml(w.id)}</code>${when ? ` · ${escapeHtml(when)}` : ''}</div>
-      <div class="workflow-row-code"></div>
-    </div>`;
-    loadWorkflowCode(w.id, body.querySelector('.workflow-row-code'));
-    return;
-  }
-  // Multiple workflows: generic header, collapsible list with per-row open icons.
+// Multiple workflows: pick one to drill into (we show a single run at a time).
+function renderWorkflowPicker(workflows) {
   setWorkflowHeader('Workflows', null);
+  const body = document.getElementById('workflow-modal-body');
   body.innerHTML = workflows
     .map((w) => {
       const when = w.modifiedAt ? formatDate(w.modifiedAt) : '';
-      return `<div class="workflow-row" onclick="viewWorkflowScript('${escapeHtml(w.id)}', this)">
+      return `<div class="workflow-row" onclick="showWorkflowRun('${escapeHtml(w.id)}')">
         <div class="workflow-row-head">
           <span class="workflow-row-name">${escapeHtml(w.name || w.id)}</span>
           <span class="workflow-row-id"><code>${escapeHtml(w.id)}</code></span>
           <button class="icon-btn workflow-open-icon" aria-label="Open in editor" title="Open in editor" onclick="event.stopPropagation(); openWorkflowInEditor('${escapeHtml(w.id)}')">${ICON_OPEN_EDITOR}</button>
         </div>
+        ${w.description ? `<div class="workflow-row-desc">${escapeHtml(w.description)}</div>` : ''}
         ${when ? `<div class="workflow-row-meta">${escapeHtml(when)}</div>` : ''}
-        <div class="workflow-row-code"></div>
       </div>`;
     })
     .join('');
 }
 
+function showWorkflowRun(wfId) {
+  const name = _workflowList.find((w) => w.id === wfId)?.name || wfId;
+  setWorkflowHeader(name, wfId);
+  const body = document.getElementById('workflow-modal-body');
+  body.innerHTML = '<div style="padding:16px;color:var(--text-secondary);">Loading…</div>';
+  fetch(`/api/sessions/${_workflowSessionId}/workflows/${encodeURIComponent(wfId)}/run`)
+    .then((r) => (r.ok ? r.json() : null))
+    .catch(() => null)
+    .then((run) => {
+      if (!run) {
+        body.innerHTML = '<div style="padding:16px;color:var(--text-secondary);">Failed to load run state.</div>';
+        return;
+      }
+      renderWorkflowRun(run);
+    });
+}
+
+function fmtTokens(t) {
+  return t >= 1000 ? `${(t / 1000).toFixed(1).replace(/\.0$/, '')}k` : `${t}`;
+}
+
+function shortModelName(model) {
+  return model ? model.replace(/^claude-/, '').replace(/-\d{8}$/, '') : '';
+}
+
+function renderWorkflowRun(run) {
+  const body = document.getElementById('workflow-modal-body');
+  const allDone = run.startedCount > 0 && run.doneCount >= run.startedCount;
+  const wall =
+    run.startedAt && run.stoppedAt ? formatDuration(new Date(run.stoppedAt) - new Date(run.startedAt)) : null;
+
+  const back =
+    _workflowList.length > 1
+      ? `<div class="wf-back" onclick="renderWorkflowPicker(_workflowList)">‹ All workflows</div>`
+      : '';
+
+  const stats = [`${run.doneCount}/${run.startedCount} agents`, wall ? escapeHtml(wall) : null]
+    .filter(Boolean)
+    .join(' · ');
+
+  const desc = run.description ? `<div class="wf-run-desc">${escapeHtml(run.description)}</div>` : '';
+
+  const phases = (run.phases || [])
+    .map(
+      (p) => `<div class="wf-phase">
+        <span class="wf-phase-mark${allDone ? ' done' : ''}">${allDone ? '✓' : ''}</span>
+        <span class="wf-phase-title">${escapeHtml(p.title)}</span>
+        ${p.detail ? `<span class="wf-phase-detail">${escapeHtml(p.detail)}</span>` : ''}
+      </div>`,
+    )
+    .join('');
+  const phasesBlock = phases ? `<div class="wf-section-title">Phases</div><div class="wf-phases">${phases}</div>` : '';
+
+  const agents = (run.agents || [])
+    .map((a) => {
+      const dur = a.durationMs != null ? formatDuration(a.durationMs) : '';
+      const running = a.status !== 'done';
+      return `<div class="wf-agent" onclick="showAgentModal('${escapeHtml(a.agentId)}')" title="${escapeHtml(a.agentId)}">
+        <span class="wf-agent-type">${escapeHtml(a.type || 'agent')}</span>
+        <span class="wf-agent-model">${escapeHtml(shortModelName(a.model))}</span>
+        <span class="wf-agent-tok">${a.outputTokens ? `${fmtTokens(a.outputTokens)} tok` : ''}</span>
+        <span class="wf-agent-dur">${escapeHtml(dur)}</span>
+        <span class="wf-agent-status ${running ? 'running' : 'done'}">${running ? '●' : '✓'}</span>
+      </div>`;
+    })
+    .join('');
+  const agentsBlock = run.agents?.length
+    ? `<div class="wf-section-title">Agents · ${run.agents.length}</div><div class="wf-agents">${agents}</div>`
+    : '<div class="wf-section-title">Agents</div><div class="wf-empty">No agent runs recorded yet.</div>';
+
+  body.innerHTML = `<div class="workflow-run">
+    ${back}
+    ${desc}
+    <div class="wf-run-stats">${stats} · <code>${escapeHtml(run.id)}</code></div>
+    ${phasesBlock}
+    ${agentsBlock}
+    <details class="wf-source">
+      <summary>Source</summary>
+      <div class="workflow-row-code"></div>
+    </details>
+  </div>`;
+
+  const details = body.querySelector('.wf-source');
+  details.addEventListener(
+    'toggle',
+    () => {
+      if (details.open) loadWorkflowCode(run.id, details.querySelector('.workflow-row-code'));
+    },
+    { once: true },
+  );
+}
+
 function loadWorkflowCode(wfId, codeEl) {
   if (!codeEl) return;
   codeEl.innerHTML = '<div style="padding:8px 0;color:var(--text-secondary);">Loading…</div>';
@@ -6586,19 +6676,6 @@ function loadWorkflowCode(wfId, codeEl) {
     });
 }
 
-// biome-ignore lint/correctness/noUnusedVariables: used in HTML
-function viewWorkflowScript(wfId, rowEl) {
-  const codeEl = rowEl.querySelector('.workflow-row-code');
-  if (!codeEl) return;
-  if (rowEl.classList.contains('expanded')) {
-    rowEl.classList.remove('expanded');
-    codeEl.innerHTML = '';
-    return;
-  }
-  rowEl.classList.add('expanded');
-  loadWorkflowCode(wfId, codeEl);
-}
-
 function openWorkflowInEditor(wfId) {
   postAndToast(`/api/sessions/${_workflowSessionId}/workflows/${encodeURIComponent(wfId)}/open`, {}, 'in editor');
 }
@@ -6611,6 +6688,7 @@ function openWorkflowHeaderScript() {
 function closeWorkflowModal() {
   document.getElementById('workflow-modal').classList.remove('visible');
   _workflowSessionId = null;
+  _workflowList = [];
   setWorkflowHeader('Workflows', null);
 }
 
@@ -7111,6 +7189,9 @@ window.addEventListener('popstate', () => {
   ownerFilter = s.owner || '';
   searchQuery = s.search || '';
   loadPreferences();
+  // fetchSessions derives query params from the globals set above — refetch so
+  // back/forward across a filter change doesn't render a stale server-filtered list.
+  fetchSessions(false);
   if (s.projectView) {
     try {
       fetchProjectView(atob(s.projectView));

package/public/style.css

@@ -1723,6 +1723,13 @@ body::before {
   color: var(--text-secondary);
 }
 
+.workflow-row-desc {
+  margin-top: 4px;
+  font-size: 12px;
+  line-height: 1.4;
+  color: var(--text-secondary);
+}
+
 .workflow-row-meta {
   margin-top: 2px;
   font-size: 11px;
@@ -1748,6 +1755,150 @@ body::before {
   border-radius: 6px;
 }
 
+/* Run state view */
+.wf-back {
+  font-size: 12px;
+  color: var(--text-secondary);
+  cursor: pointer;
+  margin-bottom: 10px;
+}
+
+.wf-back:hover {
+  color: var(--text-primary);
+}
+
+.wf-run-desc {
+  color: var(--text-secondary);
+  font-size: 13px;
+  line-height: 1.5;
+  margin-bottom: 8px;
+}
+
+.wf-run-stats {
+  font-size: 12px;
+  color: var(--text-secondary);
+  margin-bottom: 4px;
+}
+
+.wf-run-stats code {
+  font-size: 11px;
+}
+
+.wf-section-title {
+  margin: 16px 0 8px;
+  font-size: 11px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--text-secondary);
+}
+
+.wf-phases {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.wf-phase {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  padding: 3px 0;
+  font-size: 13px;
+}
+
+.wf-phase-mark {
+  flex-shrink: 0;
+  width: 12px;
+  color: var(--text-muted);
+}
+
+.wf-phase-mark.done {
+  color: var(--ok, #3fb950);
+}
+
+.wf-phase-title {
+  font-weight: 500;
+  color: var(--text-primary);
+}
+
+.wf-phase-detail {
+  color: var(--text-muted);
+  font-size: 12px;
+}
+
+.wf-agents {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.wf-agent {
+  display: grid;
+  grid-template-columns: 1fr auto auto auto 16px;
+  align-items: center;
+  gap: 12px;
+  padding: 6px 10px;
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  cursor: pointer;
+  font-size: 12px;
+  transition: border-color 0.15s ease;
+}
+
+.wf-agent:hover {
+  border-color: var(--accent, var(--plan));
+}
+
+.wf-agent-type {
+  font-weight: 500;
+  color: var(--text-primary);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.wf-agent-model,
+.wf-agent-tok,
+.wf-agent-dur {
+  font-family: var(--font-mono, monospace);
+  color: var(--text-secondary);
+  white-space: nowrap;
+}
+
+.wf-agent-status {
+  text-align: center;
+}
+
+.wf-agent-status.done {
+  color: var(--ok, #3fb950);
+}
+
+.wf-agent-status.running {
+  color: var(--accent, var(--plan));
+}
+
+.wf-empty {
+  font-size: 12px;
+  color: var(--text-muted);
+  padding: 4px 0;
+}
+
+.wf-source {
+  margin-top: 16px;
+}
+
+.wf-source > summary {
+  cursor: pointer;
+  font-size: 12px;
+  color: var(--text-secondary);
+  padding: 4px 0;
+}
+
+.wf-source > summary:hover {
+  color: var(--text-primary);
+}
+
 /* #endregion */
 
 .loop-section-title {

package/server.js

@@ -20,6 +20,8 @@ const {
   findTerminatedTeammates,
   extractPromptFromTranscript,
   extractModelFromTranscript,
+  extractStructuredResultFromTranscript,
+  extractTranscriptStats,
   readFullToolResult,
   readUserImage,
   readToolResultImage,
@@ -106,6 +108,10 @@ const PERMISSION_TTL_MS = 30 * 60 * 1000;
 const AGENT_TTL_MS = 60 * 60 * 1000;
 const AGENT_STALE_MS = 30 * 60 * 1000; // safety net for crashed sessions
 const SESSION_STALE_MS = 5 * 60 * 1000;
+// Keep an idle session in the active list this long after its last log write, so it
+// doesn't vanish the instant a turn ends. Ungated by registry-idle — visibility only,
+// 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;
@@ -333,6 +339,13 @@ function hasRecentLogActivity(sessionId, logAge) {
   return logAge <= SESSION_STALE_MS && !isRegistryIdle(sessionId);
 }
 
+// Visibility-only recency: hasRecentLogActivity widened by the post-turn grace
+// window (ungated by registry-idle). Drives whether a session appears in the
+// active list — never the "active" status badges, which stay on hasRecentLog.
+function hasVisibleLogActivity(sessionId, logAge) {
+  return logAge <= SESSION_GRACE_MS || hasRecentLogActivity(sessionId, logAge);
+}
+
 // 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) {
@@ -351,11 +364,20 @@ function resolveSelfTeamOwner(cfg) {
   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.
+// Attach a team-named task dir's counts to a session card, preferring the most recently written
+// dir (see taskDirBeats — "latest wins"). A resumed session owns several team dirs: a stale
+// prior-boot dir plus the current run's dir; the older "most tasks wins" rule attached the stale
+// dir when it had more tasks than the live one. The incumbent's mtime comes from the path-cached
+// counts (every card.tasksDir was already passed through getTaskCounts by the caller, so this is a
+// cache hit, not disk I/O). Caller passes the already-computed candidate counts.
 function attachTeamTasks(card, teamTaskDir, teamName, counts) {
-  if (!card.tasksDir || counts.taskCount > (card.taskCount || 0)) {
+  let curMtime = -1, curCount = -1;
+  if (card.tasksDir) {
+    const cur = getTaskCounts(card.tasksDir);
+    curMtime = taskDirMtime(cur);
+    curCount = cur.taskCount;
+  }
+  if (taskDirBeats(taskDirMtime(counts), counts.taskCount, curMtime, curCount)) {
     Object.assign(card, {
       taskCount: counts.taskCount,
       completed: counts.completed,
@@ -467,13 +489,14 @@ function getCustomTaskDir(sessionId) {
   // 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.
+  // A live session can own several team dirs at once: a stale dir from a prior boot of the same
+  // session id, plus the current run's dir (a resume creates a fresh self-team). Pick the most
+  // recently written dir ("latest wins") — the old "most tasks wins" rule picked the stale dir
+  // whenever a completed prior run had accumulated more tasks than the live one. taskCount breaks
+  // ties; empty dirs (no task mtime) lose, so a real dir still beats an empty self-team.
   if (existsSync(TEAMS_DIR)) {
     try {
-      let bestDir = null, bestCount = -1;
+      let bestDir = null, bestMtime = -1, bestCount = -1;
       for (const dir of readdirSync(TEAMS_DIR, { withFileTypes: true })) {
         if (!dir.isDirectory()) continue;
         const cfg = loadTeamConfig(dir.name);
@@ -483,9 +506,11 @@ function getCustomTaskDir(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;
+        const counts = getTaskCounts(teamTaskDir);
+        const mtime = taskDirMtime(counts);
+        if (taskDirBeats(mtime, counts.taskCount, bestMtime, bestCount)) {
+          bestMtime = mtime;
+          bestCount = counts.taskCount;
           bestDir = teamTaskDir;
         }
       }
@@ -501,6 +526,11 @@ function getTaskCounts(sessionPath) {
 
   const taskFiles = readdirSync(sessionPath).filter(f => f.endsWith('.json'));
   let completed = 0, inProgress = 0, pending = 0, newestTaskMtime = null;
+  // Directory mtime bumps when task files are added/removed, so it stays fresh even for an
+  // emptied dir (task list closed) that has no files left to date. Task-file mtime alone would
+  // report 0 for such a dir and lose "latest wins" to a stale prior-boot dir.
+  let dirMtime = 0;
+  try { dirMtime = statSync(sessionPath).mtimeMs; } catch (_) {}
 
   for (const file of taskFiles) {
     try {
@@ -518,11 +548,27 @@ function getTaskCounts(sessionPath) {
   }
 
   const taskCount = completed + inProgress + pending;
-  const result = { taskCount, completed, inProgress, pending, newestTaskMtime };
+  const result = { taskCount, completed, inProgress, pending, newestTaskMtime, dirMtime };
   taskCountsCache.set(sessionPath, result);
   return result;
 }
 
+// Last-write recency of a getTaskCounts() result, in ms: the newer of the directory mtime (bumps
+// on add/remove, so it survives an emptied dir) and the newest task-file mtime (bumps on in-place
+// status edits, which don't touch the dir). An emptied current dir thus still ranks by when it was
+// cleared, letting it win "latest wins" over a stale prior-boot dir instead of reporting 0.
+function taskDirMtime(counts) {
+  const fileMtime = counts.newestTaskMtime ? counts.newestTaskMtime.getTime() : 0;
+  return Math.max(counts.dirMtime || 0, fileMtime);
+}
+
+// "Latest wins" ranking for two owned task dirs of the same session: more recently written wins,
+// taskCount breaks ties. Callers seed the incumbent with mtime/count -1 so the first candidate
+// always wins.
+function taskDirBeats(candMtime, candCount, curMtime, curCount) {
+  return candMtime > curMtime || (candMtime === curMtime && candCount > curCount);
+}
+
 function cachedByMtime(cache, cacheKey, filePath, loadFn, fallback) {
   try {
     const cached = cache.get(cacheKey);
@@ -900,6 +946,7 @@ function buildSessionObject(id, meta, overrides = {}) {
     hasRunningAgents: false,
     hasWaitingForUser: false,
     hasRecentLog: hasRecentLogActivity(id, logAge),
+    hasRecentActivity: hasVisibleLogActivity(id, logAge),
     jsonlPath: meta.jsonlPath || null,
     tasksDir: null,
     projectDir: meta.jsonlPath ? path.dirname(meta.jsonlPath) : null,
@@ -958,9 +1005,8 @@ 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 = hasRecentLogActivity(entry.name, logAge);
             const cheaplyActive = logStat.hasMessages && (
-              hasRecentLog
+              hasVisibleLogActivity(entry.name, logAge)
               || agentStatus.hasActive
               || !!agentStatus.waitingForUser
               || (pending > 0 || inProgress > 0)
@@ -1059,9 +1105,8 @@ 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 = hasRecentLogActivity(sessionId, logAge);
           const cheaplyActive = logStat.hasMessages && (
-            hasRecentLog || metaAgentStatus.hasActive || !!metaAgentStatus.waitingForUser
+            hasVisibleLogActivity(sessionId, logAge) || metaAgentStatus.hasActive || !!metaAgentStatus.waitingForUser
           );
           if (!cheaplyActive) continue;
         }
@@ -1117,26 +1162,30 @@ app.get('/api/sessions', async (req, res) => {
           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.
+            // the tasks would be silently orphaned. Recover them: 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) {
+              // Attach even when empty: a resumed session's freshly-emptied current dir (task list
+              // closed) must be allowed to win "latest wins" and suppress its stale prior-boot dir,
+              // otherwise the card resurfaces the previous tasks. attachTeamTasks ranks by recency.
               attachTeamTasks(ownerCard, teamTaskDir, dir.name, counts);
             } else {
+              // No owner card to attach to — don't fabricate one for an empty stale self-team
+              // (that is the original noise case the skip suppressed).
+              if (counts.taskCount === 0) continue;
               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 taskMtime = taskDirMtime(counts);
               const card = buildSessionObject(leaderId, meta, {
                 _logStat: logStat,
                 name: getSessionDisplayName(leaderId, meta) || cfg.name || dir.name,
@@ -1246,7 +1295,7 @@ app.get('/api/sessions', async (req, res) => {
           (!s.sharedTaskList && (s.pending > 0 || s.inProgress > 0))
           || s.hasActiveAgents
           || s.hasWaitingForUser
-          || s.hasRecentLog
+          || s.hasRecentActivity
         );
       for (const [id, s] of sessionsMap) {
         if (pinnedIds.has(id)) continue;
@@ -1411,14 +1460,23 @@ app.get('/api/sessions/:sessionId/loop', (req, res) => {
   }
 });
 
-// API: List workflow scripts for a session
-app.get('/api/sessions/:sessionId/workflows', (req, res) => {
+// API: List workflow scripts for a session. Parses each script's meta for the
+// canonical name + description (cold path — only when the workflow modal opens).
+app.get('/api/sessions/:sessionId/workflows', async (req, res) => {
   try {
-    const workflows = getWorkflowScripts(req.params.sessionId).map((w) => ({
-      id: w.id,
-      name: w.name,
-      modifiedAt: w.mtimeMs ? new Date(w.mtimeMs).toISOString() : null,
-    }));
+    const scripts = getWorkflowScripts(req.params.sessionId);
+    const workflows = await Promise.all(
+      scripts.map(async (w) => {
+        let meta = {};
+        try { meta = parseWorkflowMeta(await fs.readFile(w.path, 'utf8')); } catch (_) {}
+        return {
+          id: w.id,
+          name: meta.name || w.name,
+          description: meta.description || null,
+          modifiedAt: w.mtimeMs ? new Date(w.mtimeMs).toISOString() : null,
+        };
+      }),
+    );
     res.json({ workflows });
   } catch (error) {
     console.error('Error listing workflows:', error);
@@ -1440,6 +1498,159 @@ app.get('/api/sessions/:sessionId/workflows/:wfId', async (req, res) => {
   }
 });
 
+// meta.phases and meta.name/description are pure literals per the Workflow tool
+// contract, so pull them by regex rather than executing the untrusted script.
+// name/description take the first match (the meta block is at the top of the file).
+// Pull a quoted string value for `key` out of `src` (matches ', ", or `).
+function matchStr(src, key) {
+  const m = src.match(new RegExp(`${key}\\s*:\\s*(['"\`])([\\s\\S]*?)\\1`));
+  return m ? m[2] : null;
+}
+
+function parseWorkflowMeta(source) {
+  const meta = { name: matchStr(source, 'name'), description: matchStr(source, 'description'), phases: [] };
+  const phasesM = source.match(/phases\s*:\s*\[([\s\S]*?)\]/);
+  if (phasesM) {
+    const re = /\{[\s\S]*?\}/g;
+    let m;
+    while ((m = re.exec(phasesM[1]))) {
+      const title = matchStr(m[0], 'title');
+      if (title) meta.phases.push({ title, detail: matchStr(m[0], 'detail') });
+    }
+  }
+  return meta;
+}
+
+// journal.jsonl records {type:'started',agentId} then {type:'result',agentId,...}
+// per workflow agent. Map agentId → {started, done}; done count matches the
+// "N/M agents" ratio the /workflows viewer shows.
+function readWorkflowJournal(runDir) {
+  const status = new Map();
+  let content;
+  try { content = readFileSync(path.join(runDir, 'journal.jsonl'), 'utf8'); } catch { return status; }
+  for (const line of content.split('\n')) {
+    if (!line.trim()) continue;
+    let o;
+    try { o = JSON.parse(line); } catch { continue; }
+    if (!o.agentId) continue;
+    const e = status.get(o.agentId) || { started: false, done: false };
+    if (o.type === 'started') e.started = true;
+    else if (o.type === 'result') e.done = true;
+    status.set(o.agentId, e);
+  }
+  return status;
+}
+
+// A workflow's run artifacts (journal + agent transcripts) live at
+// <sessionDir>/subagents/workflows/<wfId>/. The script itself sits under
+// <sessionDir>/workflows/scripts/, so the run dir is derivable from the script
+// path with no I/O — try that first. Fall back to the session dir from metadata,
+// then to scanning every project/session (the session dir can sit under a
+// different projEnc than the script when a workflow runs from another cwd). wfId
+// comes from the trusted script index (validated filename), so it can't
+// traverse. Cold path only.
+function resolveWorkflowRunDir(meta, wfId, scriptPath) {
+  const rel = path.join('subagents', 'workflows', wfId);
+  if (scriptPath) {
+    const sessionDir = path.dirname(path.dirname(path.dirname(scriptPath)));
+    const fromScript = path.join(sessionDir, rel);
+    if (existsSync(fromScript)) return fromScript;
+  }
+  if (meta.jsonlPath) {
+    const local = path.join(sessionDirFromMeta(meta), rel);
+    if (existsSync(local)) return local;
+  }
+  try {
+    for (const proj of readdirSync(PROJECTS_DIR, { withFileTypes: true })) {
+      if (!proj.isDirectory()) continue;
+      const projPath = path.join(PROJECTS_DIR, proj.name);
+      let sessDirs;
+      try { sessDirs = readdirSync(projPath, { withFileTypes: true }); } catch { continue; }
+      for (const s of sessDirs) {
+        if (!s.isDirectory()) continue;
+        const cand = path.join(projPath, s.name, rel);
+        if (existsSync(cand)) return cand;
+      }
+    }
+  } catch {}
+  return null;
+}
+
+// API: Workflow run state — declared phases (from the script) plus the agent
+// roster (type/model/output-tokens/duration/status) reconstructed from the run
+// dir's journal + transcripts. Phase↔agent mapping and per-agent labels are
+// runtime-only and never persisted, so the roster is flat by design.
+app.get('/api/sessions/:sessionId/workflows/:wfId/run', async (req, res) => {
+  try {
+    const wf = getWorkflowScripts(req.params.sessionId).find((w) => w.id === req.params.wfId);
+    if (!wf) return res.status(404).json({ error: 'Workflow not found' });
+    let source = '';
+    try { source = await fs.readFile(wf.path, 'utf8'); } catch (_) {}
+    const parsed = parseWorkflowMeta(source);
+
+    const sessionId = resolveSessionId(req.params.sessionId);
+    const meta = loadSessionMetadata()[sessionId] || {};
+    const runDir = resolveWorkflowRunDir(meta, wf.id, wf.path);
+    const journal = runDir ? readWorkflowJournal(runDir) : new Map();
+
+    const agents = [];
+    let stoppedAt = null;
+    if (runDir) {
+      let files = [];
+      try { files = readdirSync(runDir).filter((f) => /^agent-.+\.jsonl$/.test(f)); } catch (_) {}
+      for (const f of files) {
+        const agentId = f.slice('agent-'.length, -'.jsonl'.length);
+        const stats = 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 done = journal.get(agentId)?.done;
+        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;
+        agents.push({
+          agentId,
+          type,
+          model: stats.model || null,
+          outputTokens: stats.outputTokens || 0,
+          durationMs,
+          startedAt: stats.firstTs || null,
+          status: done ? 'done' : 'running',
+        });
+      }
+      agents.sort((a, b) => (a.startedAt || '').localeCompare(b.startedAt || ''));
+    }
+    // Roster is start-ordered, so the earliest start is simply the first agent.
+    const startedAt = agents[0]?.startedAt || null;
+
+    let startedCount = 0;
+    let doneCount = 0;
+    for (const e of journal.values()) {
+      if (e.started) startedCount++;
+      if (e.done) doneCount++;
+    }
+    if (!startedCount) {
+      startedCount = agents.length;
+      doneCount = agents.filter((a) => a.status === 'done').length;
+    }
+
+    res.json({
+      id: wf.id,
+      name: parsed.name || wf.name,
+      description: parsed.description,
+      phases: parsed.phases,
+      agents,
+      startedCount,
+      doneCount,
+      startedAt,
+      stoppedAt,
+    });
+  } catch (error) {
+    console.error('Error building workflow run view:', error);
+    res.status(500).json({ error: 'Failed to build workflow run view' });
+  }
+});
+
 function openInEditor(...targets) {
   const editor = process.env.EDITOR || 'code';
   spawn(editor, ['-n', ...targets], { shell: true, stdio: 'ignore', detached: true }).unref();
@@ -1680,6 +1891,27 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
       }
     }
 
+    // Workflow-spawned subagents given a schema end on a forced StructuredOutput
+    // tool call and never emit a text lastMessage — surface that structured result
+    // as the agent's response. Only stopped agents (complete transcript); latch
+    // resultUnavailable so we tail-read at most once per agent. Workflow subagents
+    // are exempt from the latch: the poll that flips them to "stopped" can beat the
+    // transcript's final StructuredOutput line to disk, latching resultUnavailable
+    // against an incomplete transcript — so always re-attempt for them, mirroring
+    // the prompt/name/description reconcile above.
+    const agentsNeedingResult = agents.filter(
+      (a) => !a.lastMessage && !isAgentLive(a) && (!a.resultUnavailable || a.type === 'workflow-subagent'),
+    );
+    if (agentsNeedingResult.length && meta.jsonlPath) {
+      for (const agent of agentsNeedingResult) {
+        let result = null;
+        try { result = extractStructuredResultFromTranscript(subagentJsonlForExtraction(meta, agent.agentId)); } catch (_) {}
+        if (result) agent.lastMessage = result;
+        else agent.resultUnavailable = true;
+        dirty.add(agent);
+      }
+    }
+
     for (const agent of dirty) persistAgent(agentDir, agent);
     const teamColors = {};
     if (teamConfig?.members) {