claude-code-kanban 4.28.0 → 4.30.0

package/lib/parsers.js

@@ -1,7 +1,8 @@
-const fs = require('fs');
+const fs = require('node:fs');
 const { readFileSync, existsSync, readdirSync, statSync } = fs;
-const path = require('path');
-const { StringDecoder } = require('string_decoder');
+const path = require('node:path');
+const os = require('node:os');
+const { StringDecoder } = require('node:string_decoder');
 
 function parseTask(raw) {
   const task = typeof raw === 'string' ? JSON.parse(raw) : raw;
@@ -12,7 +13,7 @@ function parseTask(raw) {
     status: task.status,
     blocks: task.blocks || [],
     blockedBy: task.blockedBy || [],
-    isInternal: !!(task.metadata && task.metadata._internal),
+    isInternal: !!task.metadata?._internal,
     raw: task
   };
 }
@@ -152,12 +153,12 @@ function formatTaskUsage(usage) {
   const parts = [];
   if (usage.subagentTokens != null) {
     const t = usage.subagentTokens;
-    const tok = t >= 1000 ? (t / 1000).toFixed(1).replace(/\.0$/, '') + 'k' : String(t);
-    parts.push(tok + ' tok');
+    const tok = t >= 1000 ? `${(t / 1000).toFixed(1).replace(/\.0$/, '')}k` : String(t);
+    parts.push(`${tok} tok`);
   }
   if (usage.toolUses != null) parts.push(usage.toolUses + (usage.toolUses === 1 ? ' tool' : ' tools'));
-  if (usage.durationMs != null) parts.push(Math.round(usage.durationMs / 1000) + 's');
-  return parts.length ? ' · ' + parts.join(' · ') : '';
+  if (usage.durationMs != null) parts.push(`${Math.round(usage.durationMs / 1000)}s`);
+  return parts.length ? ` · ${parts.join(' · ')}` : '';
 }
 
 // Raw per-agent cost for the agent modal's chips plus the formatted one-liner for
@@ -196,7 +197,7 @@ function pushUserMessage(messages, text, timestamp, sysLabel, extras) {
   const truncated = safeText.length > USER_TEXT_MAX;
   const msg = {
     type: 'user',
-    text: truncated ? safeText.slice(0, USER_TEXT_MAX) + '...' : safeText,
+    text: truncated ? `${safeText.slice(0, USER_TEXT_MAX)}...` : safeText,
     fullText: truncated ? safeText : null,
     timestamp,
     ...(label && { systemLabel: label })
@@ -214,8 +215,8 @@ function pushUserMessage(messages, text, timestamp, sysLabel, extras) {
   }
   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;
+    if (extras.images?.length) msg.images = extras.images;
+    if (extras.toolResultRefs?.length) msg.toolResultRefs = extras.toolResultRefs;
     if (extras.queued) msg.queued = true;
   }
   // One agent message reaches the log twice: the queued enqueue record and the
@@ -231,27 +232,37 @@ function pushUserMessage(messages, text, timestamp, sysLabel, extras) {
   messages.push(msg);
 }
 
-// Cache: jsonlPath -> { scannedUpTo, customTitle }
+// Cache: jsonlPath -> { ino, mtimeMs, scannedUpTo, customTitle }
 // Only re-scan the new bytes appended since last scan
 const customTitleCache = new Map();
+let sessionCacheDirty = false;
+
+// An entry scanned up to `scannedUpTo` still describes the file when the file is the same one
+// and has only grown. A same-size file with a new mtime was rewritten in place. The entries
+// outlive the process (exportSessionCaches), so this is the only check between two runs.
+function sameFileGrown(cached, stat) {
+  if (!cached || cached.ino !== stat.ino || stat.size < cached.scannedUpTo) return false;
+  return stat.size > cached.scannedUpTo || cached.mtimeMs === stat.mtimeMs;
+}
 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.
+const TITLE_MARKER_TEXT = ['"custom-title"', '"ai-title"', '"agent-name"'];
+const TITLE_MARKERS = TITLE_MARKER_TEXT.map((m) => Buffer.from(m));
+const hasTitleMarker = (s) => TITLE_MARKER_TEXT.some((m) => s.includes(m));
+
 function extractCustomTitleFromText(text) {
-  const hasCustom = text.includes('"custom-title"');
-  const hasAi = text.includes('"ai-title"');
-  const hasAgent = text.includes('"agent-name"');
-  if (!hasCustom && !hasAi && !hasAgent) return null;
+  if (!hasTitleMarker(text)) 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--) {
     const line = lines[i];
-    if (!line.includes('"custom-title"') && !line.includes('"ai-title"') && !line.includes('"agent-name"')) continue;
+    if (!hasTitleMarker(line)) continue;
     try {
       const data = JSON.parse(line);
       if (!customTitle && data.type === 'custom-title' && data.customTitle && !data.customTitle.startsWith('<')) {
@@ -262,17 +273,37 @@ function extractCustomTitleFromText(text) {
         agentName = data.agentName;
       }
       if (customTitle) break;
-    } catch (e) {}
+    } catch {}
   }
   return customTitle || aiTitle || agentName || null;
 }
 
