claude-code-kanban 4.0.0 → 4.2.0

package/lib/parsers.js

@@ -118,16 +118,23 @@ const TOOL_RESULT_MAX = 1500;
 const USER_TEXT_MAX = 500;
 const INTERRUPT_MARKER = '[Request interrupted by user]';
 
-function pushUserMessage(messages, text, timestamp, sysLabel) {
+function pushUserMessage(messages, text, timestamp, sysLabel, extras) {
   if (sysLabel === '__skip__') return;
-  const truncated = text.length > USER_TEXT_MAX;
-  messages.push({
+  const safeText = text || '';
+  const truncated = safeText.length > USER_TEXT_MAX;
+  const msg = {
     type: 'user',
-    text: truncated ? text.slice(0, USER_TEXT_MAX) + '...' : text,
-    fullText: truncated ? text : null,
+    text: truncated ? safeText.slice(0, USER_TEXT_MAX) + '...' : safeText,
+    fullText: truncated ? safeText : null,
     timestamp,
     ...(sysLabel && { systemLabel: sysLabel })
-  });
+  };
+  if (extras) {
+    if (extras.uuid) msg.uuid = extras.uuid;
+    if (extras.images && extras.images.length) msg.images = extras.images;
+    if (extras.toolResultRefs && extras.toolResultRefs.length) msg.toolResultRefs = extras.toolResultRefs;
+  }
+  messages.push(msg);
 }
 
 // Cache: jsonlPath -> { scannedUpTo, customTitle }
@@ -135,19 +142,35 @@ function pushUserMessage(messages, text, timestamp, sysLabel) {
 const customTitleCache = new Map();
 const CUSTOM_TITLE_SCAN_SIZE = 1048576; // 1MB max scan on first read
 
+// Returns the best title found, in priority order:
+//   custom-title (user override) > ai-title > agent-name
+// Background-session JSONLs created by the "claude agents" feature only emit
+// ai-title/agent-name records; older sessions emit custom-title.
 function extractCustomTitleFromText(text) {
-  if (!text.includes('"custom-title"')) return null;
+  const hasCustom = text.includes('"custom-title"');
+  const hasAi = text.includes('"ai-title"');
+  const hasAgent = text.includes('"agent-name"');
+  if (!hasCustom && !hasAi && !hasAgent) return null;
   const lines = text.split('\n');
+  let customTitle = null;
+  let aiTitle = null;
+  let agentName = null;
   for (let i = lines.length - 1; i >= 0; i--) {
-    if (!lines[i].includes('"custom-title"')) continue;
+    const line = lines[i];
+    if (!line.includes('"custom-title"') && !line.includes('"ai-title"') && !line.includes('"agent-name"')) continue;
     try {
-      const data = JSON.parse(lines[i]);
-      if (data.type === 'custom-title' && data.customTitle && !data.customTitle.startsWith('<')) {
-        return data.customTitle;
+      const data = JSON.parse(line);
+      if (!customTitle && data.type === 'custom-title' && data.customTitle && !data.customTitle.startsWith('<')) {
+        customTitle = data.customTitle;
+      } else if (!aiTitle && data.type === 'ai-title' && data.aiTitle && !data.aiTitle.startsWith('<')) {
+        aiTitle = data.aiTitle;
+      } else if (!agentName && data.type === 'agent-name' && data.agentName && !data.agentName.startsWith('<')) {
+        agentName = data.agentName;
       }
+      if (customTitle) break;
     } catch (e) {}
   }
-  return null;
+  return customTitle || aiTitle || agentName || null;
 }
 
 function readCustomTitle(jsonlPath, existingStat) {
@@ -199,99 +222,147 @@ function scrapeScalarFromBlob(blob, re) {
 const sessionInfoCache = new Map();
 const SESSION_INFO_CACHE_MAX = 2000;
 
+// gitBranch in the JSONL is pinned to the launch-time repo by Claude Code
+// and goes stale once cwd shifts (Bash `cd`, submodule). Callers needing the
+// live branch must resolve it from cwd separately. Cache is reset on inode
+// change or truncation (size < scannedUpTo).
 function readSessionInfoFromJsonl(jsonlPath) {
   const result = { slug: null, projectPath: null, cwd: null, gitBranch: null, customTitle: null };
   let stat;
   let fd;
   try {
     stat = statSync(jsonlPath);
-    const cached = sessionInfoCache.get(jsonlPath);
-    if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
-      return { ...cached.result, customTitle: readCustomTitle(jsonlPath, stat) };
-    }
   } catch (_) {
     return result;
   }
-  // State shared across head-chunk parse, leftover flush, and tail parse.
-  let lastCwdFromHead = null;
+
+  const cached = sessionInfoCache.get(jsonlPath);
+  const inodeMatch = cached && cached.ino === stat.ino;
+  const sizeOK = cached && stat.size >= cached.scannedUpTo;
+  const canIncrement = inodeMatch && sizeOK;
+
+  if (canIncrement && stat.size === cached.scannedUpTo) {
+    return {
+      slug: cached.slug,
+      projectPath: cached.projectPath,
+      cwd: cached.cwd,
+      gitBranch: cached.gitBranch,
+      customTitle: readCustomTitle(jsonlPath, stat)
+    };
+  }
+
+  if (canIncrement) {
+    result.slug = cached.slug;
+    result.projectPath = cached.projectPath;
+    result.cwd = cached.cwd;
+    result.gitBranch = cached.gitBranch;
+  }
+
+  let lastCwdSeen = result.cwd;
   const applyLine = (line) => {
     try {
       const data = JSON.parse(line);
-      if (data.slug) result.slug = data.slug;
+      if (data.slug && !result.slug) result.slug = data.slug;
       if (data.cwd) {
         if (!result.projectPath) result.projectPath = data.cwd;
-        lastCwdFromHead = data.cwd;
+        lastCwdSeen = data.cwd;
       }
       if (data.gitBranch) result.gitBranch = data.gitBranch;
     } catch (e) {}
   };
+
+  const CHUNK_SIZE = 16384;
+  const TAIL_SIZE = 16384;
+  const HEAD_MAX = 1048576;
+  let scannedUpTo = canIncrement ? cached.scannedUpTo : 0;
+
   try {
     fd = fs.openSync(jsonlPath, 'r');
-    const CHUNK_SIZE = 16384;
-    const TAIL_SIZE = 16384;
-    // Stream head in chunks with StringDecoder to preserve multi-byte UTF-8
-    // codepoints across chunk boundaries. Scan up to HEAD_MAX so the last cwd
-    // in the window wins — sessions that change cwd mid-run must surface it.
-    const HEAD_MAX = 1048576;
-    const decoder = new StringDecoder('utf8');
-    const buf = Buffer.alloc(CHUNK_SIZE);
-    let leftover = '';
-    let offset = 0;
-    while (offset < stat.size && offset < HEAD_MAX) {
-      const len = Math.min(CHUNK_SIZE, stat.size - offset);
-      const n = fs.readSync(fd, buf, 0, len, offset);
-      if (n === 0) break;
-      offset += n;
-      const text = leftover + decoder.write(n === buf.length ? buf : buf.slice(0, n));
-      const lines = text.split('\n');
-      leftover = lines.pop();
-      for (const line of lines) applyLine(line);
-    }
-    leftover += decoder.end();
-    if (leftover) applyLine(leftover);
-    // Oversized first line (e.g. multi-MB inline image) left leftover unparsed
-    // above; scrape scalars out of it so we don't fall through to the tail and
-    // pick a mid-session cwd as projectPath.
-    if (!result.projectPath && leftover && leftover.length > CHUNK_SIZE) {
-      const scrapedCwd = scrapeScalarFromBlob(leftover, SCRAPE_CWD_RE);
-      if (scrapedCwd) { result.projectPath = scrapedCwd; lastCwdFromHead = scrapedCwd; }
-      if (!result.slug) result.slug = scrapeScalarFromBlob(leftover, SCRAPE_SLUG_RE);
-      if (!result.gitBranch) result.gitBranch = scrapeScalarFromBlob(leftover, SCRAPE_GITBRANCH_RE);
-    }
 
-    result.cwd = lastCwdFromHead;
-
-    // Tail scan: always runs when the file extends past the head window, so
-    // `cwd` reflects the latest value even in long sessions where a late cwd
-    // switch sits past HEAD_MAX. Also backfills projectPath/slug/gitBranch
-    // when the head couldn't find them. projectPath is NOT overwritten — it
-    // stays anchored to the earliest cwd seen.
-    if (stat.size > offset) {
-      const tailStart = Math.max(offset, stat.size - TAIL_SIZE);
-      const tailBuf = Buffer.alloc(TAIL_SIZE);
-      const tn = fs.readSync(fd, tailBuf, 0, TAIL_SIZE, tailStart);
-      const lines = tailBuf.toString('utf8', 0, tn).split('\n');
-      let latestTailCwd = null;
-      for (let i = lines.length - 1; i >= 0; i--) {
-        try {
-          const data = JSON.parse(lines[i]);
-          if (!result.slug && data.slug) result.slug = data.slug;
-          if (!result.projectPath && data.cwd) result.projectPath = data.cwd;
-          if (!result.gitBranch && data.gitBranch) result.gitBranch = data.gitBranch;
-          if (!latestTailCwd && data.cwd) latestTailCwd = data.cwd;
-          if (latestTailCwd && result.slug && result.projectPath && result.gitBranch) break;
-        } catch (e) {}
+    if (canIncrement) {
+      // Each conversational JSONL line carries `cwd`, so a mid-session `cd`
+      // surfaces in any tail window — we don't need the whole delta.
+      const DELTA_MAX = 1048576;
+      const deltaLen = stat.size - cached.scannedUpTo;
+      if (deltaLen > 0) {
+        const readLen = Math.min(deltaLen, DELTA_MAX);
+        const readStart = stat.size - readLen;
+        const buf = Buffer.alloc(readLen);
+        const n = fs.readSync(fd, buf, 0, readLen, readStart);
+        if (n > 0) {
+          const text = buf.toString('utf8', 0, n);
+          const lastNl = text.lastIndexOf('\n');
+          const complete = lastNl >= 0 ? text.slice(0, lastNl) : '';
+          const lines = complete.split('\n');
+          for (const line of lines) if (line) applyLine(line);
+        }
+        scannedUpTo = stat.size;
+      }
+    } else {
+      const decoder = new StringDecoder('utf8');
+      const buf = Buffer.alloc(CHUNK_SIZE);
+      let leftover = '';
+      let offset = 0;
+      while (offset < stat.size && offset < HEAD_MAX) {
+        const len = Math.min(CHUNK_SIZE, stat.size - offset);
+        const n = fs.readSync(fd, buf, 0, len, offset);
+        if (n === 0) break;
+        offset += n;
+        const text = leftover + decoder.write(n === buf.length ? buf : buf.slice(0, n));
+        const lines = text.split('\n');
+        leftover = lines.pop();
+        for (const line of lines) applyLine(line);
+      }
+      leftover += decoder.end();
+      if (leftover) applyLine(leftover);
+      // Oversized first line (e.g. multi-MB inline image) — scrape scalars so
+      // we don't fall through and pick a mid-session cwd as projectPath.
+      if (!result.projectPath && leftover && leftover.length > CHUNK_SIZE) {
+        const scrapedCwd = scrapeScalarFromBlob(leftover, SCRAPE_CWD_RE);
+        if (scrapedCwd) { result.projectPath = scrapedCwd; lastCwdSeen = scrapedCwd; }
+        if (!result.slug) result.slug = scrapeScalarFromBlob(leftover, SCRAPE_SLUG_RE);
+        if (!result.gitBranch) result.gitBranch = scrapeScalarFromBlob(leftover, SCRAPE_GITBRANCH_RE);
+      }
+
+      // Tail scan catches late cwd switches past HEAD_MAX. projectPath stays
+      // anchored to the earliest cwd — it is never overwritten here.
+      if (stat.size > offset) {
+        const tailStart = Math.max(offset, stat.size - TAIL_SIZE);
+        const tailBuf = Buffer.alloc(TAIL_SIZE);
+        const tn = fs.readSync(fd, tailBuf, 0, TAIL_SIZE, tailStart);
+        const lines = tailBuf.toString('utf8', 0, tn).split('\n');
+        let latestTailCwd = null;
+        for (let i = lines.length - 1; i >= 0; i--) {
+          try {
+            const data = JSON.parse(lines[i]);
+            if (!result.slug && data.slug) result.slug = data.slug;
+            if (!result.projectPath && data.cwd) result.projectPath = data.cwd;
+            if (!result.gitBranch && data.gitBranch) result.gitBranch = data.gitBranch;
+            if (!latestTailCwd && data.cwd) latestTailCwd = data.cwd;
+            if (latestTailCwd && result.slug && result.projectPath && result.gitBranch) break;
+          } catch (e) {}
+        }
+        if (latestTailCwd) lastCwdSeen = latestTailCwd;
       }
-      if (latestTailCwd) result.cwd = latestTailCwd;
+      scannedUpTo = stat.size;
     }
   } catch (e) {
   } finally {
     if (fd !== undefined) { try { fs.closeSync(fd); } catch (e) {} }
   }
 
+  result.cwd = lastCwdSeen;
+
   if (stat) {
-    const { customTitle: _ct, ...rest } = result;
-    sessionInfoCache.set(jsonlPath, { mtimeMs: stat.mtimeMs, size: stat.size, result: rest });
+    sessionInfoCache.set(jsonlPath, {
+      ino: stat.ino,
+      size: stat.size,
+      scannedUpTo,
+      slug: result.slug,
+      projectPath: result.projectPath,
+      gitBranch: result.gitBranch,
+      cwd: result.cwd
+    });
     if (sessionInfoCache.size > SESSION_INFO_CACHE_MAX) {
       const firstKey = sessionInfoCache.keys().next().value;
       sessionInfoCache.delete(firstKey);
@@ -532,16 +603,19 @@ function readRecentMessages(jsonlPath, limit = 10) {
               }
               pushUserMessage(messages, t, obj.timestamp, getSystemMessageLabel(t));
             } else if (Array.isArray(obj.message.content)) {
-              const joined = obj.message.content
-                .filter(b => b.type === 'text' && typeof b.text === 'string' && b.text)
-                .map(b => b.text)
-                .join('\n')
-                .trim();
-              if (joined && joined !== INTERRUPT_MARKER) {
-                pushUserMessage(messages, joined, obj.timestamp, getSystemMessageLabel(joined));
-              }
-              for (const block of obj.message.content) {
-                if (block.type === 'tool_result' && block.tool_use_id) {
+              const texts = [];
+              const images = [];
+              const toolResultRefs = [];
+              obj.message.content.forEach((block, idx) => {
+                if (block.type === 'text' && typeof block.text === 'string' && block.text) {
+                  texts.push(block.text);
+                } else if (block.type === 'image' && block.source && block.source.type === 'base64') {
+                  images.push({
+                    blockIndex: idx,
+                    mediaType: block.source.media_type || 'image/png',
+                    dataLen: typeof block.source.data === 'string' ? block.source.data.length : 0
+                  });
+                } else if (block.type === 'tool_result' && block.tool_use_id) {
                   let resultText = '';
                   if (typeof block.content === 'string') {
                     resultText = block.content;
@@ -554,7 +628,23 @@ function readRecentMessages(jsonlPath, limit = 10) {
                   if (resultText) {
                     toolResults.set(block.tool_use_id, resultText);
                   }
+                  toolResultRefs.push({
+                    toolUseId: block.tool_use_id,
+                    preview: resultText ? resultText.slice(0, 200) : ''
+                  });
                 }
+              });
+              const joined = texts.join('\n').trim();
+              const hasText = joined && joined !== INTERRUPT_MARKER;
+              const hasImages = images.length > 0;
+              if (hasText || hasImages) {
+                pushUserMessage(
+                  messages,
+                  joined,
+                  obj.timestamp,
+                  getSystemMessageLabel(joined),
+                  { uuid: obj.uuid, images, toolResultRefs: hasText ? toolResultRefs : [] }
+                );
               }
             }
           }
@@ -620,6 +710,31 @@ function readFullToolResult(jsonlPath, toolUseId) {
   return null;
 }
 
+function readUserImage(jsonlPath, msgUuid, blockIndex) {
+  if (!msgUuid || !jsonlPath) return null;
+  const idx = Number(blockIndex);
+  if (!Number.isInteger(idx) || idx < 0) return null;
+  try {
+    const content = readFileSync(jsonlPath, 'utf8');
+    const lines = content.split('\n');
+    for (const line of lines) {
+      if (!line || line.indexOf(msgUuid) === -1) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj?.uuid !== msgUuid) continue;
+        if (!Array.isArray(obj?.message?.content)) continue;
+        const block = obj.message.content[idx];
+        if (!block || block.type !== 'image' || !block.source || block.source.type !== 'base64') return null;
+        return {
+          mediaType: block.source.media_type || 'image/png',
+          data: block.source.data
+        };
+      } catch (_) {}
+    }
+  } catch (_) {}
+  return null;
+}
+
 function readMessagesPage(jsonlPath, limit = 10, beforeTimestamp = null) {
   const fetchLimit = limit + 1;
   const applyFilter = beforeTimestamp
@@ -902,6 +1017,121 @@ function extractModelFromTranscript(jsonlPath) {
   return null;
 }
 
+// Incremental loop-tool scanner. JSONL is append-only, so we keep per-path
+// state and on each call read ONLY the bytes appended since scannedOffset.
+// Avoids the only full-file read that ran inside the /api/sessions hot path.
+//
+// State shape: { mtimeMs, size, scannedOffset, wakeups[], crons[],
+//                taskIdByToolUseId<Map>, deletedTaskIds<Set> }
+const EMPTY_LOOP_STATE = () => ({
+  mtimeMs: 0, size: 0, scannedOffset: 0,
+  wakeups: [], crons: [],
+  taskIdByToolUseId: new Map(), deletedTaskIds: new Set()
+});
+
+function processLoopLine(line, state) {
+  if (!line) return;
+  const hasToolResult = line.includes('"tool_use_id"');
+  const hasLoopTool = line.includes('"ScheduleWakeup"')
+    || line.includes('"CronCreate"')
+    || line.includes('"CronDelete"');
+  if (!hasToolResult && !hasLoopTool) return;
+  let obj;
+  try { obj = JSON.parse(line); } catch (_) { return; }
+  const content = obj?.message?.content;
+  if (!Array.isArray(content)) return;
+  for (const b of content) {
+    if (!b) continue;
+    if (b.type === 'tool_result' && b.tool_use_id) {
+      const tid = obj.toolUseResult?.id;
+      if (tid) state.taskIdByToolUseId.set(b.tool_use_id, tid);
+    } else if (b.type === 'tool_use') {
+      const inp = b.input || {};
+      if (b.name === 'ScheduleWakeup') {
+        state.wakeups.push({
+          id: b.id || null,
+          timestamp: obj.timestamp || null,
+          delaySeconds: typeof inp.delaySeconds === 'number' ? inp.delaySeconds : null,
+          reason: inp.reason || null,
+          prompt: inp.prompt || null
+        });
+      } else if (b.name === 'CronCreate') {
+        state.crons.push({
+          id: b.id || null,
+          taskId: null,
+          timestamp: obj.timestamp || null,
+          cron: inp.cron || inp.cronExpression || null,
+          prompt: inp.prompt || null,
+          description: inp.description || inp.reason || null
+        });
+      } else if (b.name === 'CronDelete') {
+        const ids = inp.id ? [inp.id] : (Array.isArray(inp.ids) ? inp.ids : []);
+        for (const i of ids) state.deletedTaskIds.add(i);
+      }
+    }
+  }
+}
+
+// Reads bytes appended to jsonlPath since prev.scannedOffset and merges into
+// state. Pass `null` (or undefined) for prev to do a one-time full scan.
+function updateLoopInfo(jsonlPath, prev) {
+  let stat;
+  try { stat = statSync(jsonlPath); } catch (_) { return prev || EMPTY_LOOP_STATE(); }
+
+  let state = prev;
+  // Cold start OR file shrank (truncate/replace) → rescan from beginning.
+  if (!state || stat.size < state.size) {
+    state = EMPTY_LOOP_STATE();
+  } else if (state.mtimeMs === stat.mtimeMs && state.size === stat.size) {
+    return state; // unchanged
+  }
+
+  if (stat.size <= state.scannedOffset) {
+    state.mtimeMs = stat.mtimeMs;
+    state.size = stat.size;
+    return state;
+  }
+
+  let fd;
+  try {
+    fd = fs.openSync(jsonlPath, 'r');
+    const len = stat.size - state.scannedOffset;
+    const buf = Buffer.alloc(len);
+    const n = fs.readSync(fd, buf, 0, len, state.scannedOffset);
+    const text = buf.toString('utf8', 0, n);
+    const lastNl = text.lastIndexOf('\n');
+    if (lastNl < 0) {
+      // No complete line yet — leave scannedOffset alone, update mtime only.
+      state.mtimeMs = stat.mtimeMs;
+      return state;
+    }
+    const complete = text.slice(0, lastNl);
+    for (const line of complete.split('\n')) processLoopLine(line, state);
+    state.scannedOffset += Buffer.byteLength(complete, 'utf8') + 1;
+    state.mtimeMs = stat.mtimeMs;
+    state.size = stat.size;
+  } catch (_) {
+    // leave state as-is
+  } finally {
+    if (fd != null) { try { fs.closeSync(fd); } catch (_) {} }
+  }
+  return state;
+}
+
+function buildLoopInfoFromState(state) {
+  if (!state) return { wakeups: [], crons: [] };
+  // Resolve pending taskIds in place — taskIdByToolUseId is monotonic, so
+  // once resolved an entry stays resolved and we skip the spread-copy on
+  // every subsequent call.
+  for (const c of state.crons) {
+    if (!c.taskId) c.taskId = state.taskIdByToolUseId.get(c.id) || null;
+  }
+  const crons = state.deletedTaskIds.size
+    ? state.crons.filter(c => !c.taskId || !state.deletedTaskIds.has(c.taskId))
+    : state.crons;
+  return { wakeups: state.wakeups, crons };
+}
+
 module.exports = {
   parseTask,
   parseAgent,
@@ -913,6 +1143,9 @@ module.exports = {
   readRecentMessages,
   readMessagesPage,
   readFullToolResult,
+  readUserImage,
+  updateLoopInfo,
+  buildLoopInfoFromState,
   buildAgentProgressMap,
   buildSessionDigest,
   readCompactSummaries,

package/package.json

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

package/plugin/plugins/claude-code-kanban/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "claude-code-kanban",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Agent activity tracking for claude-code-kanban dashboard"
 }

package/plugin/plugins/claude-code-kanban/hooks/hooks.json

@@ -70,6 +70,16 @@
             "timeout": 5
           }
         ]
+      },
+      {
+        "matcher": "ExitPlanMode",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/scripts/agent-spy.sh",
+            "timeout": 5
+          }
+        ]
       }
     ],
     "PostToolUse": [

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

@@ -38,17 +38,17 @@ if [ "$EVENT" = "SessionStart" ]; then
 fi
 
 # PostToolUse / non-waiting PreToolUse: clear waiting state
-if [ "$EVENT" = "PostToolUse" ] || { [ "$EVENT" = "PreToolUse" ] && [ "$TOOL_NAME" != "AskUserQuestion" ]; }; then
+if [ "$EVENT" = "PostToolUse" ] || { [ "$EVENT" = "PreToolUse" ] && [ "$TOOL_NAME" != "AskUserQuestion" ] && [ "$TOOL_NAME" != "ExitPlanMode" ]; }; then
   WFILE="$CCK_ACTIVITY/$SESSION_ID/_waiting.json"
   rm -f "$WFILE"
   [ "$EVENT" = "PostToolUse" ] && exit 0
 fi
 
-# Plan mode tools don't fire PostToolUse — skip to avoid stale markers
-[ "$TOOL_NAME" = "EnterPlanMode" ] || [ "$TOOL_NAME" = "ExitPlanMode" ] && exit 0
+# EnterPlanMode has no waiting semantics — skip
+[ "$TOOL_NAME" = "EnterPlanMode" ] && exit 0
 
 # Waiting-for-user events → write _waiting.json marker
-if [ "$EVENT" = "PermissionRequest" ] || { [ "$EVENT" = "PreToolUse" ] && [ "$TOOL_NAME" = "AskUserQuestion" ]; }; then
+if [ "$EVENT" = "PermissionRequest" ] || { [ "$EVENT" = "PreToolUse" ] && { [ "$TOOL_NAME" = "AskUserQuestion" ] || [ "$TOOL_NAME" = "ExitPlanMode" ]; }; }; then
   DIR="$CCK_ACTIVITY/$SESSION_ID"
   mkdir -p "$DIR"
   KIND="permission"