claude-code-kanban 5.3.0 → 6.0.0

package/server.js

@@ -9,7 +9,7 @@ const _readline = require('node:readline');
 const chokidar = require('chokidar');
 const os = require('node:os');
 const crypto = require('node:crypto');
-const { spawnSync, spawn } = require('node:child_process');
+const { spawn } = require('node:child_process');
 const { assertOpenTarget, openInEditor, whichSync, exeBehindShim } = require('./lib/open-editor');
 const { createNetGuard } = require('./lib/net-guard');
 const { isContained } = require('./lib/contain');
@@ -35,17 +35,19 @@ const {
   readToolResultImage,
   readCachedImage,
   updateLoopInfo,
-  buildLoopInfoFromState
+  buildLoopInfoFromState,
+  readLines
 } = require('./lib/parsers');
 const { inlineHtmlAssets, MIME_BY_EXT } = require('./lib/inline-assets');
 const { buildDecision, decisionFileName, isDecisionFile, approvalsFrom, boardRefusal } = require('./lib/approvals');
 const { getClaudeDir, getArgValue, storageNamespace, isDefaultClaudeDir, encodeProjectDirName } = require('./lib/claude-dir');
 const { createTerminalService, readTerminalConfig } = require('./lib/terminal');
 const { createProcStats } = require('./lib/proc-stats');
-const { createDispatchRegistry, formatPreamble, formatDispatchLine, isPeerName, DISPATCH_OUTCOME } = require('./lib/dispatch');
+const { createDispatchRegistry } = require('./lib/dispatch');
 const { createGroupStore, isGroupName, suggestGroupName } = require('./lib/dispatch-groups');
 const { createDispatchedStore, scanTranscripts, pruneSessionDirs, retentionMs } = require('./lib/retention');
 const { createWorktreeStore } = require('./lib/worktrees');
+const { readGitBranch, sessionGitBranch } = require('./lib/git-branch');
 const { createLinkedDocStore, linkUrl } = require('./lib/linked-docs');
 const { pickFolder } = require('./lib/folder-dialog');
 const { loadSessionCache, saveSessionCache } = require('./lib/session-cache');