+// Same answer as extractCustomTitleFromText(buf.toString('utf8')): that function only looks at
+// lines holding a marker, and a line cut at \n decodes the same alone as inside the chunk.
+function extractCustomTitleFromBuffer(buf) {
+  const starts = new Set();
+  for (const m of TITLE_MARKERS) {
+    for (let i = buf.indexOf(m); i !== -1; i = buf.indexOf(m, i + m.length)) {
+      starts.add(buf.lastIndexOf(0x0a, i) + 1);
+    }
+  }
+  if (!starts.size) return null;
+  const lines = [...starts]
+    .sort((a, b) => a - b)
+    .map((s) => {
+      const e = buf.indexOf(0x0a, s);
+      return buf.toString('utf8', s, e === -1 ? buf.length : e);
+    });
+  return extractCustomTitleFromText(lines.join('\n'));
+}
+
 function readCustomTitle(jsonlPath, existingStat) {
   try {
     const stat = existingStat || statSync(jsonlPath);
-    const cached = customTitleCache.get(jsonlPath);
+    const prev = customTitleCache.get(jsonlPath);
+    const cached = sameFileGrown(prev, stat) ? prev : null;
 
-    if (cached && cached.scannedUpTo >= stat.size) return cached.customTitle;
+    if (cached && cached.scannedUpTo === stat.size) return cached.customTitle;
 
     let customTitle = cached?.customTitle || null;
     const fd = fs.openSync(jsonlPath, 'r');
@@ -282,23 +313,23 @@ function readCustomTitle(jsonlPath, existingStat) {
       if (len > 0) {
         const buf = Buffer.alloc(len);
         fs.readSync(fd, buf, 0, len, cached.scannedUpTo);
-        customTitle = extractCustomTitleFromText(buf.toString('utf8')) || customTitle;
+        customTitle = extractCustomTitleFromBuffer(buf) || customTitle;
       }
     } else {
+      // The last chunk holding a title wins, so scan from the end and stop at the first hit.
       const CHUNK = CUSTOM_TITLE_SCAN_SIZE;
-      for (let offset = 0; offset < stat.size; offset += CHUNK) {
-        const len = Math.min(CHUNK, stat.size - offset);
-        const buf = Buffer.alloc(len);
-        fs.readSync(fd, buf, 0, len, offset);
-        const found = extractCustomTitleFromText(buf.toString('utf8'));
-        if (found) customTitle = found;
+      const buf = Buffer.allocUnsafe(Math.min(CHUNK, stat.size));
+      for (let offset = Math.floor((stat.size - 1) / CHUNK) * CHUNK; offset >= 0 && !customTitle; offset -= CHUNK) {
+        const n = fs.readSync(fd, buf, 0, Math.min(CHUNK, stat.size - offset), offset);
+        customTitle = extractCustomTitleFromBuffer(buf.subarray(0, n));
       }
     }
 
     fs.closeSync(fd);
-    customTitleCache.set(jsonlPath, { scannedUpTo: stat.size, customTitle });
+    customTitleCache.set(jsonlPath, { ino: stat.ino, mtimeMs: stat.mtimeMs, scannedUpTo: stat.size, customTitle });
+    sessionCacheDirty = true;
     return customTitle;
-  } catch (e) {
+  } catch {
     return null;
   }
 }
@@ -310,75 +341,18 @@ const SCRAPE_GITBRANCH_RE = /"gitBranch"\s*:\s*"((?:[^"\\]|\\.)*)"/;
 function scrapeScalarFromBlob(blob, re) {
   const m = blob.match(re);
   if (!m) return null;
-  try { return JSON.parse(`"${m[1]}"`); } catch (e) { return null; }
+  try { return JSON.parse(`"${m[1]}"`); } catch { return null; }
 }
 
 const sessionInfoCache = new Map();
 const SESSION_INFO_CACHE_MAX = 2000;
 
