claude-code-kanban 5.3.0 → 5.4.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,7 +35,8 @@ 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');
@@ -46,6 +47,7 @@ const { createDispatchRegistry, formatPreamble, formatDispatchLine, isPeerName,
 const { createGroupStore, isGroupName, suggestGroupName } = require('./lib/dispatch-groups');
 const { createDispatchedStore, scanTranscripts, pruneSessionDirs, retentionMs } = require('./lib/retention');
 const { createWorktreeStore } = require('./lib/worktrees');
+const { readGitBranch } = 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,8 +343,8 @@ 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.
+// Only look up the branch when cwd has diverged from the launch project — that's
+// the only case the JSONL value is wrong.
 function resolveSessionGitBranch(meta) {
   if (meta.cwd && meta.project && meta.cwd !== meta.project) {
     return getGitBranch(meta.cwd) || meta.gitBranch || null;
@@ -366,13 +360,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 +780,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 +855,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 +942,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);
       }
@@ -1775,15 +1796,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 +1820,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 +1870,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 +2148,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 +2383,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 +2429,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 +2450,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 +2483,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 +2640,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 +2960,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 +2977,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 +3031,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 +3049,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/messages', asyncRoute(sendSessionMessages));
 
-app.get('/api/sessions/:sessionId/tool-result/:toolUseId', (req, res) => {
+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 +3159,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 +3173,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);
@@ -4248,7 +4260,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 +4320,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);

package/plugin/plugins/claude-code-kanban/scripts/agent-spy.sh

@@ -1,135 +0,0 @@
-#!/bin/bash
-# Tracks subagent lifecycle: one append-only JSONL file per agent, grouped by session
-# Layout: <CLAUDE_CONFIG_DIR or ~/.claude>/.cck/agent-activity/{sessionId}/{agentId}.jsonl
-# Each line is a lifecycle event (start | idle | stop). Server folds last-line-wins.
-
-INPUT=$(cat)
-
-# Single jq call to extract all routing fields
-eval "$(echo "$INPUT" | jq -r '
-  @sh "SESSION_ID=\(.session_id // "")",
-  @sh "AGENT_ID=\(.agent_id // "")",
-  @sh "EVENT=\(.hook_event_name // "")",
-  @sh "TOOL_NAME=\(.tool_name // "")",
-  @sh "AGENT_TYPE_RAW=\(.agent_type // "")",
-  @sh "TEAMMATE_NAME=\(.teammate_name // "")"
-')"
-
-[ -z "$SESSION_ID" ] && exit 0
-
-CCK_ACTIVITY="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/.cck/agent-activity"
-
-# Map session to custom task list on session start
-if [ "$EVENT" = "SessionStart" ]; then
-  TASK_LIST_ID="${CLAUDE_CODE_TASK_LIST_ID:-}"
-  if [ -n "$TASK_LIST_ID" ]; then
-    CWD=$(echo "$INPUT" | jq -r '.cwd // ""')
-    MAPS_DIR="$CCK_ACTIVITY/_task-maps"
-    mkdir -p "$MAPS_DIR"
-    MAP_FILE="$MAPS_DIR/$TASK_LIST_ID.json"
-    TMP_FILE="$MAP_FILE.$$"
-    TS=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-    EXISTING="{}"
-    [ -f "$MAP_FILE" ] && EXISTING=$(cat "$MAP_FILE")
-    echo "$EXISTING" | jq -c --arg sid "$SESSION_ID" --arg cwd "$CWD" --arg ts "$TS" \
-      '.[$sid] = {project: $cwd, updatedAt: $ts}' > "$TMP_FILE" && mv "$TMP_FILE" "$MAP_FILE"
-  fi
-  exit 0
-fi
-
-# Stop: the session finished its turn. The marker means unread; the board deletes it on open.
-if [ "$EVENT" = "Stop" ]; then
-  DIR="$CCK_ACTIVITY/$SESSION_ID"
-  [ -d "$DIR" ] || mkdir -p "$DIR"
-  : > "$DIR/_stop.json"
-  exit 0
-fi
-
-# PostToolUse / non-waiting PreToolUse: clear waiting state, and unread since the session is working again
-if [ "$EVENT" = "PostToolUse" ] || { [ "$EVENT" = "PreToolUse" ] && [ "$TOOL_NAME" != "AskUserQuestion" ] && [ "$TOOL_NAME" != "ExitPlanMode" ]; }; then
-  rm -f "$CCK_ACTIVITY/$SESSION_ID/_waiting.json" "$CCK_ACTIVITY/$SESSION_ID/_stop.json"
-  [ "$EVENT" = "PostToolUse" ] && exit 0
-fi
-
-# EnterPlanMode has no waiting semantics — skip
-[ "$TOOL_NAME" = "EnterPlanMode" ] && exit 0
-
-# Legacy-config shim: shipped hooks.json routes PermissionRequest to
-# approval-gate.sh (which owns the id-bearing marker) and registers no
-# PreToolUse, so the suppression and writer below only run for configs that
-# still route those events here. Suppressing question/plan PermissionRequest
-# keeps such a config from overwriting the gate's marker with an id-less one.
-if [ "$EVENT" = "PermissionRequest" ] && { [ "$TOOL_NAME" = "AskUserQuestion" ] || [ "$TOOL_NAME" = "ExitPlanMode" ]; }; then
-  exit 0
-fi
-
-# Waiting-for-user events → write _waiting.json marker
-if [ "$EVENT" = "PermissionRequest" ] || { [ "$EVENT" = "PreToolUse" ] && { [ "$TOOL_NAME" = "AskUserQuestion" ] || [ "$TOOL_NAME" = "ExitPlanMode" ]; }; }; then
-  DIR="$CCK_ACTIVITY/$SESSION_ID"
-  mkdir -p "$DIR"
-  KIND="permission"
-  [ "$EVENT" = "PreToolUse" ] && KIND="question"
-  TS=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-  echo "$INPUT" | jq -c --arg kind "$KIND" --arg ts "$TS" '{
-    status: "waiting",
-    kind: $kind,
-    toolName: (.tool_name // "unknown"),
-    toolInput: ((.tool_input | tostring) // ""),
-    timestamp: $ts
-  }' > "$DIR/_waiting.json"
-  exit 0
-fi
-
-# TeammateIdle has no agent_id — resolve via name→id mapping file
-if [ "$EVENT" = "TeammateIdle" ] && [ -z "$AGENT_ID" ] && [ -n "$TEAMMATE_NAME" ]; then
-  DIR="$CCK_ACTIVITY/$SESSION_ID"
-  MAP_FILE="$DIR/_name-${TEAMMATE_NAME}.id"
-  [ ! -f "$MAP_FILE" ] && exit 0
-  AGENT_ID=$(cat "$MAP_FILE")
-  [ -z "$AGENT_ID" ] && exit 0
-  FILE="$DIR/$AGENT_ID.jsonl"
-  TS=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-  echo "{\"agentId\":\"$AGENT_ID\",\"type\":\"$TEAMMATE_NAME\",\"event\":\"idle\",\"status\":\"idle\",\"updatedAt\":\"$TS\"}" >> "$FILE"
-  exit 0
-fi
-
-[ -z "$AGENT_ID" ] && exit 0
-
-DIR="$CCK_ACTIVITY/$SESSION_ID"
-FILE="$DIR/$AGENT_ID.jsonl"
-
-# On Start: skip if no type (internal agents like AskUserQuestion)
-# On Stop/Idle: only skip if no existing file (never tracked)
-if [ -z "$AGENT_TYPE_RAW" ]; then
-  if [ "$EVENT" = "SubagentStart" ]; then
-    exit 0
-  elif [ ! -f "$FILE" ]; then
-    exit 0
-  fi
-fi
-
-mkdir -p "$DIR"
-TS=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-
-if [ "$EVENT" = "SubagentStart" ]; then
-  echo "{\"agentId\":\"$AGENT_ID\",\"type\":\"$AGENT_TYPE_RAW\",\"event\":\"start\",\"status\":\"active\",\"startedAt\":\"$TS\",\"updatedAt\":\"$TS\"}" >> "$FILE"
-  # Mapping always points at latest agent of this type (used by TeammateIdle resolution).
-  if [ -n "$AGENT_TYPE_RAW" ]; then
-    echo -n "$AGENT_ID" > "$DIR/_name-${AGENT_TYPE_RAW}.id"
-  fi
-
-elif [ "$EVENT" = "SubagentStop" ]; then
-  # Omit empty type: the server folds lines last-key-wins, so an empty type
-  # here would clobber the type recorded by the start line
-  echo "$INPUT" | jq -c \
-    --arg id "$AGENT_ID" --arg type "$AGENT_TYPE_RAW" --arg ts "$TS" \
-    '{agentId: $id, event: "stop", status: "stopped",
-      lastMessage: (.last_assistant_message // ""), stoppedAt: $ts, updatedAt: $ts}
-     + (if $type == "" then {} else {type: $type} end)' \
-    >> "$FILE"
-
-elif [ "$EVENT" = "TeammateIdle" ]; then
-  TYPE_FIELD=""
-  [ -n "$AGENT_TYPE_RAW" ] && TYPE_FIELD="\"type\":\"$AGENT_TYPE_RAW\","
-  echo "{\"agentId\":\"$AGENT_ID\",${TYPE_FIELD}\"event\":\"idle\",\"status\":\"idle\",\"updatedAt\":\"$TS\"}" >> "$FILE"
-fi