claude-code-kanban 4.1.0 → 4.2.0

package/lib/parsers.js

@@ -142,19 +142,35 @@ function pushUserMessage(messages, text, timestamp, sysLabel, extras) {
 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) {
@@ -206,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);
@@ -953,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,
@@ -965,6 +1144,8 @@ module.exports = {
   readMessagesPage,
   readFullToolResult,
   readUserImage,
+  updateLoopInfo,
+  buildLoopInfoFromState,
   buildAgentProgressMap,
   buildSessionDigest,
   readCompactSummaries,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "4.1.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/public/app.js

@@ -604,6 +604,7 @@ async function fetchAgents(sessionId) {
     if (waitHash !== lastWaitingHash) {
       lastWaitingHash = waitHash;
       if (messagePanelOpen && currentMessages.length) renderMessages(currentMessages);
+      maybeFollowLatest();
     }
   } catch (e) {
     console.error('[fetchAgents]', e);
@@ -1159,16 +1160,33 @@ function getWaitingPreview(toolInput) {
 }
 
 function renderWaitingEntry() {
-  if (!currentWaiting?.timestamp) return '';
-  const age = Date.now() - new Date(currentWaiting.timestamp).getTime();
-  if (age >= WAITING_TTL_MS) return '';
+  if (!isWaitingFresh()) return '';
   const tool = currentWaiting.toolName || 'unknown';
   const label = getWaitingLabel(currentWaiting.kind, tool);
   const preview = getWaitingPreview(currentWaiting.toolInput);
   const previewHtml = preview
     ? `<div class="msg-waiting-preview">${escapeHtml(preview.slice(0, WAITING_PREVIEW_MAX_CHARS))}</div>`
     : '';
-  return `<div class="msg-item msg-waiting">${ICON_CHAT}<div class="msg-body"><div class="msg-text">${escapeHtml(label)}</div>${previewHtml}<div class="msg-time">waiting…</div></div></div>`;
+  const discardBtn = `<button class="msg-waiting-discard" title="Discard permission prompt" onclick="event.stopPropagation();discardWaiting()"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" width="14" height="14"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg></button>`;
+  return `<div class="msg-item msg-waiting" onclick="msgDetailFollowLatest=false;showWaitingDetail()">${ICON_CHAT}<div class="msg-body"><div class="msg-text">${escapeHtml(label)}</div>${previewHtml}<div class="msg-time">waiting…</div></div>${discardBtn}</div>`;
+}
+
+// biome-ignore lint/correctness/noUnusedVariables: used in HTML onclick
+async function discardWaiting() {
+  if (!currentSessionId) return;
+  try {
+    const res = await fetch(`/api/sessions/${encodeURIComponent(currentSessionId)}/waiting/discard`, {
+      method: 'POST',
+    });
+    if (res.ok) {
+      currentWaiting = null;
+      if (currentMsgDetailIdx === MSG_DETAIL_WAITING_IDX) closeMsgDetailModal();
+      renderMessages(currentMessages);
+      renderAgentFooter();
+    }
+  } catch (e) {
+    console.error('[discardWaiting]', e);
+  }
 }
 
 function renderMessages(messages) {
@@ -1199,6 +1217,7 @@ function renderMessages(messages) {
 
 let currentMsgDetailIdx = null;
 let msgDetailFollowLatest = false;
+const MSG_DETAIL_WAITING_IDX = -2;
 let currentPins = [];
 let pinnedCollapsed = false;
 
@@ -2137,7 +2156,7 @@ function renderAgentFooter() {
     )
     .slice(0, AGENT_LOG_MAX);
 
-  const permFresh = currentWaiting?.timestamp && now - new Date(currentWaiting.timestamp).getTime() < WAITING_TTL_MS;
+  const permFresh = isWaitingFresh();
 
   if (visible.length === 0 && !permFresh) {
     footer.classList.remove('visible');
@@ -2580,6 +2599,7 @@ function renderSessions() {
                 ${session.sharedTaskList ? `<span class="shared-tasklist-badge" title="Shared task list: ${escapeHtml(session.sharedTaskList)}">${linkSvg(12)}</span>` : ''}
                 ${isTeam || session.project || showCtx ? `<span class="team-info-btn" onclick="event.stopPropagation(); showSessionInfoModal('${session.id}')" title="View session info">ℹ</span>` : ''}
                 ${session.hasPlan ? `<span class="plan-indicator" onclick="event.stopPropagation(); openPlanForSession('${session.id}')" title="View plan"><svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><polyline points="14 2 14 8 20 8"/><line x1="16" y1="13" x2="8" y2="13"/><line x1="16" y1="17" x2="8" y2="17"/></svg></span>` : ''}
+                ${renderLoopBadge(session)}
                 ${linkedDocsCount > 0 ? `<span class="linked-docs-badge" onclick="event.stopPropagation(); showSessionInfoModal('${session.id}')" title="${linkedDocsCount} linked document${linkedDocsCount > 1 ? 's' : ''}">${linkSvg(10)}${linkedDocsCount}</span>` : ''}
                 ${bookmarksCount > 0 ? `<span class="bookmarks-badge" onclick="event.stopPropagation(); openSessionWithBookmarks('${session.id}')" title="${bookmarksCount} bookmarked message${bookmarksCount > 1 ? 's' : ''}"><svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z"/></svg>${bookmarksCount}</span>` : ''}
                 ${hasScratchpad ? `<span class="scratchpad-badge" onclick="event.stopPropagation(); openSessionScratchpad('${session.id}')" title="Open scratchpad"><svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"/><path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z"/></svg></span>` : ''}
@@ -4251,7 +4271,7 @@ function matchKey(e, ...keys) {
   return keys.some((k) => e.key === k || e.code === k);
 }
 
-const MODAL_ESC_PRIORITY = ['preview-modal', 'msg-detail-modal', 'plan-modal'];
+const MODAL_ESC_PRIORITY = ['preview-modal', 'msg-detail-modal', 'plan-modal', 'loop-modal'];
 const MODAL_CLOSERS = {
   'preview-modal': () => closePreviewModal(),
   'msg-detail-modal': () => {
@@ -4259,6 +4279,7 @@ const MODAL_CLOSERS = {
     msgDetailFollowLatest = false;
   },
   'plan-modal': () => closePlanModal(),
+  'loop-modal': () => closeLoopModal(),
   'team-modal': () => closeTeamModal(),
   'agent-modal': () => closeAgentModal(),
   'help-modal': () => closeHelpModal(),
@@ -4293,7 +4314,13 @@ document.addEventListener('keydown', (e) => {
     } else if (document.getElementById('msg-detail-modal').classList.contains('visible')) {
       if (matchKey(e, 'ArrowDown', 'KeyJ')) {
         e.preventDefault();
-        if (currentMsgDetailIdx < currentMessages.length - 1) {
+        if (currentMsgDetailIdx === MSG_DETAIL_WAITING_IDX) {
+          msgDetailFollowLatest = true;
+          showWaitingDetail();
+        } else if (currentMsgDetailIdx === currentMessages.length - 1 && isWaitingFresh()) {
+          msgDetailFollowLatest = false;
+          showWaitingDetail();
+        } else if (currentMsgDetailIdx < currentMessages.length - 1) {
           msgDetailFollowLatest = false;
           showMsgDetail(currentMsgDetailIdx + 1);
         } else if (currentMsgDetailIdx === currentMessages.length - 1) {
@@ -4302,7 +4329,12 @@ document.addEventListener('keydown', (e) => {
         }
       } else if (matchKey(e, 'ArrowUp', 'KeyK')) {
         e.preventDefault();
-        if (currentMsgDetailIdx > 0) {
+        if (currentMsgDetailIdx === MSG_DETAIL_WAITING_IDX) {
+          if (currentMessages.length) {
+            msgDetailFollowLatest = false;
+            showMsgDetail(currentMessages.length - 1);
+          }
+        } else if (currentMsgDetailIdx > 0) {
           msgDetailFollowLatest = false;
           showMsgDetail(currentMsgDetailIdx - 1);
         }
@@ -4327,6 +4359,9 @@ document.addEventListener('keydown', (e) => {
     const msgDetailModal = document.getElementById('msg-detail-modal');
     if (msgDetailModal.classList.contains('visible')) {
       closeMsgDetailModal();
+    } else if (isWaitingFresh()) {
+      msgDetailFollowLatest = true;
+      showWaitingDetail();
     } else if (currentMessages.length) {
       msgDetailFollowLatest = true;
       showMsgDetail(currentMessages.length - 1);
@@ -5091,11 +5126,50 @@ function renderContextDetail(raw) {
 
 //#region UTILS
 function maybeFollowLatest() {
-  if (msgDetailFollowLatest && currentMessages.length) {
+  if (!msgDetailFollowLatest) return;
+  if (isWaitingFresh()) {
+    showWaitingDetail();
+  } else if (currentMessages.length) {
     showMsgDetail(currentMessages.length - 1);
   }
 }
 
+function isWaitingFresh() {
+  if (!currentWaiting?.timestamp) return false;
+  return Date.now() - new Date(currentWaiting.timestamp).getTime() < WAITING_TTL_MS;
+}
+
+function showWaitingDetail() {
+  if (!isWaitingFresh()) return;
+  currentMsgDetailIdx = MSG_DETAIL_WAITING_IDX;
+  const tool = currentWaiting.toolName || 'unknown';
+  const label = getWaitingLabel(currentWaiting.kind, tool);
+  const body = document.getElementById('msg-detail-body');
+  let inputHtml = '';
+  if (currentWaiting.toolInput) {
+    let pretty = currentWaiting.toolInput;
+    try {
+      pretty = JSON.stringify(JSON.parse(currentWaiting.toolInput), null, 2);
+    } catch (_) {
+      /* keep raw */
+    }
+    inputHtml = `<pre class="${TINTED_PRE_CLASS}">${escapeHtml(pretty)}</pre>`;
+  }
+  body.innerHTML = inputHtml;
+  document.getElementById('msg-detail-title').textContent = label;
+  document.getElementById('msg-detail-agent-btn').style.display = 'none';
+  const modal = document.getElementById('msg-detail-modal').querySelector('.modal');
+  autoSizeModal(modal, body);
+  modal.classList.toggle('live', msgDetailFollowLatest);
+  const overlay = document.getElementById('msg-detail-modal');
+  overlay.classList.toggle('live-overlay', msgDetailFollowLatest);
+  const meta = [formatDate(currentWaiting.timestamp), 'waiting'];
+  document.getElementById('msg-detail-meta').textContent = meta.join(' · ');
+  currentPinDetailId = null;
+  updateMsgDetailPinState();
+  overlay.classList.add('visible');
+}
+
 function isSessionActive(s) {
   return s.hasRecentLog || s.inProgress > 0 || s.hasActiveAgents || s.hasWaitingForUser;
 }
@@ -5884,6 +5958,110 @@ function refreshOpenPlan() {
     .catch(() => {});
 }
 
+// biome-ignore lint/correctness/noUnusedVariables: used in HTML
+function showLoopModal(sessionId) {
+  const body = document.getElementById('loop-modal-body');
+  body.innerHTML = '<div style="padding:16px;color:var(--text-secondary);">Loading…</div>';
+  document.getElementById('loop-modal').classList.add('visible');
+  fetch(`/api/sessions/${sessionId}/loop`)
+    .then((r) => (r.ok ? r.json() : { wakeups: [], crons: [] }))
+    .catch(() => ({ wakeups: [], crons: [] }))
+    .then((data) => {
+      renderLoopModalBody(data);
+    });
+}
+
+function fmtLoopDelay(s) {
+  if (s == null) return '';
+  if (s < 60) return `${s}s`;
+  if (s < 3600) return `${Math.round(s / 60)}m`;
+  return `${(s / 3600).toFixed(1)}h`;
+}
+
+function fmtLoopFireTime(timestamp, delaySeconds) {
+  if (!timestamp || delaySeconds == null) return { abs: '', rel: '', status: '' };
+  const fireMs = new Date(timestamp).getTime() + delaySeconds * 1000;
+  const fireDate = new Date(fireMs);
+  const diff = fireMs - Date.now();
+  const abs = fireDate.toLocaleString(undefined, {
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  });
+  const absSec = Math.abs(Math.round(diff / 1000));
+  const rel =
+    absSec < 60 ? `${absSec}s` : absSec < 3600 ? `${Math.round(absSec / 60)}m` : `${(absSec / 3600).toFixed(1)}h`;
+  if (diff > 0) return { abs, rel: `in ${rel}`, status: 'pending' };
+  return { abs, rel: `${rel} ago`, status: 'fired' };
+}
+
+const LOOP_CLOCK_SVG =
+  '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/></svg>';
+const LOOP_CRON_SVG =
+  '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 8v4l3 3"/><circle cx="12" cy="12" r="10"/></svg>';
+
+function loopField(label, value, mono = false) {
+  if (!value) return '';
+  const inner = mono ? `<code>${escapeHtml(value)}</code>` : escapeHtml(value);
+  return `<div class="loop-field"><div class="loop-field-label">${label}</div><div class="loop-field-val">${inner}</div></div>`;
+}
+
+function renderLoopRow(item, kind) {
+  const when = item.timestamp ? formatDate(item.timestamp) : '';
+  let headline = '';
+  let footer = '';
+  let fields = '';
+  if (kind === 'wakeup') {
+    const fire = fmtLoopFireTime(item.timestamp, item.delaySeconds);
+    const delayLbl = item.delaySeconds != null ? `delay ${fmtLoopDelay(item.delaySeconds)}` : '';
+    if (fire.abs) {
+      headline = `<div class="loop-headline loop-fire-${fire.status}">${LOOP_CLOCK_SVG}<span class="loop-headline-rel">${fire.status === 'pending' ? 'Fires' : 'Fired'} ${escapeHtml(fire.rel)}</span><span class="loop-headline-abs">${escapeHtml(fire.abs)}</span></div>`;
+    }
+    fields = loopField('Reason', item.reason) + loopField('Prompt', item.prompt, true);
+    footer = `<div class="loop-foot">scheduled ${escapeHtml(when)}${delayLbl ? ` · ${delayLbl}` : ''}</div>`;
+  } else {
+    if (item.cron) {
+      headline = `<div class="loop-headline">${LOOP_CRON_SVG}<span class="loop-headline-rel"><code>${escapeHtml(item.cron)}</code></span></div>`;
+    }
+    fields = loopField('Description', item.description) + loopField('Prompt', item.prompt, true);
+    footer = `<div class="loop-foot">created ${escapeHtml(when)}</div>`;
+  }
+  return `<div class="loop-row">${headline}${fields}${footer}</div>`;
+}
+
+function renderLoopModalBody(data) {
+  const body = document.getElementById('loop-modal-body');
+  const wakeups = data.wakeups || [];
+  const crons = data.crons || [];
+  if (!wakeups.length && !crons.length) {
+    body.innerHTML =
+      '<div style="padding:24px;text-align:center;color:var(--text-secondary);">No scheduled wakeups or cron jobs.</div>';
+    return;
+  }
+  const section = (title, items, kind) =>
+    items.length
+      ? `<h4 class="loop-section-title">${title} <span class="loop-count">${items.length}</span></h4>${items.map((i) => renderLoopRow(i, kind)).join('')}`
+      : '';
+  body.innerHTML = section('Wakeups', wakeups, 'wakeup') + section('Cron jobs', crons, 'cron');
+}
+
+function renderLoopBadge(session) {
+  const li = session.loopInfo;
+  const total = (li?.wakeupCount || 0) + (li?.cronCount || 0);
+  if (total === 0) return '';
+  let tip = `${li.wakeupCount} wakeup${li.wakeupCount === 1 ? '' : 's'}, ${li.cronCount} cron${li.cronCount === 1 ? '' : 's'}`;
+  if (li.latest?.timestamp && li.latest.delaySeconds != null) {
+    const f = fmtLoopFireTime(li.latest.timestamp, li.latest.delaySeconds);
+    if (f.abs) tip += ` — latest ${f.status === 'pending' ? 'fires' : 'fired'} ${f.rel} (${f.abs})`;
+  }
+  return `<span class="loop-badge" onclick="event.stopPropagation(); showLoopModal('${session.id}')" title="${escapeHtml(tip)}"><svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/></svg></span>`;
+}
+
+function closeLoopModal() {
+  document.getElementById('loop-modal').classList.remove('visible');
+}
+
 function openPlanForSession(sid) {
   fetch(`/api/sessions/${sid}/plan`)
     .then((r) => (r.ok ? r.json() : null))

package/public/index.html

@@ -604,6 +604,25 @@
     </div>
   </div>
 
+  <!-- Loop Wakeups Modal -->
+  <div id="loop-modal" class="modal-overlay" onclick="closeLoopModal()">
+    <div class="modal plan-modal" onclick="event.stopPropagation()">
+      <div class="modal-header">
+        <h3 id="loop-modal-title" class="modal-title" style="display:flex;align-items:center;gap:8px;">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" style="width:18px;height:18px;"><circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/></svg>
+          Loop activity
+        </h3>
+        <button class="modal-close" aria-label="Close dialog" onclick="closeLoopModal()">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M18 6L6 18M6 6l12 12"/></svg>
+        </button>
+      </div>
+      <div id="loop-modal-body" class="modal-body" style="overflow-y:auto;flex:0 1 auto;min-height:0;"></div>
+      <div class="modal-footer">
+        <button class="btn btn-primary" onclick="closeLoopModal()">Close</button>
+      </div>
+    </div>
+  </div>
+
   <div id="agent-modal" class="modal-overlay plan-modal-overlay" onclick="closeAgentModal()">
     <div class="modal plan-modal" onclick="event.stopPropagation()">
       <div class="modal-header">

package/public/style.css

@@ -1615,6 +1615,136 @@ body::before {
   border-color: var(--plan);
 }
 
+.loop-badge {
+  width: 24px;
+  height: 24px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  background: var(--bg-deep);
+  border: 1px solid transparent;
+  border-radius: 4px;
+  color: var(--text-secondary);
+  cursor: pointer;
+  flex-shrink: 0;
+  transition: all 0.15s ease;
+}
+
+.loop-badge:hover {
+  border-color: var(--accent, var(--plan));
+  color: var(--accent, var(--plan));
+}
+
+.loop-section-title {
+  margin: 14px 0 8px;
+  font-size: 12px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--text-secondary);
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.loop-section-title:first-child {
+  margin-top: 4px;
+}
+
+.loop-count {
+  font-size: 11px;
+  font-weight: 500;
+  padding: 1px 6px;
+  border-radius: 10px;
+  background: var(--bg-elevated);
+  color: var(--text-secondary);
+  text-transform: none;
+  letter-spacing: 0;
+}
+
+.loop-row {
+  padding: 12px 14px;
+  border: 1px solid var(--border);
+  border-left: 3px solid var(--border);
+  border-radius: 6px;
+  background: var(--bg-elevated);
+  margin-bottom: 10px;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.loop-row:has(.loop-fire-pending) {
+  border-left-color: var(--accent, var(--plan));
+}
+
+.loop-headline {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  flex-wrap: wrap;
+  font-variant-numeric: tabular-nums;
+}
+
+.loop-headline-rel {
+  font-size: 15px;
+  font-weight: 600;
+}
+
+.loop-headline-abs {
+  font-size: 12px;
+  color: var(--text-secondary);
+  margin-left: auto;
+}
+
+.loop-fire-pending {
+  color: var(--accent, var(--plan));
+}
+.loop-fire-fired {
+  color: var(--text-secondary);
+}
+.loop-fire-fired .loop-headline-rel {
+  font-weight: 500;
+}
+
+.loop-field {
+  display: grid;
+  grid-template-columns: 80px 1fr;
+  gap: 10px;
+  align-items: start;
+  font-size: 13px;
+  line-height: 1.45;
+}
+
+.loop-field-label {
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--text-secondary);
+  padding-top: 3px;
+}
+
+.loop-field-val {
+  color: var(--text-primary);
+  word-break: break-word;
+}
+
+.loop-field-val code {
+  background: var(--bg);
+  padding: 2px 6px;
+  border-radius: 4px;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 12px;
+}
+
+.loop-foot {
+  font-size: 11px;
+  color: var(--text-secondary);
+  padding-top: 6px;
+  border-top: 1px dashed var(--border);
+  font-variant-numeric: tabular-nums;
+}
+
 /* #endregion */
 
 /* #region OWNER_BADGE */
@@ -2358,6 +2488,28 @@ body::before {
   border-left: 3px solid var(--warning, #f5a623);
   background: color-mix(in srgb, var(--warning, #f5a623) 8%, transparent);
   animation: msg-waiting-pulse 2s ease-in-out infinite;
+  cursor: pointer;
+}
+.msg-waiting-discard {
+  flex-shrink: 0;
+  background: none;
+  border: none;
+  color: var(--text-muted);
+  cursor: pointer;
+  padding: 2px;
+  opacity: 0;
+  transition: opacity 0.15s;
+  margin-left: auto;
+  align-self: flex-start;
+  line-height: 0;
+}
+.msg-item.msg-waiting:hover .msg-waiting-discard {
+  opacity: 0.6;
+}
+.msg-waiting-discard:hover {
+  /* biome-ignore lint/complexity/noImportantStyles: override parent hover opacity */
+  opacity: 1 !important;
+  color: var(--danger, #e54d4d);
 }
 .msg-waiting .msg-text {
   font-weight: 600;

package/server.js

@@ -8,7 +8,7 @@ const readline = require('readline');
 const chokidar = require('chokidar');
 const os = require('os');
 const crypto = require('crypto');
-const { spawn } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
 
 const {
   readRecentMessages: _readRecentMessagesUncached,
@@ -21,7 +21,9 @@ const {
   extractPromptFromTranscript,
   extractModelFromTranscript,
   readFullToolResult,
-  readUserImage
+  readUserImage,
+  updateLoopInfo,
+  buildLoopInfoFromState
 } = require('./lib/parsers');
 
 if (process.argv.includes("--install") || process.argv.includes("--uninstall")) {
@@ -157,6 +159,45 @@ function isAgentFresh(agent) {
   return (Date.now() - new Date(ts).getTime()) < AGENT_TTL_MS;
 }
 
+// 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.
+const gitBranchCache = new Map();
+const GIT_BRANCH_TTL_MS = 30000;
+const GIT_BRANCH_CACHE_MAX = 500;
+function getGitBranch(cwd) {
+  if (!cwd) return null;
+  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 {
+    const r = spawnSync('git', ['-C', cwd, 'rev-parse', '--abbrev-ref', 'HEAD'], {
+      encoding: 'utf8', timeout: 500, windowsHide: true
+    });
+    if (r.status === 0) {
+      const out = (r.stdout || '').trim();
+      if (out && out !== 'HEAD') branch = out;
+    }
+  } catch (_) {}
+  gitBranchCache.set(cwd, { branch, ts: now });
+  if (gitBranchCache.size > GIT_BRANCH_CACHE_MAX) {
+    const firstKey = gitBranchCache.keys().next().value;
+    gitBranchCache.delete(firstKey);
+  }
+  return branch;
+}
+
+// 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 {
@@ -221,6 +262,11 @@ const clients = new Set();
 let sessionMetadataCache = {};
 let lastMetadataRefresh = 0;
 const METADATA_CACHE_TTL = 10000; // 10 seconds
+// Watcher-driven invalidation. `change` events (append to existing jsonl) only
+// dirty the one path so we can do a targeted refresh; `add` / `unlink` events
+// are structural and force a full rescan.
+const dirtyMetadataPaths = new Set();
+let metadataNeedsFullScan = true;
 
 const SAFE_ID_RE = /^[a-zA-Z0-9_-]+$/;
 function isSafeId(id) {
@@ -386,10 +432,50 @@ function readRecentMessages(jsonlPath, limit = 10) {
 /**
  * Scan all project directories to find session JSONL files and extract slugs
  */
+// Returns false when sessionId is unknown — caller must promote to full scan.
+function refreshSessionMetadataPath(jsonlPath) {
+  const sessionId = path.basename(jsonlPath, '.jsonl');
+  if (!isSafeId(sessionId)) return false;
+  const existing = sessionMetadataCache[sessionId];
+  if (!existing) return false;
+  let info;
+  try {
+    info = readSessionInfoFromJsonl(jsonlPath);
+  } catch (_) {
+    return false;
+  }
+  // Shadow JSONLs (continued from a worktree) hold only custom-title / agent-
+  // name records — no projectPath. Don't let a shadow clobber the real entry.
+  const shadow = existing.project && !info.projectPath;
+  if (shadow) {
+    if (!existing.slug && info.slug) existing.slug = info.slug;
+    if (!existing.customTitle && info.customTitle) existing.customTitle = info.customTitle;
+    return true;
+  }
+  if (info.slug) existing.slug = info.slug;
+  if (info.cwd) existing.cwd = info.cwd;
+  if (info.gitBranch) existing.gitBranch = info.gitBranch;
+  if (info.customTitle) existing.customTitle = info.customTitle;
+  return true;
+}
+
 function loadSessionMetadata() {
   const now = Date.now();
-  if (now - lastMetadataRefresh < METADATA_CACHE_TTL) {
-    return sessionMetadataCache;
+
+  if (!metadataNeedsFullScan && now - lastMetadataRefresh < METADATA_CACHE_TTL) {
+    if (dirtyMetadataPaths.size > 0) {
+      for (const p of dirtyMetadataPaths) {
+        if (!refreshSessionMetadataPath(p)) {
+          // Unknown sessionId — structural change snuck in. Promote to full.
+          metadataNeedsFullScan = true;
+          break;
+        }
+      }
+      dirtyMetadataPaths.clear();
+      if (!metadataNeedsFullScan) return sessionMetadataCache;
+    } else {
+      return sessionMetadataCache;
+    }
   }
 
   const metadata = {};
@@ -520,6 +606,8 @@ function loadSessionMetadata() {
 
   sessionMetadataCache = metadata;
   lastMetadataRefresh = now;
+  metadataNeedsFullScan = false;
+  dirtyMetadataPaths.clear();
   return metadata;
 }
 
@@ -536,6 +624,51 @@ function getPlanInfo(slug) {
   }
 }
 
+// Hide wakeups whose fire time is more than this far in the past — long /loop
+// sessions otherwise produce dozens of stale entries that drown the badge.
+const WAKEUP_FIRED_GRACE_MS = 5 * 60 * 1000;
+
+function isWakeupActive(w, now = Date.now()) {
+  if (!w || !w.timestamp || w.delaySeconds == null) return true;
+  const fireMs = new Date(w.timestamp).getTime() + w.delaySeconds * 1000;
+  return (now - fireMs) <= WAKEUP_FIRED_GRACE_MS;
+}
+
+function filterActiveLoopInfo(info) {
+  const now = Date.now();
+  return {
+    wakeups: info.wakeups.filter(w => isWakeupActive(w, now)),
+    crons: info.crons
+  };
+}
+
+// Per-path incremental scan state. Populated lazily on first access and
+// updated in place; the projectsWatcher event handler keeps entries warm so
+// the request path does O(1) work in steady state.
+const loopInfoStateByPath = new Map();
+
+function refreshLoopInfoState(jsonlPath) {
+  if (!jsonlPath) return null;
+  const prev = loopInfoStateByPath.get(jsonlPath);
+  const next = updateLoopInfo(jsonlPath, prev);
+  if (next) loopInfoStateByPath.set(jsonlPath, next);
+  return next;
+}
+
+function getLoopInfoSummary(meta) {
+  const empty = { wakeupCount: 0, cronCount: 0, latest: null };
+  if (!meta?.jsonlPath) return empty;
+  try {
+    const state = refreshLoopInfoState(meta.jsonlPath);
+    const filtered = filterActiveLoopInfo(buildLoopInfoFromState(state));
+    return {
+      wakeupCount: filtered.wakeups.length,
+      cronCount: filtered.crons.length,
+      latest: filtered.wakeups[filtered.wakeups.length - 1] || filtered.crons[filtered.crons.length - 1] || null
+    };
+  } catch (_) { return empty; }
+}
+
 function getSessionDisplayName(sessionId, meta) {
   if (meta?.customTitle) return meta.customTitle;
   if (meta?.slug) return meta.slug;
@@ -553,7 +686,7 @@ function buildSessionObject(id, meta, overrides = {}) {
     project: meta.project || null,
     cwd: meta.cwd || null,
     description: meta.description || null,
-    gitBranch: meta.gitBranch || null,
+    gitBranch: resolveSessionGitBranch(meta),
     customTitle: meta.customTitle || null,
     taskCount: 0,
     completed: 0,
@@ -573,6 +706,7 @@ function buildSessionObject(id, meta, overrides = {}) {
     projectDir: meta.jsonlPath ? path.dirname(meta.jsonlPath) : null,
     contextStatus: getContextStatus(id, meta),
     ...getPlanInfo(meta.slug),
+    loopInfo: getLoopInfoSummary(meta),
     ...overrides,
     // Remove internal-only field
     _logStat: undefined,
@@ -974,6 +1108,23 @@ app.get('/api/sessions/:sessionId/plan', async (req, res) => {
   }
 });
 
+app.get('/api/sessions/:sessionId/loop', (req, res) => {
+  try {
+    const metadata = loadSessionMetadata();
+    const meta = metadata[req.params.sessionId];
+    if (!meta?.jsonlPath) return res.json({ wakeups: [], crons: [] });
+    const state = refreshLoopInfoState(meta.jsonlPath);
+    const filtered = filterActiveLoopInfo(buildLoopInfoFromState(state));
+    res.json({
+      wakeups: [...filtered.wakeups].reverse(),
+      crons: [...filtered.crons].reverse()
+    });
+  } catch (error) {
+    console.error('Error reading loop info:', error);
+    res.status(500).json({ error: 'Failed to read loop info' });
+  }
+});
+
 function openInEditor(...targets) {
   const editor = process.env.EDITOR || 'code';
   spawn(editor, ['-n', ...targets], { shell: true, stdio: 'ignore', detached: true }).unref();
@@ -1223,6 +1374,20 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
   }
 });
 
+function clearWaitingFile(sessionId) {
+  try { unlinkSync(path.join(AGENT_ACTIVITY_DIR, sessionId, '_waiting.json')); }
+  catch (e) { if (e.code !== 'ENOENT') throw e; }
+}
+
+app.post('/api/sessions/:sessionId/waiting/discard', (req, res) => {
+  try {
+    clearWaitingFile(resolveSessionId(req.params.sessionId));
+    res.json({ ok: true });
+  } catch (e) {
+    res.status(500).json({ error: 'Failed to discard waiting' });
+  }
+});
+
 app.post('/api/sessions/:sessionId/agents/:agentId/stop', (req, res) => {
   const sessionId = resolveSessionId(req.params.sessionId);
   const agentId = sanitizeAgentId(req.params.agentId);
@@ -1234,9 +1399,7 @@ app.post('/api/sessions/:sessionId/agents/:agentId/stop', (req, res) => {
     agent.stoppedAt = new Date().toISOString();
     const stopEvt = { agentId, type: agent.type, event: 'user-stop', status: 'stopped', stoppedAt: agent.stoppedAt, updatedAt: agent.stoppedAt };
     writeFileSync(agentFile, readFileSync(agentFile, 'utf8') + JSON.stringify(stopEvt) + '\n', 'utf8'); // sync — response depends on write
-    // Also remove waiting state if present
-    const waitingFile = path.join(AGENT_ACTIVITY_DIR, sessionId, '_waiting.json');
-    if (existsSync(waitingFile)) unlinkSync(waitingFile);
+    clearWaitingFile(sessionId);
     res.json({ ok: true });
   } catch (e) {
     res.status(500).json({ error: 'Failed to stop agent' });
@@ -1928,13 +2091,27 @@ console.log(`Watching for team changes in: ${TEAMS_DIR}`);
 const projectsWatcher = chokidar.watch(PROJECTS_DIR, {
   persistent: true,
   ignoreInitial: true,
-  depth: 2
+  depth: 2,
+  awaitWriteFinish: { stabilityThreshold: 150, pollInterval: 50 }
 });
 
 projectsWatcher.on('all', (event, filePath) => {
-  if ((event === 'add' || event === 'change' || event === 'unlink') && filePath.endsWith('.jsonl')) {
-    // Invalidate cache on any change
-    lastMetadataRefresh = 0;
+  if (event !== 'add' && event !== 'change' && event !== 'unlink') return;
+  if (filePath.endsWith('.jsonl')) {
+    if (event === 'unlink') {
+      loopInfoStateByPath.delete(filePath);
+    } else {
+      // Warm the incremental scan state so the next request does no IO.
+      try { refreshLoopInfoState(filePath); } catch (_) {}
+    }
+    // add/unlink reshape the session set — promote to full rescan.
+    if (event === 'change') dirtyMetadataPaths.add(filePath);
+    else metadataNeedsFullScan = true;
+    broadcast({ type: 'metadata-update' });
+  } else if (path.basename(filePath) === 'sessions-index.json') {
+    // Index holds description / created / customTitle that the targeted
+    // refresh doesn't touch — promote to full rescan.
+    metadataNeedsFullScan = true;
     broadcast({ type: 'metadata-update' });
   }
 });
@@ -1947,7 +2124,9 @@ const plansWatcher = chokidar.watch(PLANS_DIR, {
 
 plansWatcher.on('all', (event, filePath) => {
   if ((event === 'add' || event === 'change' || event === 'unlink') && filePath.endsWith('.md')) {
-    lastMetadataRefresh = 0;
+    // Plan files don't affect cached session metadata — getPlanInfo is called
+    // fresh from buildSessionObject on every list build. The broadcast alone
+    // is enough to trigger a client refetch.
     broadcast({ type: 'metadata-update' });
     if (event === 'change') {
       const slug = path.basename(filePath, '.md');