pi-kanban 0.1.3 → 0.3.0

package/README.md

@@ -2,10 +2,14 @@
 
 [![npm version](https://img.shields.io/npm/v/pi-kanban.svg)](https://www.npmjs.com/package/pi-kanban)
 
-Web dashboard for the [pi coding agent](https://pi.dev) — sessions, todos, subagents, observability.
+Web dashboard for the [pi coding agent](https://pi.dev/packages/pi-kanban?name=kanban) — sessions, todos, subagents, observability.
 
 ![pi-kanban dashboard](https://raw.githubusercontent.com/NikiforovAll/pi-kanban/main/assets/pi-kanban-poster.png)
 
+## Documentation
+
+**[→ See the documentation](https://nikiforovall.github.io/pi-kanban/docs/)**
+
 ## Try it now
 
 **[→ Open the live demo](https://nikiforovall.blog/pi-kanban/)**
@@ -39,8 +43,9 @@ pi install npm:@juicesharp/rpiv-todo
 
 - [`pi-subagents`](https://www.npmjs.com/package/pi-subagents) — spawns named subagent sessions; pi-kanban renders them under each parent session.
 - [`@juicesharp/rpiv-todo`](https://www.npmjs.com/package/@juicesharp/rpiv-todo) — task tracking that pi-kanban displays as kanban columns.
+- [`@juicesharp/rpiv-ask-user-question`](https://www.npmjs.com/package/@juicesharp/rpiv-ask-user-question) — pi-kanban surfaces these as interactive Q&A cards.
+
+## Demo
 
-## Documentation
 
-- [User guide](https://github.com/NikiforovAll/pi-kanban/blob/main/docs/user-guide.md) — slash commands, layout, sessions, subagents, storage manager, keyboard shortcuts.
-- [Theming](https://github.com/NikiforovAll/pi-kanban/blob/main/docs/theming.md) — built-in themes, configuration, custom theme authoring.
+![pi-kanban demo](https://raw.githubusercontent.com/NikiforovAll/pi-kanban/main/assets/pi-kanban-demo.gif)

package/extensions/kanban.ts

@@ -1,10 +1,11 @@
 import { spawn, spawnSync, type ChildProcess } from "node:child_process";
 import { createRequire } from "node:module";
-import { readFileSync } from "node:fs";
+import { readFileSync, statSync } from "node:fs";
 import { createConnection } from "node:net";
 import { homedir } from "node:os";
 import { isAbsolute, join as joinPath, resolve as resolvePath } from "node:path";
 import { fileURLToPath } from "node:url";
+import { Type } from "typebox";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 
 const extDir = fileURLToPath(new URL(".", import.meta.url));
@@ -121,6 +122,21 @@ async function postPreview(filePath: string, sessionId: string | null, link = fa
 	});
 }
 
+async function postPlan(id: string, planPath: string, title: string | null): Promise<Response> {
+	return api("/api/session/plan", {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ id, path: planPath, title }),
+	});
+}
+
+const PLAN_MAX_BYTES = 256 * 1024;
+
+function extractFirstHeading(markdown: string): string | null {
+	const m = markdown.match(/^#\s+(.+?)\s*$/m);
+	return m ? m[1].trim() : null;
+}
+
 function splitArgs(args: string): string[] {
 	return args.trim().split(/\s+/).filter(Boolean);
 }
@@ -195,6 +211,73 @@ export default function kanbanExtension(pi: ExtensionAPI) {
 		}
 	});
 
+	pi.registerTool({
+		name: "bind_plan",
+		label: "Bind Plan",
+		description:
+			"Attach a markdown plan file (e.g. plan.md) to the current session so the dashboard can render it.",
+		promptSnippet:
+			"Bind a markdown plan file to the current session — call after writing plan file",
+		promptGuidelines: [
+			"Use bind_plan once a planning markdown file exists so it surfaces in pi-kanban.",
+		],
+		parameters: Type.Object({
+			path: Type.String({
+				description: "Path to the plan markdown file. Absolute, or relative to the session cwd.",
+			}),
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const sessionId = ctx?.sessionManager?.getSessionId?.() ?? null;
+			const cwd = ctx?.sessionManager?.getCwd?.() ?? process.cwd();
+			const inputPath = String(params.path ?? "").trim();
+			if (!inputPath) {
+				return { content: [{ type: "text", text: "Error: path is required." }], isError: true };
+			}
+			const absPath = isAbsolute(inputPath) ? inputPath : resolvePath(cwd, inputPath);
+
+			let title: string | null = null;
+			try {
+				const stat = statSync(absPath);
+				if (!stat.isFile()) {
+					return { content: [{ type: "text", text: `Error: ${absPath} is not a file.` }], isError: true };
+				}
+				const buf = readFileSync(absPath, { encoding: "utf8" });
+				const head = buf.slice(0, PLAN_MAX_BYTES);
+				title = extractFirstHeading(head);
+			} catch (e: any) {
+				return {
+					content: [{ type: "text", text: `Error reading ${absPath}: ${e?.message ?? e}` }],
+					isError: true,
+				};
+			}
+
+			if (!sessionId) {
+				return {
+					content: [{ type: "text", text: "Error: no active session id; cannot bind plan." }],
+					isError: true,
+				};
+			}
+			try {
+				const res = await postPlan(sessionId, absPath, title);
+				if (!res.ok) {
+					const msg = `pi-kanban server rejected bind_plan: HTTP ${res.status}. Is /kanban running?`;
+					console.warn(msg);
+					return { content: [{ type: "text", text: msg }], isError: true };
+				}
+			} catch (e: any) {
+				const msg = `pi-kanban: bind_plan POST failed (server may be stopped): ${e?.message ?? e}`;
+				console.warn(msg);
+				return { content: [{ type: "text", text: msg }], isError: true };
+			}
+
+			const summary = title ? `Bound plan "${title}" → ${absPath}` : `Bound plan → ${absPath}`;
+			return {
+				content: [{ type: "text", text: summary }],
+				details: { path: absPath, title, sessionId },
+			};
+		},
+	});
+
 	type Notify = (m: string, l?: "info" | "error") => void;
 
 	async function startServer(notify: Notify, opts: { silentSuccess?: boolean } = {}): Promise<boolean> {

package/lib/pi-parsers.js

@@ -35,30 +35,28 @@ function decodeProjectDir(name) {
   return s.replace(/-/g, path.sep);
 }
 
-function listSessionFiles() {
-  if (!fs.existsSync(SESSIONS_DIR)) return [];
-  const out = [];
-  for (const projDir of fs.readdirSync(SESSIONS_DIR)) {
+async function listSessionFiles() {
+  let projDirs;
+  try { projDirs = await fs.promises.readdir(SESSIONS_DIR, { withFileTypes: true }); }
+  catch { return []; }
+  const projects = projDirs.filter((d) => d.isDirectory());
+  const perProject = await Promise.all(projects.map(async (d) => {
+    const projDir = d.name;
     const projPath = path.join(SESSIONS_DIR, projDir);
-    let stat;
-    try { stat = fs.statSync(projPath); } catch { continue; }
-    if (!stat.isDirectory()) continue;
-    for (const f of fs.readdirSync(projPath)) {
-      if (!f.endsWith('.jsonl')) continue;
-      const full = path.join(projPath, f);
-      let s;
-      try { s = fs.statSync(full); } catch { continue; }
-      if (!s.isFile()) continue;
-      out.push({
-        file: full,
-        projectDir: projDir,
-        cwd: decodeProjectDir(projDir),
-        mtime: s.mtime,
-        size: s.size,
-      });
-    }
-  }
-  return out;
+    let files;
+    try { files = await fs.promises.readdir(projPath, { withFileTypes: true }); }
+    catch { return []; }
+    const jsonls = files.filter((f) => f.isFile() && f.name.endsWith('.jsonl'));
+    const stats = await Promise.all(jsonls.map(async (f) => {
+      const full = path.join(projPath, f.name);
+      try {
+        const s = await fs.promises.stat(full);
+        return { file: full, projectDir: projDir, cwd: decodeProjectDir(projDir), mtime: s.mtime, mtimeMs: s.mtimeMs, size: s.size };
+      } catch { return null; }
+    }));
+    return stats.filter(Boolean);
+  }));
+  return perProject.flat();
 }
 
 async function readJsonlLines(file) {
@@ -76,7 +74,7 @@ function parseLine(line) {
   try { return JSON.parse(line); } catch { return null; }
 }
 
-async function readSessionEntries(file) {
+async function readSessionEntriesUncached(file) {
   const lines = await readJsonlLines(file);
   const entries = [];
   for (const l of lines) {
@@ -86,6 +84,57 @@ async function readSessionEntries(file) {
   return entries;
 }
 
+// Parsed entries + summary + tool/subagent indices keyed by file path; (mtimeMs, size) is
+// the validity tag. Invalidated by chokidar events via invalidateSessionCache().
+const sessionCache = new Map();
+
+function buildToolMaps(entries) {
+  const toolResultByCallId = new Map();
+  const subagentInfoByCallId = new Map();
+  for (const e of entries) {
+    if (e.type !== 'message') continue;
+    const m = e.message;
+    if (m && m.role === 'toolResult' && m.toolCallId) {
+      toolResultByCallId.set(m.toolCallId, m);
+      if (m.toolName === 'subagent' && m.details && Array.isArray(m.details.results) && m.details.results[0]) {
+        const r = m.details.results[0];
+        subagentInfoByCallId.set(m.toolCallId, {
+          runId: m.details.runId || null,
+          agent: r.agent || null,
+          runIndex: 0,
+          outputPath: r.artifactPaths && r.artifactPaths.outputPath ? r.artifactPaths.outputPath : null,
+          inputPath: r.artifactPaths && r.artifactPaths.inputPath ? r.artifactPaths.inputPath : null,
+        });
+      }
+    }
+  }
+  return { toolResultByCallId, subagentInfoByCallId };
+}
+
+async function getCachedSession(file, knownStat = null) {
+  const mtimeMs = knownStat ? knownStat.mtimeMs : null;
+  const size = knownStat ? knownStat.size : null;
+  const cached = sessionCache.get(file);
+  if (cached && knownStat && cached.mtimeMs === mtimeMs && cached.size === size) return cached;
+  const stat = knownStat || await fs.promises.stat(file);
+  if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) return cached;
+  const entries = await readSessionEntriesUncached(file);
+  const summary = summarize(entries);
+  const { toolResultByCallId, subagentInfoByCallId } = buildToolMaps(entries);
+  const entry = { mtimeMs: stat.mtimeMs, size: stat.size, entries, summary, toolResultByCallId, subagentInfoByCallId };
+  sessionCache.set(file, entry);
+  return entry;
+}
+
+async function readSessionEntries(file) {
+  return (await getCachedSession(file)).entries;
+}
+
+function invalidateSessionCache(file) {
+  if (file) sessionCache.delete(file);
+  else sessionCache.clear();
+}
+
 // Extract concrete agent spawns from a `subagent` toolCall arguments.
 // Returns [] for management calls (action:"list" etc) so they don't pollute the agent list.
 // Single spawn: {agent, task} -> [{agent, task}]
@@ -120,6 +169,12 @@ function expandSubagentSpawns(args) {
   return [];
 }
 
+function lastMapValue(map) {
+  let v;
+  for (v of map.values());
+  return v;
+}
+
 function summarize(entries) {
   let sessionEntry = null;
   let firstModel = null;
@@ -144,6 +199,8 @@ function summarize(entries) {
   const subagentByToolCallId = new Map();
   // `${runId}_${index}` -> rec, for /run slash-invoked subagents (custom_message)
   const subagentByRunKey = new Map();
+  // toolCallId -> { timestamp } for unanswered ask_user_question calls
+  const pendingAskUsers = new Map();
 
   for (const e of entries) {
     if (e.type === 'session') sessionEntry = e;
@@ -178,7 +235,9 @@ function summarize(entries) {
           for (const c of m.content) {
             if (c && c.type === 'toolCall') {
               toolCalls++;
-              if (c.name === 'subagent') {
+              if (c.name === 'ask_user_question' && c.id) {
+                pendingAskUsers.set(c.id, { timestamp: e.timestamp || null });
+              } else if (c.name === 'subagent') {
                 const items = expandSubagentSpawns(c.arguments);
                 if (items.length) {
                   const recs = items.map((it, i) => ({
@@ -205,11 +264,25 @@ function summarize(entries) {
         }
       } else if (m.role === 'toolResult') {
         toolResults++;
-        if (m.toolName === 'todo' && m.details && Array.isArray(m.details.tasks)) {
+        if (m.toolName === 'ask_user_question' && m.toolCallId) {
+          pendingAskUsers.delete(m.toolCallId);
+        } else if (m.toolName === 'todo' && m.details && Array.isArray(m.details.tasks)) {
           lastTodoTasks = m.details.tasks;
-        } else if (m.toolName === 'subagent' && m.details && Array.isArray(m.details.results)) {
+        } else if (m.toolName === 'subagent') {
           const pendingArr = m.toolCallId ? subagentByToolCallId.get(m.toolCallId) : null;
-          m.details.results.forEach((r, idx) => {
+          const results = m.details && Array.isArray(m.details.results) ? m.details.results : null;
+          if (!results && pendingArr && pendingArr.length) {
+            // Validation/spawn-time failure: pi wrote an error toolResult with no results.
+            const errText = Array.isArray(m.content)
+              ? (m.content.find((c) => c && c.type === 'text')?.text || '')
+              : '';
+            for (const rec of pendingArr) {
+              rec.stoppedAt = e.timestamp || null;
+              rec._error = rec._error || (errText ? errText.split('\n')[0].slice(0, 200) : 'Spawn failed');
+              if (rec.exitCode == null) rec.exitCode = -1;
+            }
+          }
+          (results || []).forEach((r, idx) => {
             let target = pendingArr && pendingArr[idx];
             if (!target) {
               const base = pendingArr && pendingArr[0];
@@ -222,7 +295,7 @@ function summarize(entries) {
               };
               subagents.push(target);
             }
-            target.runId = m.details.runId || target.runId;
+            target.runId = (m.details && m.details.runId) || target.runId;
             target.runIndex = idx;
             target.agent = r.agent || target.agent;
             target.prompt = target.prompt || r.task || null;
@@ -233,8 +306,11 @@ function summarize(entries) {
             target.sessionFile = r.sessionFile || null;
             target.artifactPaths = r.artifactPaths || null;
             target.stoppedAt = e.timestamp || null;
+            if (r.exitCode != null && r.exitCode !== 0 && !r.error && (r.finalOutput == null || r.finalOutput === '')) {
+              target._cancelled = true;
+            }
           });
-          if (m.details.results.length === 0 && pendingArr && pendingArr.length) {
+          if (results && results.length === 0 && pendingArr && pendingArr.length) {
             const text = Array.isArray(m.content) ? (m.content.find((c) => c && c.type === 'text')?.text || '') : '';
             const cancelled = /cancel/i.test(text);
             for (const rec of pendingArr) {
@@ -290,6 +366,9 @@ function summarize(entries) {
           // pi emits progress events without these fields; their presence marks completion.
           const isFinal = !!(r.model || r.artifactPaths || r.sessionFile || r.error);
           if (isFinal) target.stoppedAt = e.timestamp || target.stoppedAt;
+          if (isFinal && r.exitCode != null && r.exitCode !== 0 && !r.error && (r.finalOutput == null || r.finalOutput === '')) {
+            target._cancelled = true;
+          }
         });
       }
     }
@@ -316,6 +395,7 @@ function summarize(entries) {
     lastAssistantUsage,
     lastTodoTasks,
     subagents,
+    pendingAskUser: pendingAskUsers.size > 0 ? lastMapValue(pendingAskUsers) : null,
   };
 }
 
@@ -328,15 +408,18 @@ function agentIdFor(rec) {
 
 function subagentToApi(rec, lastMessage) {
   const stopped = !!rec.stoppedAt;
+  const cancelled = !!rec._cancelled;
   let desc = rec.progressSummary
     ? `${rec.progressSummary.toolCount ?? 0} tools · ${rec.progressSummary.tokens ?? 0} tokens`
     : null;
   if (rec._error) desc = `error · ${String(rec._error).split('\n')[0].slice(0, 80)}`;
+  else if (cancelled) desc = desc ? `cancelled · ${desc}` : 'cancelled';
   return {
     agentId: agentIdFor(rec),
     type: rec.agent || null,
     agentName: rec.agent || null,
-    status: stopped ? 'stopped' : 'active',
+    status: stopped ? (cancelled ? 'cancelled' : 'stopped') : 'active',
+    cancelled,
     startedAt: rec.startedAt || null,
     stoppedAt: rec.stoppedAt || null,
     updatedAt: rec.stoppedAt || rec.startedAt || null,
@@ -358,7 +441,7 @@ async function readSubagentOutput(rec) {
 }
 
 async function enrichPendingSubagents(meta, subagents) {
-  let pending = subagents.filter((r) => !r.runId);
+  let pending = subagents.filter((r) => !r.runId && !r.stoppedAt);
   if (pending.length === 0) return;
   const artifactsDir = path.join(path.dirname(meta.file), 'subagent-artifacts');
   let files = null;
@@ -403,10 +486,11 @@ async function enrichPendingSubagents(meta, subagents) {
     };
     rec.sessionFile = rec.artifactPaths.jsonlPath;
     rec._error = m.error || null;
+    if (m.exitCode != null && m.exitCode !== 0 && !m.error) rec._cancelled = true;
     if (m.toolCount != null) rec.progressSummary = { toolCount: m.toolCount, tokens: (m.usage?.input || 0) + (m.usage?.output || 0) };
   }
 
-  pending = subagents.filter((r) => !r.runId);
+  pending = subagents.filter((r) => !r.runId && !r.stoppedAt);
   if (pending.length === 0) return;
   await matchLiveSubagentRuns(meta, pending, subagents);
 }
@@ -470,28 +554,35 @@ async function matchLiveSubagentRuns(meta, pending, allSubagents) {
     rec.sessionFile = lr.jsonl;
   }
 
-  let parentMtime = 0;
-  try { parentMtime = (await fs.promises.stat(meta.file)).mtimeMs; } catch {}
-  const STALE_MS = 60_000;
-  const now = Date.now();
-  const parentStale = parentMtime && (now - parentMtime > STALE_MS);
+  // Structural staleness: while a subagent is running, the parent assistant is blocked
+  // waiting on its toolResult, so the parent jsonl can't have any later message other
+  // than that toolResult. If we see a newer message that isn't this subagent's own
+  // toolResult, pi has moved on and the spawn is orphaned. Tradeoff: a real pi crash
+  // with no further parent activity stays as "active" until the user restarts pi.
+  const parentEntries = (await getCachedSession(meta.file)).entries;
   for (const rec of pending) {
     if (rec.stoppedAt) continue;
-    let runMtime = 0;
-    if (rec.sessionFile) {
-      try { runMtime = (await fs.promises.stat(rec.sessionFile)).mtimeMs; } catch {}
-    }
-    const runStale = runMtime ? (now - runMtime > STALE_MS) : true;
-    if (parentStale && runStale) {
-      rec.stoppedAt = new Date(runMtime || parentMtime || now).toISOString();
+    if (!rec.startedAt) continue;
+    const startMs = new Date(rec.startedAt).getTime();
+    if (!startMs) continue;
+    const movedOn = parentEntries.some((e) => {
+      if (e.type !== 'message') return false;
+      const t = e.timestamp ? new Date(e.timestamp).getTime() : 0;
+      if (t <= startMs) return false;
+      const m = e.message;
+      if (m && m.role === 'toolResult' && m.toolName === 'subagent'
+          && rec.toolCallId && m.toolCallId === rec.toolCallId) return false;
+      return true;
+    });
+    if (movedOn) {
+      rec.stoppedAt = new Date().toISOString();
       rec._error = rec._error || 'Interrupted (no result recorded)';
     }
   }
 }
 
-async function listAgentsForSession(meta) {
-  const entries = await readSessionEntries(meta.file);
-  const s = summarize(entries);
+async function listAgentsForSession(meta, summary = null) {
+  const s = summary || (await getCachedSession(meta.file)).summary;
   const recs = s.subagents || [];
   await enrichPendingSubagents(meta, recs);
   const out = [];
@@ -509,13 +600,15 @@ async function findAgentRecord(meta, agentId) {
 }
 
 function tallyTasks(tasks) {
-  let pending = 0, inProgress = 0, completed = 0;
+  let pending = 0, inProgress = 0, completed = 0, total = 0;
   for (const t of tasks) {
+    if (t.status === 'deleted') continue;
+    total++;
     if (t.status === 'completed') completed++;
     else if (t.status === 'in_progress') inProgress++;
     else pending++;
   }
-  return { taskCount: tasks.length, pending, inProgress, completed };
+  return { taskCount: total, pending, inProgress, completed };
 }
 
 const MODEL_CONTEXT_WINDOWS = [
@@ -555,8 +648,8 @@ function slugFromFile(file) {
 const RECENT_MS = 5 * 60 * 1000;
 
 async function buildSessionSummary(meta) {
-  const entries = await readSessionEntries(meta.file);
-  const s = summarize(entries);
+  const cached = await getCachedSession(meta.file, meta.mtimeMs != null ? { mtimeMs: meta.mtimeMs, size: meta.size } : null);
+  const s = cached.summary;
   const id = (s.sessionEntry && s.sessionEntry.id) || slugFromFile(meta.file);
   const cwd = (s.sessionEntry && s.sessionEntry.cwd) || meta.cwd;
   const projectName = path.basename(cwd) || cwd;
@@ -574,13 +667,13 @@ async function buildSessionSummary(meta) {
     }),
     customTitle: s.customTitle || null,
     parentSession: (s.sessionEntry && s.sessionEntry.parentSession) || null,
-    ...tallyTasks(taskStore.listTasks(id)),
+    ...tallyTasks(await taskStore.listTasksAsync(id)),
     createdAt: s.sessionEntry && s.sessionEntry.timestamp,
     modifiedAt: meta.mtime.toISOString(),
     hasMessages: s.messageCount > 0,
     hasActiveAgents: false,
     hasRunningAgents: false,
-    hasWaitingForUser: false,
+    hasWaitingForUser: !!s.pendingAskUser,
     hasRecentLog: isRecent,
     jsonlPath: meta.file,
     tasksDir: null,
@@ -637,26 +730,26 @@ async function buildSessionSummary(meta) {
 }
 
 async function listSessions() {
-  const files = listSessionFiles();
+  const files = await listSessionFiles();
   files.sort((a, b) => b.mtime - a.mtime);
+  const summaries = await Promise.all(files.map(async (f) => {
+    try { return await buildSessionSummary(f); }
+    catch { return null; }
+  }));
   const out = [];
   const seen = new Set();
-  for (const f of files) {
-    try {
-      const summary = await buildSessionSummary(f);
-      if (summary.parentSession) continue;
-      if (seen.has(summary.id)) continue;
-      seen.add(summary.id);
-      out.push(summary);
-    } catch (err) {
-      // skip corrupt files
-    }
+  for (const summary of summaries) {
+    if (!summary) continue;
+    if (summary.parentSession) continue;
+    if (seen.has(summary.id)) continue;
+    seen.add(summary.id);
+    out.push(summary);
   }
   return out;
 }
 
 async function findSessionFileById(id) {
-  const files = listSessionFiles();
+  const files = await listSessionFiles();
   files.sort((a, b) => b.mtime - a.mtime);
   // First try filename match (faster)
   for (const f of files) {
@@ -714,22 +807,36 @@ function computeToolDetail(name, params) {
   }
   let detail = null;
   let full = null;
+  const trunc = (s, n = 80) => (s.length > n ? s.slice(0, n) + '...' : s);
   if (params.file_path) { detail = path.basename(params.file_path); full = params.file_path; }
   else if (params.path) { detail = path.basename(params.path); full = params.path; }
-  else if (params.command) { full = params.command; detail = full.length > 80 ? full.slice(0, 80) + '...' : full; }
+  else if (params.command) { full = params.command; detail = trunc(full); }
   else if (params.pattern) { full = params.pattern; detail = full; }
   else if (params.query) { full = params.query; detail = full; }
-  else if (params.queries) { full = Array.isArray(params.queries) ? params.queries.join(' | ') : String(params.queries); detail = full.length > 80 ? full.slice(0, 80) + '...' : full; }
-  else if (params.url) { full = params.url; detail = full.length > 80 ? full.slice(0, 80) + '...' : full; }
-  else if (params.task) { full = params.task; detail = full.length > 80 ? full.slice(0, 80) + '...' : full; }
+  else if (params.queries) { full = Array.isArray(params.queries) ? params.queries.join(' | ') : String(params.queries); detail = trunc(full); }
+  else if (params.url) { full = params.url; detail = trunc(full); }
+  else if (params.task) { full = params.task; detail = trunc(full); }
   else if (params.subject) { full = params.subject; detail = full; }
-  else if (params.description) { full = params.description; detail = full.length > 80 ? full.slice(0, 80) + '...' : full; }
-  else if (params.question) { full = params.question; detail = full.length > 80 ? full.slice(0, 80) + '...' : full; }
+  else if (params.description) { full = params.description; detail = trunc(full); }
+  else if (params.tasks && Array.isArray(params.tasks)) {
+    const agents = [...new Set(params.tasks.map((t) => t.agent).filter(Boolean))];
+    const n = params.tasks.length;
+    const agentStr = agents.length ? ` · ${agents.join(', ')}` : '';
+    detail = `${n} task${n > 1 ? 's' : ''}${agentStr}`;
+    full = detail;
+  }
+  else if (params.question) { full = params.question; detail = trunc(full); }
+  else if (params.questions && Array.isArray(params.questions)) {
+    const first = params.questions[0]?.question || '';
+    const extra = params.questions.length > 1 ? ` (+${params.questions.length - 1} more)` : '';
+    full = params.questions.map((q) => q.question).join(' | ');
+    detail = trunc(first, 60) + extra;
+  }
   else if (params.action) { detail = params.action; full = detail; }
   else if (params.operation) { detail = params.operation; full = detail; }
   else {
     try { full = JSON.stringify(params); } catch { full = ''; }
-    detail = full.length > 80 ? full.slice(0, 80) + '...' : full;
+    detail = trunc(full);
   }
   return { detail: detail || '', fullDetail: full && full !== detail ? full : null };
 }
@@ -767,26 +874,18 @@ async function readFileSafe(p) {
 }
 
 async function buildMessages(file, limit = 50, before = null) {
-  const entries = await readSessionEntries(file);
-  const toolResultByCallId = new Map();
-  const subagentInfoByCallId = new Map();
-  for (const e of entries) {
-    if (e.type !== 'message') continue;
-    const m = e.message;
-    if (m && m.role === 'toolResult' && m.toolCallId) {
-      toolResultByCallId.set(m.toolCallId, m);
-      if (m.toolName === 'subagent' && m.details && Array.isArray(m.details.results) && m.details.results[0]) {
-        const r = m.details.results[0];
-        subagentInfoByCallId.set(m.toolCallId, {
-          runId: m.details.runId || null,
-          agent: r.agent || null,
-          runIndex: 0,
-          outputPath: r.artifactPaths && r.artifactPaths.outputPath ? r.artifactPaths.outputPath : null,
-          inputPath: r.artifactPaths && r.artifactPaths.inputPath ? r.artifactPaths.inputPath : null,
-        });
-      }
-    }
+  const cached = await getCachedSession(file);
+  if (cached.allMessages) {
+    const filtered = before
+      ? cached.allMessages.filter((m) => m.timestamp && m.timestamp < before)
+      : cached.allMessages;
+    const total = filtered.length;
+    const sliced = limit && limit < total ? filtered.slice(-limit) : filtered;
+    return { messages: sliced, hasMore: sliced.length < total, sessionId: null };
   }
+  const entries = cached.entries;
+  const toolResultByCallId = cached.toolResultByCallId;
+  const subagentInfoByCallId = cached.subagentInfoByCallId;
 
   const messages = [];
   for (const e of entries) {
@@ -840,11 +939,15 @@ async function buildMessages(file, limit = 50, before = null) {
               toolResult: trText ? trText.slice(0, 1500) : null,
               toolResultTruncated: trText ? trText.length > 1500 : false,
             };
+            if (c.name === 'ask_user_question' && tr && tr.details && !tr.isError) {
+              msg.toolResultDetails = tr.details;
+            }
             if (c.name === 'subagent') {
               const info = subagentInfoByCallId.get(c.id);
               const agent = (c.arguments && c.arguments.agent) || (info && info.agent) || null;
               const runId = info && info.runId ? info.runId : null;
               const isSpawn = !!(c.arguments && c.arguments.task);
+              const isParallel = !!(c.arguments && Array.isArray(c.arguments.tasks));
               if (isSpawn) {
                 msg.tool = 'Agent';
                 msg.agentId = c.id ? `tc_${c.id}_${(info && info.runIndex) || 0}` : (runId && agent ? `${runId}_${agent}_${(info && info.runIndex) || 0}` : `pending_${Math.random().toString(36).slice(2, 10)}`);
@@ -853,6 +956,11 @@ async function buildMessages(file, limit = 50, before = null) {
                 msg.agentPrompt = c.arguments.task || null;
                 msg.agentLastMessage = info && info.outputPath ? await readFileSafe(info.outputPath) : null;
                 if (!msg.agentLastMessage && trText) msg.agentLastMessage = trText;
+              } else if (isParallel) {
+                msg.agentTasks = c.arguments.tasks;
+                if (tr && tr.details && Array.isArray(tr.details.results)) {
+                  msg.parallelResults = tr.details.results;
+                }
               }
             }
             messages.push(msg);
@@ -863,6 +971,7 @@ async function buildMessages(file, limit = 50, before = null) {
     // toolResult handled via map above.
   }
 
+  cached.allMessages = messages;
   const filtered = before
     ? messages.filter((m) => m.timestamp && m.timestamp < before)
     : messages;
@@ -886,4 +995,6 @@ module.exports = {
   findAgentRecord,
   slugFromFile,
   setOnBranchResolved,
+  flattenContentToText,
+  invalidateSessionCache,
 };