@@ -55,8 +57,8 @@ const { getParentVerdict, setParentVerdict } = require('./lib/parent-cache');
 
 if (process.argv.includes("--install") || process.argv.includes("--uninstall")) {
   const { runInstall, runUninstall } = require("./install");
-  const pluginOnly = process.argv.includes("--plugin-only");
-  (process.argv.includes("--install") ? runInstall({ pluginOnly }) : runUninstall())
+  const yes = process.argv.includes("--yes");
+  (process.argv.includes("--install") ? runInstall({ yes }) : runUninstall())
     .then(() => process.exit(0))
     .catch(e => { console.error(e.message); process.exit(1); });
 } else if (!require("./cli").runCli(process.argv)) {
@@ -136,7 +138,7 @@ function writePins(pins) {
   writeJsonAtomic(PINS_FILE, pins);
 }
 
-// Port discovery for out-of-process helpers (the postman monitor, approval-gate.sh).
+// Port discovery for out-of-process helpers (the postman monitor, the CLI).
 // The pid rides along so a reader can tell a live server from a file left behind by
 // a crashed one.
 function writeServerInfo(port) {
@@ -165,8 +167,8 @@ function ownerPid(file) {
   try { return JSON.parse(readFileSync(file, 'utf8')).pid ?? null; } catch (_) { return null; }
 }
 
-// A beacon that outlives its server disarms UI approvals silently: approval-gate.sh
-// probes the port, finds it closed and never waits. The hub spawns every sub-app on
+// A beacon that outlives its server sends the postman monitor and the CLI to a closed
+// port. The hub spawns every sub-app on
 // an ephemeral port, so a stale beacon never comes back on its own — drop ours on
 // the way out. Only when the file is still ours: a newer server on the same config
 // dir has already claimed it. The terminal token file goes the same way.
@@ -271,7 +273,10 @@ function checkWaitingForUser(agentDir, logMtime) {
       const age = Date.now() - waitTime;
       if (age >= PERMISSION_TTL_MS) return null;
       // After grace period, check if session resumed activity (user already responded)
-      if (logMtime && age >= WAITING_RESOLVE_GRACE_MS && logMtime > waitTime + WAITING_RESOLVE_GRACE_MS) return null;
+      if (movedOnSince(waitTime, logMtime)) return null;
+      // The mod sees the ask before auto mode's classifier decides it, and no dialog may follow.
+      // An ask from a settings rule always opens the dialog.
+      if (data.kind === 'permission' && !data.rule && loadSessionMetadata()[path.basename(agentDir)]?.permissionMode === 'auto') return null;
       // Opted out reads the same as lapsed to the board: the ask is only
       // answerable in the terminal, so no buttons.
       if (boardRefusal(data, approvalsConfig())) return { ...data, lapsed: true };
@@ -313,7 +318,7 @@ function isAgentLive(agent) {
 // Claude Code records gitBranch from the launch-time repo and never updates it
 // when cwd shifts (Bash `cd`, submodule, sibling repo). Resolve on-demand from
 // the live cwd instead. Cached per-cwd with a short TTL so a list refresh
-// across N sessions sharing one cwd spawns git at most once per TTL window.
+// across N sessions sharing one cwd reads HEAD at most once per TTL window.
 const gitBranchCache = new Map();
 const GIT_BRANCH_TTL_MS = 30000;
 const GIT_BRANCH_CACHE_MAX = 500;
@@ -322,18 +327,7 @@ function getGitBranch(cwd) {
   const now = Date.now();
   const cached = gitBranchCache.get(cwd);
   if (cached && now - cached.ts < GIT_BRANCH_TTL_MS) return cached.branch;
-  let branch = null;
-  try {
-    // cwd rather than `-C <cwd>`: a path beginning with a dash would otherwise be
-    // read by git as an option.
-    const r = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
-      cwd, encoding: 'utf8', timeout: 500, windowsHide: true
-    });
-    if (r.status === 0) {
-      const out = (r.stdout || '').trim();
-      if (out && out !== 'HEAD') branch = out;
-    }
-  } catch (_) {}
+  const branch = readGitBranch(cwd);
   gitBranchCache.set(cwd, { branch, ts: now });
   if (gitBranchCache.size > GIT_BRANCH_CACHE_MAX) {
     const firstKey = gitBranchCache.keys().next().value;
@@ -349,15 +343,6 @@ const worktrees = createWorktreeStore({
   save: (data) => writeJsonAtomic(WORKTREES_FILE, data),
 });
 
-// Only spawn git when cwd has diverged from the launch project — that's the
-// only case the JSONL value is wrong. Saves N spawns on a typical list build.
-function resolveSessionGitBranch(meta) {
-  if (meta.cwd && meta.project && meta.cwd !== meta.project) {
-    return getGitBranch(meta.cwd) || meta.gitBranch || null;
-  }
-  return meta.gitBranch || null;
-}
-
 function getSessionLogStat(meta) {
   if (!meta.jsonlPath) return { mtime: null, hasMessages: false };
   try {
@@ -366,13 +351,25 @@ function getSessionLogStat(meta) {
   } catch { return { mtime: null, hasMessages: false }; }
 }
 
+// A transcript write past the grace window after a marker means the session went on.
+function movedOnSince(markerMs, logMtime) {
+  return !!logMtime && logMtime > markerMs + WAITING_RESOLVE_GRACE_MS;
+}
+
+// The mod cannot delete _stop.json when the session works again.
+function resumedSince(markerPath, logMtime) {
+  if (!logMtime) return false;
+  try { return movedOnSince(statSync(markerPath).mtimeMs, logMtime); }
+  catch { return true; }
+}
+
 function checkAgentStatus(agentDir, stale, logMtime, isTeam) {
   const result = { hasActive: false, hasRunning: false, waitingForUser: null, unread: false };
   let names;
   try { names = readdirSync(agentDir); } catch { return result; }
   if (names.includes('_waiting.json')) result.waitingForUser = checkWaitingForUser(agentDir, logMtime);
   if (result.waitingForUser) result.hasActive = true;
-  const stopped = names.includes('_stop.json');
+  const stopped = names.includes('_stop.json') && !resumedSince(path.join(agentDir, '_stop.json'), logMtime);
   if (stale && !isTeam) {
     result.unread = stopped;
     return result;
@@ -774,33 +771,46 @@ function taskDirBeats(candMtime, candCount, curMtime, curCount) {
   return candMtime > curMtime || (candMtime === curMtime && candCount > curCount);
 }
 
+// A promise from loadFn is cached as is, so concurrent callers share one read, and a newer
+// mtime starts no second read while it is pending: full-transcript scans stream for seconds.
 function cachedByMtime(cache, cacheKey, filePath, loadFn, fallback) {
   try {
     const cached = cache.get(cacheKey);
-    if (cached && Date.now() - cached.ts < MESSAGE_CACHE_TTL) return cached.data;
+    if (cached && (cached.pending || Date.now() - cached.ts < MESSAGE_CACHE_TTL)) return cached.data;
     const st = statSync(filePath);
     if (cached && cached.mtime === st.mtimeMs) {
       cached.ts = Date.now();
       return cached.data;
     }
-    const data = loadFn();
-    cache.set(cacheKey, { data, mtime: st.mtimeMs, ts: Date.now() });
+    const entry = { data: loadFn(), mtime: st.mtimeMs, ts: Date.now() };
+    if (typeof entry.data?.then === 'function') {
+      entry.pending = true;
+      entry.data = entry.data.catch(() => {
+        if (cache.get(cacheKey) === entry) cache.delete(cacheKey);
+        return fallback;
+      }).finally(() => {
+        entry.pending = false;
+        entry.ts = Date.now();
+      });
+    }
+    cache.set(cacheKey, entry);
     evictStaleCache(cache);
-    return data;
+    return entry.data;
   } catch (_) { return fallback; }
 }
 
+// Express 4 does not pass a rejected handler promise to next(), and Node 24 exits on it.
+function asyncRoute(fn) {
+  return (req, res, next) => fn(req, res, next).catch(next);
+}
+
 const sessionDigestCache = new Map();
 function getSessionDigest(jsonlPath) {
   return cachedByMtime(sessionDigestCache, jsonlPath, jsonlPath, () => buildSessionDigest(jsonlPath), { progressMap: {}, terminated: new Map() });
 }
 
-function getProgressMap(jsonlPath) {
-  return getSessionDigest(jsonlPath).progressMap;
-}
-
-function getTerminatedTeammates(jsonlPath) {
-  return getSessionDigest(jsonlPath).terminated;
+async function getProgressMap(jsonlPath) {
+  return (await getSessionDigest(jsonlPath)).progressMap;
 }
 
 function readRecentMessages(jsonlPath, limit = 10) {
@@ -836,6 +846,7 @@ function refreshSessionMetadataPath(jsonlPath) {
   if (info.customTitle) existing.customTitle = info.customTitle;
   if (info.logicalParentUuid) existing.logicalParentUuid = info.logicalParentUuid;
   if (info.compactBoundaryUuid) existing.compactBoundaryUuid = info.compactBoundaryUuid;
+  existing.permissionMode = info.permissionMode;
   return true;
 }
 
@@ -922,7 +933,8 @@ function loadSessionMetadata() {
           customTitle: sessionInfo.customTitle || null,
           jsonlPath: jsonlPath,
           logicalParentUuid: sessionInfo.logicalParentUuid || null,
-          compactBoundaryUuid: sessionInfo.compactBoundaryUuid || null
+          compactBoundaryUuid: sessionInfo.compactBoundaryUuid || null,
+          permissionMode: sessionInfo.permissionMode
         };
         sessionIds.push(sessionId);
       }
@@ -1147,6 +1159,7 @@ function buildSessionObject(id, meta, overrides = {}) {
   const logStat = overrides._logStat || getSessionLogStat(meta);
   const logMtime = logStat.mtime;
   const logAge = logMtime ? Date.now() - logMtime : Infinity;
+  const worktree = worktrees.resolve(meta.project);
   return {
     id,
     name: getSessionDisplayName(id, meta),
@@ -1155,8 +1168,8 @@ function buildSessionObject(id, meta, overrides = {}) {
     project: meta.project || null,
     cwd: meta.cwd || null,
     description: meta.description || null,
-    gitBranch: resolveSessionGitBranch(meta),
-    worktree: worktrees.resolve(meta.project),
+    gitBranch: sessionGitBranch(meta, !!worktree, getGitBranch),
+    worktree,
     customTitle: meta.customTitle || null,
     taskCount: 0,
     completed: 0,
@@ -1610,6 +1623,30 @@ app.get('/api/sessions/search', (req, res) => {
   res.json(hits.slice(0, SESSION_SEARCH_MAX).map((h) => h.id));
 });
 
+app.get('/api/sessions/known', (_req, res) => {
+  res.setHeader('Cache-Control', 'no-store');
+  try {
+    const known = new Map();
+    for (const [id, meta] of Object.entries(loadSessionMetadata())) {
+      known.set(id, { id, project: meta.project || null, name: getSessionDisplayName(id, meta) });
+    }
+    const add = (id, project = null) => {
+      if (!known.has(id)) known.set(id, { id, project, name: null });
+    };
+    for (const dir of [TASKS_DIR, AGENT_ACTIVITY_DIR]) {
+      if (!existsSync(dir)) continue;
+      for (const d of readdirSync(dir, { withFileTypes: true })) if (d.isDirectory()) add(d.name);
+    }
+    for (const map of Object.values(loadAllTaskMaps().listToSessions)) {
+      for (const [id, info] of Object.entries(map)) add(id, info.project || null);
+    }
+    res.json([...known.values()]);
+  } catch (error) {
+    console.error('Error listing known sessions:', error);
+    res.status(500).json({ error: 'Failed to list known sessions' });
+  }
+});
+
 function isTempPath(p) {
   const rel = path.relative(TEMP_ROOT, p);
   return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel);
@@ -1775,15 +1812,20 @@ app.get('/api/sessions/:sessionId/loop', (req, res) => {
 
 // Memo for a cold read keyed on the file's identity, so a repeat ask costs the one stat
 // it already pays to notice the file grew. `load` may return a promise: the promise is
-// what gets cached, so concurrent callers share a single read. Null when the file is gone.
+// what gets cached, so concurrent callers share a single read, and a file that grows while
+// it is pending starts no second one. Null when the file is gone.
 function cachedByFileStat(cache, filePath, load) {
   let stat;
   try { stat = statSync(filePath); } catch (_) { return null; }
   const hit = cache.get(filePath);
-  if (hit && hit.mtimeMs === stat.mtimeMs && hit.size === stat.size) return hit.value;
-  const value = load();
-  cache.set(filePath, { mtimeMs: stat.mtimeMs, size: stat.size, value });
-  return value;
+  if (hit && (hit.pending || (hit.mtimeMs === stat.mtimeMs && hit.size === stat.size))) return hit.value;
+  const entry = { mtimeMs: stat.mtimeMs, size: stat.size, value: load() };
+  if (typeof entry.value?.then === 'function') {
+    entry.pending = true;
+    entry.value.finally(() => { entry.pending = false; }).catch(() => {});
+  }
+  cache.set(filePath, entry);
+  return entry.value;
 }
 
 // Cold path — a full transcript scan, so the result is held until the file grows.
@@ -1794,12 +1836,12 @@ function getArtifactLinks(jsonlPath) {
   return cachedByFileStat(artifactsByPath, jsonlPath, () => readArtifactLinks(jsonlPath)) || [];
 }
 
-app.get('/api/sessions/:sessionId/artifacts', (req, res) => {
+app.get('/api/sessions/:sessionId/artifacts', async (req, res) => {
   try {
     const metadata = loadSessionMetadata();
     const meta = metadata[req.params.sessionId] || metadata[resolveSessionId(req.params.sessionId)];
     if (!meta?.jsonlPath) return res.json({ artifacts: [] });
-    res.json({ artifacts: getArtifactLinks(meta.jsonlPath) });
+    res.json({ artifacts: await getArtifactLinks(meta.jsonlPath) });
   } catch (error) {
     console.error('Error reading artifacts:', error);
     res.status(500).json({ error: 'Failed to read artifacts' });
@@ -1844,7 +1886,7 @@ async function findPads(root, depth = 0) {
 // stored, so re-reading a transcript cannot drift; the client links each pad once
 // and records that it did, which is what stops a re-read undoing an unlink.
 async function readCreatedPads(meta) {
-  const creations = readScratchpadCreations(meta.jsonlPath);
+  const creations = await readScratchpadCreations(meta.jsonlPath);
   // No `scratch new` in the transcript means no disk work at all, so sessions that
   // never touch the CLI pay a substring pass over the transcript and nothing more.
   if (!creations.length) return [];
@@ -2122,7 +2164,7 @@ app.get('/api/sessions/:sessionId/workflows/:wfId/run', async (req, res) => {
       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)) || {};
+        const stats = (await extractTranscriptStats(path.join(runDir, f))) || {};
         let type = null;
         try {
           type = JSON.parse(readFileSync(path.join(runDir, `agent-${agentId}.meta.json`), 'utf8')).agentType || null;
@@ -2357,9 +2399,9 @@ app.get('/api/teams/:name', (req, res) => {
 // API: Get agents for a session
 // The resultUnavailable latch is persisted on the agent record. Bump this when
 // extractAgentResultFromTranscript finds more, so agents latched earlier rescan once.
-const RESULT_SCAN = 2;
+const RESULT_SCAN = 3;
 
-app.get('/api/sessions/:sessionId/agents', (req, res) => {
+app.get('/api/sessions/:sessionId/agents', async (req, res) => {
   const sessionId = resolveSessionId(req.params.sessionId);
   const agentDir = path.join(AGENT_ACTIVITY_DIR, sessionId);
   if (!existsSync(agentDir)) return res.json({ agents: [], waitingForUser: null });
@@ -2403,10 +2445,11 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
         agents.push(agent);
       } catch { /* skip invalid */ }
     }
+    const digest = meta.jsonlPath ? await getSessionDigest(meta.jsonlPath) : null;
     const liveAgents = agents.filter(isAgentLive);
     if (liveAgents.length && meta.jsonlPath) {
       try {
-        const terminated = getTerminatedTeammates(meta.jsonlPath);
+        const { terminated } = digest;
         if (terminated.size) {
           for (const agent of liveAgents) {
             const agentName = agentDisplayName(agent);
@@ -2423,10 +2466,9 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
       // Mark agents whose spawning Agent tool_use was rejected by the user as stopped:
       // the parent will never read their output, so they're orphans. Match by agentId
       // when the digest already correlated tool_use→agent, else fall back to prompt text
-      // (the agent-spy hook doesn't record the spawning tool_use_id).
+      // (the plugin's mod doesn't record the spawning tool_use_id).
       try {
-        const { rejectedAgentIds = new Set(), rejectedPrompts = new Set(), killedAgentIds = new Set() } =
-          getSessionDigest(meta.jsonlPath);
+        const { rejectedAgentIds = new Set(), rejectedPrompts = new Set(), killedAgentIds = new Set() } = digest;
         if (rejectedAgentIds.size || rejectedPrompts.size || killedAgentIds.size) {
           for (const agent of liveAgents) {
             if (!isAgentLive(agent)) continue;
@@ -2457,8 +2499,7 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
     const byAgentId = {};
     if (meta.jsonlPath) {
       try {
-        const progressMap = getProgressMap(meta.jsonlPath);
-        for (const entry of Object.values(progressMap)) {
+        for (const entry of Object.values(digest.progressMap)) {
           byAgentId[entry.agentId] ||= {};
           const e = byAgentId[entry.agentId];
           for (const f of ['prompt', 'name', 'description', 'usage']) {
@@ -2615,10 +2656,10 @@ app.post('/api/sessions/:sessionId/read', (req, res) => {
   }
 });
 
-// UI-driven approvals: answers the ask approval-gate.sh is blocking on by
-// writing _decision-<id>.json next to the marker. The hook consumes and deletes
-// both files; a write for a hook that already gave up is accepted anyway (D13)
-// and left for cleanupAgentActivity's sweep.
+// UI-driven approvals: answers the ask the plugin's mod is polling for by writing
+// _decision-<id>.json next to the marker. The mod cannot delete files, so it clears
+// the marker and leaves the decision, and a write for an ask that is already over
+// is accepted anyway (D13); cleanupAgentActivity's sweep removes both kinds.
 app.post('/api/sessions/:sessionId/waiting/respond', (req, res) => {
   const sessionId = resolveSessionId(req.params.sessionId);
   const dir = path.join(AGENT_ACTIVITY_DIR, sessionId);
@@ -2935,7 +2976,7 @@ app.get('/api/sessions/:sessionId/agents/:agentId/messages/stream', (req, res) =
   res.on('error', cleanup);
 });
 
-app.get('/api/sessions/:sessionId/messages', (req, res) => {
+async function sendSessionMessages(req, res) {
   const limit = Math.min(parseInt(req.query.limit, 10) || 10, 50);
   const before = req.query.before || null;
   const metadata = loadSessionMetadata();
@@ -2952,9 +2993,10 @@ app.get('/api/sessions/:sessionId/messages', (req, res) => {
     hasMore = messages.length > limit;
     if (hasMore) messages = messages.slice(-limit);
   }
+  const compactPromise = cachedByMtime(compactSummaryCache, jsonlPath, jsonlPath, () => readCompactSummaries(jsonlPath), []);
   const agentMessages = messages.filter(m => m.tool === 'Agent' && m.toolUseId);
   if (agentMessages.length) {
-    const progressMap = getProgressMap(jsonlPath);
+    const progressMap = await getProgressMap(jsonlPath);
     const resolvedSid = resolveSessionId(req.params.sessionId);
     const agentDir = path.join(AGENT_ACTIVITY_DIR, resolvedSid);
     for (const msg of agentMessages) {
@@ -3005,15 +3047,7 @@ app.get('/api/sessions/:sessionId/messages', (req, res) => {
       }
     }
   }
-  const cachedCompact = compactSummaryCache.get(jsonlPath);
-  let compactSummaries;
-  if (cachedCompact && Date.now() - cachedCompact.ts < MESSAGE_CACHE_TTL) {
-    compactSummaries = cachedCompact.data;
-  } else {
-    compactSummaries = readCompactSummaries(jsonlPath);
-    compactSummaryCache.set(jsonlPath, { data: compactSummaries, ts: Date.now() });
-    evictStaleCache(compactSummaryCache);
-  }
+  const compactSummaries = await compactPromise;
   // Match compaction messages to summaries by chronological order
   const compactedMsgs = messages
     .filter(m => m.systemLabel === 'Compacted')
@@ -3031,29 +3065,30 @@ app.get('/api/sessions/:sessionId/messages', (req, res) => {
     delete msg.promptId;
   }
   res.json({ messages, hasMore, sessionId: req.params.sessionId });
-});
+}
 
-app.get('/api/sessions/:sessionId/tool-result/:toolUseId', (req, res) => {
+app.get('/api/sessions/:sessionId/messages', asyncRoute(sendSessionMessages));
+
+app.get('/api/sessions/:sessionId/tool-result/:toolUseId', asyncRoute(async (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).json({ error: 'session not found' });
-  const content = readFullToolResult(jsonlPath, req.params.toolUseId);
+  const content = await readFullToolResult(jsonlPath, req.params.toolUseId);
   if (content == null) return res.status(404).json({ error: 'tool result not found' });
   res.json({ toolUseId: req.params.toolUseId, content });
-});
+}));
 
 const toolStatsCache = new Map();
 
-function buildToolStats(jsonlPath) {
+async function buildToolStats(jsonlPath) {
   const toolUseById = {};     // tool_use_id -> { displayName, isSkill }
   const seenResults = new Set();
   const toolMap = {};         // displayName -> { count, success, failed, outputBytes }
   const skillPromptIds = {};  // promptId -> [skillDisplayName, ...]
   const promptOutputBytes = {}; // promptId -> total outputBytes in that turn
 
-  const content = readFileSync(jsonlPath, 'utf8');
-  for (const line of content.split('\n')) {
+  for await (const line of readLines(jsonlPath)) {
     if (!line) continue;
     let obj;
     try { obj = JSON.parse(line); } catch (_) { continue; }
@@ -3140,13 +3175,13 @@ function buildToolStats(jsonlPath) {
   return { totalCalls, uniqueTools, totalFailed, totalRejected, tools };
 }
 
-app.get('/api/sessions/:sessionId/tool-stats', (req, res) => {
+app.get('/api/sessions/:sessionId/tool-stats', async (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).json({ error: 'session not found' });
   try {
-    const data = cachedByMtime(toolStatsCache, jsonlPath, jsonlPath, () => buildToolStats(jsonlPath), null);
+    const data = await cachedByMtime(toolStatsCache, jsonlPath, jsonlPath, () => buildToolStats(jsonlPath), null);
     if (!data) return res.status(404).json({ error: 'could not parse session' });
     res.json({ sessionId: req.params.sessionId, ...data });
   } catch (e) {
@@ -3154,31 +3189,24 @@ app.get('/api/sessions/:sessionId/tool-stats', (req, res) => {
   }
 });
 
-app.get('/api/sessions/:sessionId/user-image/:msgUuid/:blockIndex', (req, res) => {
+async function sendTranscriptImage(req, res, read) {
   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 = readUserImage(jsonlPath, req.params.msgUuid, req.params.blockIndex);
+  const img = await read(jsonlPath);
   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/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/user-image/:msgUuid/:blockIndex', asyncRoute((req, res) =>
+  sendTranscriptImage(req, res, (p) => readUserImage(p, req.params.msgUuid, req.params.blockIndex))));
+
+app.get('/api/sessions/:sessionId/tool-result-image/:toolUseId/:n', asyncRoute((req, res) =>
+  sendTranscriptImage(req, res, (p) => readToolResultImage(p, req.params.toolUseId, req.params.n))));
 
 app.get('/api/sessions/:sessionId/cached-image/:n', (req, res) => {
   const img = readCachedImage(req.params.sessionId, req.params.n, CLAUDE_DIR);
@@ -3264,7 +3292,9 @@ const terminal = createTerminalService({
   isAllowedFolder,
   liveSessions: () => loadLiveSessions(true),
   onChange: () => broadcast({ type: 'terminals-update', ids: terminal.list().map((t) => t.id) }),
-  onExit: (id) => dispatches.sessionExited(id),
+  onExit: (id) => {
+    if (dispatches.remove(id)) broadcast({ type: 'dispatch-update' });
+  },
 });
 
 let folderDialogOpen = false;
@@ -3334,13 +3364,7 @@ const dispatched = createDispatchedStore({
   save: (data) => writeJsonAtomic(DISPATCHED_FILE, data),
 });
 
-const dispatches = createDispatchRegistry({
-  onSettle: (r) => {
-    if (r.parent && r.report) enqueueSessionEvent(topicKey('dispatch', r.parent), formatDispatchLine(r));
-    if (r.session) dispatched.settle(r.session, r.status);
-    broadcast({ type: 'dispatch-update' });
-  },
-});
+const dispatches = createDispatchRegistry();
 
 const dispatchGroups = createGroupStore({
   load: () => {
@@ -3359,8 +3383,6 @@ const linkedDocs = createLinkedDocStore({
 });
 
 // The board places a session from these alone, so it never has to move it later.
-// `startedBy` lets it follow a starter the user put in a named group, which only the
-// browser knows; it goes once the dispatch settles. `dispatched` stays for the card's marker.
 function withDispatchPlacement(sessions) {
   const groups = dispatchGroups.snapshot();
   return sessions.map((s) => {
@@ -3370,56 +3392,35 @@ function withDispatchPlacement(sessions) {
     return {
       ...s,
       dispatchGroup,
-      startedBy: marker?.status === 'running' ? marker.parent || undefined : undefined,
-      dispatched: marker ? { parent: marker.parent, outcome: DISPATCH_OUTCOME[marker.status] } : undefined,
+      dispatched: marker ? { parent: marker.parent } : undefined,
     };
   });
 }
 
 // Starting a session needs the terminal token, as the browser does; the CLI reads it from
-// TERMINAL_TOKEN_FILE. The child gets only its dispatch capability through the preamble.
+// TERMINAL_TOKEN_FILE. The started session never holds it.
 app.post('/api/dispatch', (req, res) => {
   if (!terminal.authorized(req.get('x-terminal-token'))) return res.status(401).json({ error: 'invalid terminal token' });
-  const { cwd, spec, name, model, worktree, parent, group, report, peer } = req.body || {};
+  const { cwd, spec, name, model, worktree, parent, group, claudeArgs } = req.body || {};
   if (typeof spec !== 'string' || !spec.trim()) return res.status(400).json({ error: 'spec is required' });
-  if (peer != null && !isPeerName(peer)) return res.status(400).json({ error: 'peer must be a peer name as ListAgents prints it' });
   if (parent != null && !(typeof parent === 'string' && isUUID(parent))) return res.status(400).json({ error: 'invalid parent' });
   if (group != null && !isGroupName(group)) {
     return res.status(400).json({ error: `group must be kebab-case, e.g. ${suggestGroupName(group) || 'my-group'}` });
   }
-  const target = group || (parent && dispatchGroups.groupOf(parent)) || null;
-  const r = dispatches.create({ parent, name, spec: spec.trim(), report: report === true, peer, group: target, worktree });
-  const env = { CCK_DISPATCH_ID: r.id, ...(parent && { PARENT_SESSION_ID: parent }) };
-  const started = terminal.startNew({ cwd, name, model, worktree, prompt: formatPreamble(r) }, env);
-  if (started.error) {
-    dispatches.discard(r.id);
-    return res.status(started.status).json({ error: started.error });
-  }
-  dispatches.attach(r.id, { session: started.id, cwd: started.cwd });
+  const started = terminal.startNew({ cwd, name, model, worktree, prompt: spec.trim(), extraArgs: claudeArgs });
+  if (started.error) return res.status(started.status).json({ error: started.error });
+  dispatches.add({ session: started.id, parent, cwd: started.cwd, name, group: group || null, worktree });
   dispatched.record(started.id, parent);
   // The starter stays where it is: moving it would jump it under the user.
-  if (target) dispatchGroups.join(target, [started.id], parent);
+  if (group) dispatchGroups.join(group, [started.id]);
   broadcast({ type: 'dispatch-update' });
-  res.status(201).json({ dispatch: r.id, session: started.id, cwd: started.cwd, group: target });
+  res.status(201).json({ session: started.id, cwd: started.cwd, group: group || null });
 });
 
-app.post('/api/dispatch/:id/done', (req, res) => {
-  const { cap, outcome, summary } = req.body || {};
-  const err = dispatches.settle(req.params.id, cap, outcome, summary);
-  if (err) return res.status(err.status).json({ error: err.error });
-  res.status(204).end();
-});
-
-app.get('/api/dispatch', async (req, res) => {
+app.get('/api/dispatch', (req, res) => {
   res.setHeader('Cache-Control', 'no-store');
-  const ids = typeof req.query.ids === 'string' && req.query.ids ? req.query.ids.split(',') : null;
   const parent = typeof req.query.parent === 'string' && req.query.parent ? req.query.parent : null;
-  // res, not req: a GET's request stream can close before the response is sent.
-  const out = await dispatches.wait({ ids, parent }, req.query.wait, (stop) => {
-    res.on('close', stop);
-    return () => res.off('close', stop);
-  });
-  if (!res.writableEnded) res.json(out);
+  res.json({ running: dispatches.list({ parent }) });
 });
 // #endregion
 
@@ -3484,7 +3485,6 @@ const {
   formatTaskMoved,
   handleSessionEvents,
   hasSessionListener,
-  topicKey,
 } = require('./lib/session-events');
 app.get('/api/sessions/:sessionId/events', handleSessionEvents);
 
@@ -4248,7 +4248,7 @@ agentActivityWatcher.on('all', (event, filePath) => {
   }
 });
 
-// Watch context-status directory for statusline updates
+// Watch context-status directory for the plugin's context and cost updates
 const contextStatusWatcher = chokidar.watch(CONTEXT_STATUS_DIR, {
   persistent: true,
   ignoreInitial: false,
@@ -4308,9 +4308,8 @@ async function cleanupAgentActivity() {
           await fs.rm(dirPath, { recursive: true, force: true });
           continue;
         }
-        // Orphaned decision files: a terminal deny fires no hook event (D13), so a
-        // board answer for an already-gone gate is never consumed. The gate waits at
-        // most PERMISSION_TTL_MS, so anything older is unclaimable.
+        // Mods cannot delete files, so every decision file is swept here. The mod
+        // waits at most PERMISSION_TTL_MS, so anything older is unclaimable.
         for (const f of contents) {
           if (!isDecisionFile(f)) continue;
           const fp = path.join(dirPath, f);