-// Session-scoped /goal: a goal_status attachment carries the active condition
-// (latest-wins as the Stop hook re-evaluates). Only an unmet goal is "active" —
-// a met goal auto-clears in Claude Code, so treat met as removal, same as a
-// `/goal clear` command line. Returns the goal value to apply, or `undefined`
-// when the line is not a goal event (caller keeps its current value).
-function extractGoalFromLine(data) {
-  if (data.type === 'attachment' && data.attachment?.type === 'goal_status') {
-    return data.attachment.met ? null : { condition: data.attachment.condition || '' };
-  }
-  // `/goal clear` is a type:system local_command line carrying the command
-  // markup in `content`; a user-typed command line carries it in message.content.
-  const content = data.content ?? data.message?.content;
-  if (typeof content === 'string' && content.includes(GOAL_COMMAND_TAG) && /<command-args>\s*clear/.test(content)) {
-    return null;
-  }
-  return undefined;
-}
-
-const GOAL_COMMAND_TAG = '<command-name>/goal</command-name>';
-const GOAL_MARKERS = ['"goal_status"', GOAL_COMMAND_TAG].map((m) => Buffer.from(m));
-const SCAN_CHUNK = 65536;
-const scanBuf = Buffer.allocUnsafe(SCAN_CHUNK);
-
-// Streams [from, to) and calls onLine for the complete lines of every chunk
-// that contains a marker. Chunks without one are never decoded, which keeps a
-// full pass close to raw read speed (measured ~4x cheaper than decode+split).
-function scanMarkedLines(fd, from, to, markers, onLine) {
-  let carry = Buffer.alloc(0);
-  let offset = from;
-  while (offset < to) {
-    const n = fs.readSync(fd, scanBuf, 0, Math.min(SCAN_CHUNK, to - offset), offset);
-    if (n === 0) break;
-    offset += n;
-    const view = carry.length ? Buffer.concat([carry, scanBuf.subarray(0, n)]) : scanBuf.subarray(0, n);
-    const cut = view.lastIndexOf(0x0a) + 1;
-    const body = view.subarray(0, cut);
-    carry = Buffer.from(view.subarray(cut));
-    if (markers.some((m) => body.includes(m))) for (const line of body.toString('utf8').split('\n')) onLine(line);
-  }
-  if (carry.length && markers.some((m) => carry.includes(m))) onLine(carry.toString('utf8'));
-}
-
-// Goal events are rare and can sit anywhere in a long JSONL, outside both the
-// head and tail windows. Returns the last goal update in [from, to), or
-// undefined when there is none.
-function scanGoalInRange(fd, from, to) {
-  let latest;
-  scanMarkedLines(fd, from, to, GOAL_MARKERS, (line) => {
-    if (!line.includes('"goal_status"') && !line.includes(GOAL_COMMAND_TAG)) return;
-    try {
-      const update = extractGoalFromLine(JSON.parse(line));
-      if (update !== undefined) latest = update;
-    } catch (_) {}
-  });
-  return latest;
-}
-
 // 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, logicalParentUuid: null, compactBoundaryUuid: null, goal: null };
+  const result = { slug: null, projectPath: null, cwd: null, gitBranch: null, customTitle: null, logicalParentUuid: null, compactBoundaryUuid: null };
   let stat;
   let fd;
   try {
@@ -388,9 +362,7 @@ function readSessionInfoFromJsonl(jsonlPath) {
   }
 
   const cached = sessionInfoCache.get(jsonlPath);
-  const inodeMatch = cached && cached.ino === stat.ino;
-  const sizeOK = cached && stat.size >= cached.scannedUpTo;
-  const canIncrement = inodeMatch && sizeOK;
+  const canIncrement = sameFileGrown(cached, stat);
 
   if (canIncrement && stat.size === cached.scannedUpTo) {
     return {
@@ -400,7 +372,6 @@ function readSessionInfoFromJsonl(jsonlPath) {
       gitBranch: cached.gitBranch,
       logicalParentUuid: cached.logicalParentUuid || null,
       compactBoundaryUuid: cached.compactBoundaryUuid || null,
-      goal: cached.goal || null,
       customTitle: readCustomTitle(jsonlPath, stat)
     };
   }
@@ -412,7 +383,6 @@ function readSessionInfoFromJsonl(jsonlPath) {
     result.gitBranch = cached.gitBranch;
     result.logicalParentUuid = cached.logicalParentUuid || null;
     result.compactBoundaryUuid = cached.compactBoundaryUuid || null;
-    result.goal = cached.goal || null;
   }
 
   let lastCwdSeen = result.cwd;
@@ -432,10 +402,7 @@ function readSessionInfoFromJsonl(jsonlPath) {
         // its presence in the parent JSONL to tell the two apart.
         result.compactBoundaryUuid = data.uuid || null;
       }
-      // Forward → last wins.
-      const goalUpdate = extractGoalFromLine(data);
-      if (goalUpdate !== undefined) result.goal = goalUpdate;
-    } catch (e) {}
+    } catch {}
   };
 
   const CHUNK_SIZE = 16384;
@@ -454,12 +421,6 @@ function readSessionInfoFromJsonl(jsonlPath) {
       if (deltaLen > 0) {
         const readLen = Math.min(deltaLen, DELTA_MAX);
         const readStart = stat.size - readLen;
-        // The bytes an over-cap delta skips may hold a goal set, met or clear;
-        // scanned first so the delta's own lines win by order.
-        if (deltaLen > DELTA_MAX) {
-          const skipped = scanGoalInRange(fd, cached.scannedUpTo, readStart);
-          if (skipped !== undefined) result.goal = skipped;
-        }
         const buf = Buffer.alloc(readLen);
         const n = fs.readSync(fd, buf, 0, readLen, readStart);
         if (n > 0) {
@@ -505,9 +466,6 @@ function readSessionInfoFromJsonl(jsonlPath) {
         const tn = fs.readSync(fd, tailBuf, 0, TAIL_SIZE, tailStart);
         const lines = tailBuf.toString('utf8', 0, tn).split('\n');
         let latestTailCwd = null;
-        // undefined = no goal event seen in tail (keep head's); otherwise the
-        // most recent tail goal/clear supersedes head (tail bytes are later).
-        let tailGoal;
         for (let i = lines.length - 1; i >= 0; i--) {
           try {
             const data = JSON.parse(lines[i]);
@@ -515,22 +473,16 @@ function readSessionInfoFromJsonl(jsonlPath) {
             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 (tailGoal === undefined) tailGoal = extractGoalFromLine(data);
-            if (latestTailCwd && tailGoal !== undefined && result.slug && result.projectPath && result.gitBranch) break;
-          } catch (e) {}
+            if (latestTailCwd && result.slug && result.projectPath && result.gitBranch) break;
+          } catch {}
         }
         if (latestTailCwd) lastCwdSeen = latestTailCwd;
-        // A goal can be set, met or cleared between the head and tail windows.
-        // The scan starts at the head's last partial line and runs to EOF, so a
-        // tail event is simply seen again in order.
-        const goal = tailGoal !== undefined ? tailGoal : scanGoalInRange(fd, offset - Buffer.byteLength(leftover), stat.size);
-        if (goal !== undefined) result.goal = goal;
       }
       scannedUpTo = stat.size;
     }
-  } catch (e) {
+  } catch {
   } finally {
-    if (fd !== undefined) { try { fs.closeSync(fd); } catch (e) {} }
+    if (fd !== undefined) { try { fs.closeSync(fd); } catch {} }
   }
 
   result.cwd = lastCwdSeen;
@@ -538,25 +490,59 @@ function readSessionInfoFromJsonl(jsonlPath) {
   if (stat) {
     sessionInfoCache.set(jsonlPath, {
       ino: stat.ino,
-      size: stat.size,
+      mtimeMs: stat.mtimeMs,
+      birthtimeMs: stat.birthtimeMs,
       scannedUpTo,
       slug: result.slug,
       projectPath: result.projectPath,
       gitBranch: result.gitBranch,
       cwd: result.cwd,
       logicalParentUuid: result.logicalParentUuid,
-      compactBoundaryUuid: result.compactBoundaryUuid,
-      goal: result.goal
+      compactBoundaryUuid: result.compactBoundaryUuid
     });
     if (sessionInfoCache.size > SESSION_INFO_CACHE_MAX) {
       const firstKey = sessionInfoCache.keys().next().value;
       sessionInfoCache.delete(firstKey);
     }
+    sessionCacheDirty = true;
   }
   result.customTitle = readCustomTitle(jsonlPath, stat);
   return result;
 }
 
+// Counts the transcripts of one project folder that were read since start (or loaded from the
+// session cache). Entries of deleted files stay until the next save, so a deletion does not
+// lower the count.
+function countTranscriptsBornBefore(dir, birthtimeMs) {
+  let n = 0;
+  for (const [p, e] of sessionInfoCache) if (e.birthtimeMs < birthtimeMs && path.dirname(p) === dir) n++;
+  return n;
+}
+
+const sessionCachesDirty = () => sessionCacheDirty;
+
+// Snapshot of the per-transcript caches for lib/session-cache.js. Entries of deleted
+// transcripts are left out, so the snapshot never holds more than the live set.
+function exportSessionCaches() {
+  sessionCacheDirty = false;
+  const livePaths = new Set([...sessionInfoCache.keys(), ...customTitleCache.keys()].filter((p) => fs.existsSync(p)));
+  const live = (map) => [...map].filter(([p]) => livePaths.has(p));
+  return { info: live(sessionInfoCache), titles: live(customTitleCache) };
+}
+
+function importSessionCaches(snapshot) {
+  const valid = (e) => e && typeof e === 'object' && typeof e.ino === 'number' && typeof e.scannedUpTo === 'number' && typeof e.mtimeMs === 'number';
+  const load = (map, entries) => {
+    if (!Array.isArray(entries)) return;
+    for (const pair of entries) {
+      if (!Array.isArray(pair) || typeof pair[0] !== 'string' || !valid(pair[1])) continue;
+      map.set(pair[0], pair[1]);
+    }
+  };
+  load(sessionInfoCache, snapshot?.info?.slice(-SESSION_INFO_CACHE_MAX));
+  load(customTitleCache, snapshot?.titles?.slice(-SESSION_INFO_CACHE_MAX));
+}
+
 // Background-task completion records arrive as a user message whose content is a
 // <task-notification> envelope. Rendering the raw text leaks the tag values as a
 // run-on line (task-id + tool-use-id + output-file path) plus the <usage> numbers
@@ -674,7 +660,7 @@ function readRecentMessages(jsonlPath, limit = 10) {
   let fd;
   try {
     const stat = statSync(jsonlPath);
-    fd = require('fs').openSync(jsonlPath, 'r');
+    fd = fs.openSync(jsonlPath, 'r');
     const messages = [];
     const toolResults = new Map();
     const toolResultExtras = new Map();
@@ -686,7 +672,7 @@ function readRecentMessages(jsonlPath, limit = 10) {
       const start = Math.max(0, stat.size - readSize);
       const bufSize = readSize;
       const buf = Buffer.alloc(bufSize);
-      require('fs').readSync(fd, buf, 0, bufSize, start);
+      fs.readSync(fd, buf, 0, bufSize, start);
 
       const text = buf.toString('utf8');
       const firstNewline = text.indexOf('\n');
@@ -706,7 +692,7 @@ function readRecentMessages(jsonlPath, limit = 10) {
                 const truncated = block.text.length > 500;
                 messages.push({
                   type: 'assistant',
-                  text: truncated ? block.text.slice(0, 500) + '...' : block.text,
+                  text: truncated ? `${block.text.slice(0, 500)}...` : block.text,
                   fullText: truncated ? block.text : null,
                   timestamp: obj.timestamp,
                   model: obj.message.model || null
@@ -718,33 +704,33 @@ function readRecentMessages(jsonlPath, limit = 10) {
                 if (block.input) {
                   inp = typeof block.input === 'string' ? (() => { try { return JSON.parse(block.input); } catch(_) { return {}; } })() : block.input;
                   if (inp.file_path) { detail = inp.file_path.replace(/^.*[/\\]/, ''); fullDetail = inp.file_path; }
-                  else if (inp.command) { detail = inp.command.length > 80 ? inp.command.slice(0, 80) + '...' : inp.command; fullDetail = inp.command; }
+                  else if (inp.command) { detail = inp.command.length > 80 ? `${inp.command.slice(0, 80)}...` : inp.command; fullDetail = inp.command; }
                   else if (inp.pattern) { detail = inp.pattern; fullDetail = inp.pattern; }
                   else if (inp.query) { detail = inp.query; fullDetail = inp.query; }
-                  else if (inp.url) { detail = inp.url.length > 80 ? inp.url.slice(0, 80) + '...' : inp.url; fullDetail = inp.url; }
-                  else if (inp.skill) { const s = inp.skill + (typeof inp.args === 'string' ? ' ' + inp.args : ''); detail = s.length > 80 ? s.slice(0, 80) + '...' : s; fullDetail = s; }
+                  else if (inp.url) { detail = inp.url.length > 80 ? `${inp.url.slice(0, 80)}...` : inp.url; fullDetail = inp.url; }
+                  else if (inp.skill) { const s = inp.skill + (typeof inp.args === 'string' ? ` ${inp.args}` : ''); detail = s.length > 80 ? `${s.slice(0, 80)}...` : s; fullDetail = s; }
                   else if (inp.questions && Array.isArray(inp.questions)) {
-                    const parts = inp.questions.map(q => (q.header ? q.header + ': ' : '') + q.question);
+                    const parts = inp.questions.map(q => (q.header ? `${q.header}: ` : '') + q.question);
                     const s = parts.join(' | ');
-                    detail = s.length > 80 ? s.slice(0, 80) + '...' : s;
+                    detail = s.length > 80 ? `${s.slice(0, 80)}...` : s;
                     fullDetail = inp.questions.map(q => {
-                      let text = (q.header ? '[' + q.header + '] ' : '') + q.question;
-                      if (q.options) text += '\n\n' + q.options.map((o, j) => '  ' + (j + 1) + '. ' + o.label + (o.description ? ' — ' + o.description : '')).join('\n');
+                      let text = (q.header ? `[${q.header}] ` : '') + q.question;
+                      if (q.options) text += `\n\n${q.options.map((o, j) => `  ${j + 1}. ${o.label}${o.description ? ` — ${o.description}` : ''}`).join('\n')}`;
                       return text;
                     }).join('\n\n');
                   }
                   else if (inp.to) {
                     const proto = inp.message && typeof inp.message === 'object' ? inp.message : null;
                     if (proto?.type === 'shutdown_request') {
-                      detail = '→ ' + inp.to + ': shutdown request' + (proto.reason ? ' (' + proto.reason + ')' : '');
+                      detail = `→ ${inp.to}: shutdown request${proto.reason ? ` (${proto.reason})` : ''}`;
                     } else if (proto?.type === 'shutdown_response') {
-                      detail = '→ ' + inp.to + ': ' + (proto.approve ? 'shutdown approved' : 'shutdown rejected');
+                      detail = `→ ${inp.to}: ${proto.approve ? 'shutdown approved' : 'shutdown rejected'}`;
                     } else if (proto?.type === 'plan_approval_response') {
-                      detail = '→ ' + inp.to + ': ' + (proto.approve ? 'plan approved' : 'plan rejected');
+                      detail = `→ ${inp.to}: ${proto.approve ? 'plan approved' : 'plan rejected'}`;
                     } else {
-                      detail = '→ ' + inp.to + (inp.summary ? ': ' + inp.summary : '');
+                      detail = `→ ${inp.to}${inp.summary ? `: ${inp.summary}` : ''}`;
                     }
-                    if (detail.length > 80) detail = detail.slice(0, 80) + '...';
+                    if (detail.length > 80) detail = `${detail.slice(0, 80)}...`;
                     fullDetail = typeof inp.message === 'string' ? inp.message : JSON.stringify(inp.message);
                   }
                   else if (inp.plan) {
@@ -765,7 +751,7 @@ function readRecentMessages(jsonlPath, limit = 10) {
                     if (inp.file_path) params.file_path = inp.file_path;
                     if (inp.content) {
                       if (inp.content.length > TOOL_RESULT_MAX) {
-                        params.content = inp.content.slice(0, TOOL_RESULT_MAX) + '\n... (truncated)';
+                        params.content = `${inp.content.slice(0, TOOL_RESULT_MAX)}\n... (truncated)`;
                         params.contentFull = inp.content;
                       } else {
                         params.content = inp.content;
@@ -807,7 +793,7 @@ function readRecentMessages(jsonlPath, limit = 10) {
                   } else if (block.name === 'TaskCreate') {
                     if (inp.subject) params.subject = inp.subject;
                   } else if (block.name === 'TaskUpdate') {
-                    if (inp.taskId) params.taskId = '#' + inp.taskId;
+                    if (inp.taskId) params.taskId = `#${inp.taskId}`;
                     if (inp.status) params.status = inp.status;
                   } else if (block.name === 'NotebookEdit') {
                     if (inp.command) params.command = inp.command;
@@ -833,8 +819,8 @@ function readRecentMessages(jsonlPath, limit = 10) {
                     for (const [k, v] of Object.entries(inp)) {
                       if (k === 'description' || v == null) continue;
                       if (typeof v === 'string' && v.length > TOOL_RESULT_MAX) {
-                        params[k] = v.slice(0, TOOL_RESULT_MAX) + '\n... (truncated)';
-                        params[k + 'Full'] = v;
+                        params[k] = `${v.slice(0, TOOL_RESULT_MAX)}\n... (truncated)`;
+                        params[`${k}Full`] = v;
                       } else {
                         params[k] = v;
                       }
@@ -896,7 +882,7 @@ function readRecentMessages(jsonlPath, limit = 10) {
               if (tmMatch) {
                 const attrs = tmMatch[1];
                 const body = tmMatch[2].trim();
-                const getAttr = (name) => (attrs.match(new RegExp(name + '="([^"]*)"')) || [])[1] || null;
+                const getAttr = (name) => (attrs.match(new RegExp(`${name}="([^"]*)"`)) || [])[1] || null;
                 const tid = getAttr('teammate_id');
                 const color = getAttr('color');
                 const summary = getAttr('summary');
@@ -931,7 +917,7 @@ function readRecentMessages(jsonlPath, limit = 10) {
                   protocolType: protocol?.type || null,
                   protocolLabel,
                   protocolData: protocol || null,
-                  text: isProtocol ? null : (truncated ? body.slice(0, 500) + '...' : body),
+                  text: isProtocol ? null : (truncated ? `${body.slice(0, 500)}...` : body),
                   fullText: isProtocol ? null : (truncated ? body : null),
                   timestamp: obj.timestamp
                 });
@@ -1023,7 +1009,7 @@ function readRecentMessages(jsonlPath, limit = 10) {
               pushUserMessage(messages, text, obj.timestamp, null, { queued: true, images: refs });
             }
           }
-        } catch (e) { /* partial line */ }
+        } catch { /* partial line */ }
       }
 
       if (readSize >= stat.size) break;
@@ -1040,7 +1026,7 @@ function readRecentMessages(jsonlPath, limit = 10) {
         const full = toolResults.get(msg.toolUseId);
         const truncated = full.length > TOOL_RESULT_MAX;
         if (truncated) {
-          msg.toolResult = full.slice(0, TOOL_RESULT_MAX) + '\n... (truncated)';
+          msg.toolResult = `${full.slice(0, TOOL_RESULT_MAX)}\n... (truncated)`;
           msg.toolResultFull = full;
         } else {
           msg.toolResult = full;
@@ -1057,7 +1043,7 @@ function readRecentMessages(jsonlPath, limit = 10) {
       }
     }
 
-    require('fs').closeSync(fd);
+    fs.closeSync(fd);
     fd = null;
     messages.sort((a, b) => (a.timestamp || '').localeCompare(b.timestamp || ''));
     for (let i = messages.length - 1; i > 0; i--) {
@@ -1072,8 +1058,8 @@ function readRecentMessages(jsonlPath, limit = 10) {
       }
     }
     return messages.slice(-limit);
-  } catch (e) {
-    if (fd) try { require('fs').closeSync(fd); } catch (_) {}
+  } catch {
+    if (fd) try { fs.closeSync(fd); } catch (_) {}
     return [];
   }
 }
@@ -1172,7 +1158,7 @@ function readCachedImage(sessionId, n, claudeDir) {
   const idx = Number(n);
   if (!sessionId || !/^[A-Za-z0-9._-]+$/.test(sessionId)) return null;
   if (!Number.isInteger(idx) || idx < 0) return null;
-  const baseDir = claudeDir || path.join(require('os').homedir(), '.claude');
+  const baseDir = claudeDir || path.join(os.homedir(), '.claude');
   const dir = path.join(baseDir, 'image-cache', sessionId);
   try {
     const match = readdirSync(dir).find((f) => {
@@ -1266,8 +1252,8 @@ function buildSessionDigest(jsonlPath) {
           if (!map[key]) {
             let prompt = null;
             const promptMatch = promptRe.exec(line);
-            if (promptMatch && promptMatch[1]) {
-              try { prompt = JSON.parse('"' + promptMatch[1] + '"'); } catch (_) { prompt = promptMatch[1]; }
+            if (promptMatch?.[1]) {
+              try { prompt = JSON.parse(`"${promptMatch[1]}"`); } catch (_) { prompt = promptMatch[1]; }
             }
             map[key] = { agentId: agentMatch[1], prompt };
           }
@@ -1578,14 +1564,13 @@ function extractModelFromTranscript(jsonlPath) {
       const bytesRead = readSync(fd, buf, 0, CHUNK, null);
       if (bytesRead === 0) break;
       accumulated += buf.toString('utf8', 0, bytesRead);
-      let nlIdx;
-      while ((nlIdx = accumulated.indexOf('\n')) !== -1) {
+      for (let nlIdx = accumulated.indexOf('\n'); nlIdx !== -1; nlIdx = accumulated.indexOf('\n')) {
         const line = accumulated.slice(0, nlIdx);
         accumulated = accumulated.slice(nlIdx + 1);
         if (!line.trim()) continue;
         try {
           const obj = JSON.parse(line);
-          const model = obj.model || (obj.message && obj.message.model);
+          const model = obj.model || obj.message?.model;
           if (model) return model;
         } catch (_) {}
       }
@@ -1631,8 +1616,8 @@ function formatStructuredResult(input) {
   const parts = [];
   for (const [key, value] of Object.entries(input)) {
     if (value == null || value === '') continue;
-    parts.push('### ' + key);
-    parts.push(typeof value === 'string' ? value : '```json\n' + JSON.stringify(value, null, 2) + '\n```');
+    parts.push(`### ${key}`);
+    parts.push(typeof value === 'string' ? value : `\`\`\`json\n${JSON.stringify(value, null, 2)}\n\`\`\``);
   }
   return parts.length ? parts.join('\n\n') : null;
 }
@@ -1684,12 +1669,21 @@ const EMPTY_LOOP_STATE = () => ({
   taskIdByToolUseId: new Map(), deletedTaskIds: new Set()
 });
 
+const LOOP_TOOL_TEXT = ['"ScheduleWakeup"', '"CronCreate"', '"CronDelete"'];
+const LOOP_TOOL_MARKERS = LOOP_TOOL_TEXT.map((m) => Buffer.from(m));
+
+// Only a CronCreate result is ever read back from taskIdByToolUseId, and it is written after
+// its tool_use, so other tool results (most lines of a transcript) are not parsed.
+// `hay` is a line or a Buffer; both have includes.
+const hasPendingCronId = (hay, state) =>
+  state.crons.some((c) => c.id && !state.taskIdByToolUseId.has(c.id) && hay.includes(c.id));
+
+const wakeupFireMs = (w) => Date.parse(w.timestamp) + (w.delaySeconds ?? 0) * 1000;
+
 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"');
+  const hasToolResult = line.includes('"tool_use_id"') && hasPendingCronId(line, state);
+  const hasLoopTool = LOOP_TOOL_TEXT.some((m) => line.includes(m));
   if (!hasToolResult && !hasLoopTool) return;
   let obj;
   try { obj = JSON.parse(line); } catch (_) { return; }
@@ -1703,6 +1697,11 @@ function processLoopLine(line, state) {
     } else if (b.type === 'tool_use') {
       const inp = b.input || {};
       if (b.name === 'ScheduleWakeup') {
+        // The harness keeps one pending wakeup per session: a newer call replaces it and
+        // stop cancels it. Wakeups that already fired stay as history.
+        const at = Date.parse(obj.timestamp);
+        state.wakeups = state.wakeups.filter((w) => wakeupFireMs(w) <= at);
+        if (inp.stop) continue;
         state.wakeups.push({
           id: b.id || null,
           timestamp: obj.timestamp || null,
@@ -1727,6 +1726,12 @@ function processLoopLine(line, state) {
   }
 }
 
+// True when processLoopLine could act on some line in bytes: a loop tool call, or the result of a
+// CronCreate whose task id is still unknown. Most appended bytes hold neither and are never decoded.
+function hasLoopMarker(bytes, state) {
+  return LOOP_TOOL_MARKERS.some((m) => bytes.includes(m)) || hasPendingCronId(bytes, state);
+}
+
 // 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) {
@@ -1751,19 +1756,17 @@ function updateLoopInfo(jsonlPath, prev) {
   try {
     fd = fs.openSync(jsonlPath, 'r');
     const len = stat.size - state.scannedOffset;
-    const buf = Buffer.alloc(len);
+    const buf = Buffer.allocUnsafe(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;
+    // No complete line yet — leave scannedOffset alone.
+    const lastNl = buf.subarray(0, n).lastIndexOf(0x0a);
+    if (lastNl < 0) return state;
+    const complete = buf.subarray(0, lastNl);
+    if (hasLoopMarker(complete, state)) {
+      for (const line of complete.toString('utf8').split('\n')) processLoopLine(line, state);
+    }
+    state.scannedOffset += lastNl + 1;
     state.size = stat.size;
   } catch (_) {
     // leave state as-is
@@ -1798,6 +1801,10 @@ module.exports = {
   parseAgentMessage,
   getSystemMessageLabel,
   readSessionInfoFromJsonl,
+  exportSessionCaches,
+  importSessionCaches,
+  sessionCachesDirty,
+  countTranscriptsBornBefore,
   readRecentMessages,
   readMessagesPage,
   readFullToolResult,