claude-code-kanban 3.10.0 → 4.1.0

package/public/style.css

@@ -724,6 +724,12 @@ body::before {
   font-weight: 600;
 }
 
+.sidebar-footer .footer-limits .footer-limit-reset {
+  color: var(--text-tertiary);
+  font-weight: 400;
+  opacity: 0.75;
+}
+
 .sidebar-footer a:hover {
   color: var(--text-secondary);
 }
@@ -1743,6 +1749,55 @@ body::before {
   border-top: 1px solid var(--border);
 }
 
+.info-grid {
+  display: grid;
+  grid-template-columns: auto 1fr auto;
+  gap: 6px 12px;
+  align-items: center;
+  margin-bottom: 16px;
+}
+.info-row-actions {
+  display: flex;
+  gap: 4px;
+  opacity: 0.3;
+  transition: opacity 0.15s ease;
+}
+.info-grid:hover .info-row-actions {
+  opacity: 1;
+}
+.info-row-actions button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 22px;
+  height: 22px;
+  padding: 0;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  color: var(--text-secondary);
+  cursor: pointer;
+  transition:
+    background 0.1s ease,
+    border-color 0.1s ease,
+    color 0.1s ease;
+}
+.info-row-actions button:hover {
+  background: var(--bg-hover);
+  border-color: var(--accent);
+  color: var(--accent-text);
+}
+.info-row-actions button svg {
+  width: 12px;
+  height: 12px;
+  display: block;
+}
+@media (hover: none) {
+  .info-row-actions {
+    opacity: 1;
+  }
+}
+
 /* #endregion */
 
 /* #region OWNER_FILTER */
@@ -2107,6 +2162,11 @@ body::before {
   opacity: 1;
   color: var(--text-primary);
 }
+.agent-tab-copy svg {
+  width: 14px;
+  height: 14px;
+  display: block;
+}
 .toast {
   position: fixed;
   bottom: 16px;
@@ -2222,6 +2282,59 @@ body::before {
   border-radius: 3px;
   font-size: 11px;
 }
+.user-attach-chips {
+  display: flex;
+  gap: 4px;
+  flex-wrap: wrap;
+  margin-top: 4px;
+}
+.user-attach-chip {
+  font-size: 10px;
+  padding: 1px 6px;
+  border-radius: 10px;
+  background: var(--bg-hover);
+  color: var(--text-secondary);
+}
+.msg-text-muted {
+  color: var(--text-secondary);
+  font-size: 12px;
+}
+.user-attach-section {
+  margin-top: 12px;
+  padding-top: 10px;
+  border-top: 1px solid var(--border);
+}
+.user-attach-label {
+  font-size: 11px;
+  color: var(--text-secondary);
+  margin-bottom: 6px;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+.user-attach-images {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+.user-attach-image {
+  max-width: 100%;
+  max-height: 480px;
+  border-radius: 4px;
+  border: 1px solid var(--border);
+  background: var(--bg-hover);
+}
+.user-attach-toolresult {
+  margin-top: 6px;
+}
+.user-attach-toolresult > summary {
+  cursor: pointer;
+  font-size: 12px;
+  color: var(--text-secondary);
+  padding: 4px 0;
+}
+.user-attach-toolresult > summary code {
+  font-size: 10px;
+}
 .msg-item.msg-system {
   border-left: 3px solid var(--border);
 }
@@ -2241,6 +2354,30 @@ body::before {
   border-left: 3px solid var(--border);
   opacity: 0.75;
 }
+.msg-item.msg-waiting {
+  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;
+}
+.msg-waiting .msg-text {
+  font-weight: 600;
+}
+.msg-waiting-preview {
+  font-size: 11px;
+  opacity: 0.85;
+  margin-top: 2px;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+@keyframes msg-waiting-pulse {
+  0%,
+  100% {
+    background: color-mix(in srgb, var(--warning, #f5a623) 8%, transparent);
+  }
+  50% {
+    background: color-mix(in srgb, var(--warning, #f5a623) 16%, transparent);
+  }
+}
 .msg-item.msg-idle .msg-icon {
   width: 12px;
   height: 12px;
@@ -2531,12 +2668,31 @@ body::before {
   border: 1px solid var(--border);
 }
 .agent-badge {
-  font-size: 12px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
   cursor: default;
+  line-height: 1;
+  flex-shrink: 0;
+  color: var(--text-secondary);
+}
+.agent-badge-waiting {
+  color: var(--warning);
+  animation: agent-badge-pulse 1.6s ease-in-out infinite;
+}
+@keyframes agent-badge-pulse {
+  0%,
+  100% {
+    opacity: 0.65;
+  }
+  50% {
+    opacity: 1;
+  }
 }
 
 .linked-docs-badge,
-.bookmarks-badge {
+.bookmarks-badge,
+.scratchpad-badge {
   display: inline-flex;
   align-items: center;
   gap: 2px;
@@ -2552,7 +2708,8 @@ body::before {
 }
 
 .linked-docs-badge:hover,
-.bookmarks-badge:hover {
+.bookmarks-badge:hover,
+.scratchpad-badge:hover {
   border-color: var(--accent);
   color: var(--text-primary);
 }
@@ -3500,22 +3657,6 @@ pre.mermaid svg {
   color: var(--accent);
 }
 
-.marketplace-btn {
-  color: #888;
-  cursor: pointer;
-  display: inline-flex;
-  align-items: center;
-  transition:
-    color 0.15s,
-    filter 0.15s;
-  border-radius: 3px;
-}
-
-.marketplace-btn:hover {
-  color: var(--accent);
-  filter: drop-shadow(0 0 3px var(--accent));
-}
-
 .project-group-header .group-count {
   font-weight: 400;
   color: var(--text-muted);

package/server.js

@@ -20,7 +20,8 @@ const {
   findTerminatedTeammates,
   extractPromptFromTranscript,
   extractModelFromTranscript,
-  readFullToolResult
+  readFullToolResult,
+  readUserImage
 } = require('./lib/parsers');
 
 if (process.argv.includes("--install") || process.argv.includes("--uninstall")) {
@@ -95,19 +96,30 @@ function writePins(pins) {
   }
 }
 
-const PERMISSION_TTL_MS = 1800000;
-const AGENT_TTL_MS = 3600000;
-const AGENT_STALE_MS = 900000;
-const SESSION_STALE_MS = 300000;
-
-const WAITING_RESOLVE_GRACE_MS = 15000;
+// #region TIMINGS
+const PERMISSION_TTL_MS = 30 * 60 * 1000;
+const AGENT_TTL_MS = 60 * 60 * 1000;
+const AGENT_STALE_MS = 30 * 60 * 1000; // safety net for crashed sessions
+const SESSION_STALE_MS = 5 * 60 * 1000;
+const WAITING_RESOLVE_GRACE_MS = 15 * 1000;
+const CTX_CLEANUP_MAX_AGE_MS = 2 * 60 * 60 * 1000;
+const CLEANUP_MAX_AGE_MS = 2 * 24 * 60 * 60 * 1000;
+const CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
+// #endregion
+
+function readAgentJsonl(filePath) {
+  const raw = readFileSync(filePath, 'utf8');
+  const merged = {};
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try { Object.assign(merged, JSON.parse(line)); } catch (_) { /* skip malformed */ }
+  }
+  return merged;
+}
 
 function persistAgent(dir, agent) {
-  const file = path.join(dir, agent.agentId + '.json');
-  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
-  fs.writeFile(tmp, JSON.stringify(agent), 'utf8')
-    .then(() => fs.rename(tmp, file))
-    .catch(() => { fs.unlink(tmp).catch(() => {}); });
+  const file = path.join(dir, agent.agentId + '.jsonl');
+  fs.appendFile(file, JSON.stringify({ ...agent, event: 'server-update' }) + '\n', 'utf8').catch(() => {});
 }
 
 function checkWaitingForUser(agentDir, logMtime) {
@@ -125,6 +137,10 @@ function checkWaitingForUser(agentDir, logMtime) {
   return null;
 }
 
+function agentDisplayName(agent) {
+  return agent.type || agent.name;
+}
+
 function isGhostAgent(agent) {
   if (agent.startedAt !== agent.updatedAt || agent.lastMessage) return false;
   return (Date.now() - new Date(agent.startedAt).getTime()) >= AGENT_STALE_MS;
@@ -156,9 +172,9 @@ function checkAgentStatus(agentDir, stale, logMtime, isTeam) {
   if (result.waitingForUser) result.hasActive = true;
   if (stale && !isTeam) return result;
   try {
-    for (const file of readdirSync(agentDir).filter(f => f.endsWith('.json') && !f.startsWith('_'))) {
+    for (const file of readdirSync(agentDir).filter(f => f.endsWith('.jsonl') && !f.startsWith('_'))) {
       try {
-        const agent = JSON.parse(readFileSync(path.join(agentDir, file), 'utf8'));
+        const agent = readAgentJsonl(path.join(agentDir, file));
         if (isTeam && (agent.status === 'active' || agent.status === 'idle')) {
           result.hasActive = true;
           if (agent.status === 'active') result.hasRunning = true;
@@ -1050,17 +1066,17 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
     const isTeam = !!teamConfig;
     const teamMemberNames = isTeam ? new Set(teamConfig.members.map(m => m.name)) : null;
 
-    const files = readdirSync(agentDir).filter(f => f.endsWith('.json') && !f.startsWith('_'));
+    const files = readdirSync(agentDir).filter(f => f.endsWith('.jsonl') && !f.startsWith('_'));
     const agents = [];
     for (const file of files) {
       try {
-        const agent = JSON.parse(readFileSync(path.join(agentDir, file), 'utf8'));
+        const agent = readAgentJsonl(path.join(agentDir, file));
         if (isGhostAgent(agent)) continue;
         const agentTs = agent.updatedAt || agent.startedAt;
         const agentStale = !sessionStale && agentTs && (Date.now() - new Date(agentTs).getTime()) > AGENT_STALE_MS;
         if (!isAgentFresh(agent) || sessionStale || agentStale) {
           if (agent.status === 'active' || agent.status === 'idle') {
-            const agentName = agent.type || agent.name;
+            const agentName = agentDisplayName(agent);
             const isTeamMember = isTeam && agentName && teamMemberNames.has(agentName);
             if (!isTeamMember) {
               agent.status = 'stopped';
@@ -1077,7 +1093,7 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
         const terminated = getTerminatedTeammates(meta.jsonlPath);
         if (terminated.size) {
           for (const agent of liveAgents) {
-            const agentName = agent.type || agent.name;
+            const agentName = agentDisplayName(agent);
             if (agentName && terminated.has(agentName)) {
               const terminatedAt = terminated.get(agentName);
               if (terminatedAt && agent.startedAt && terminatedAt < agent.startedAt) continue;
@@ -1168,14 +1184,40 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
       }
       if (Object.keys(teamColors).length) {
         for (const agent of agents) {
-          const name = agent.type || agent.name;
+          const name = agentDisplayName(agent);
           if (name && teamColors[name]) agent.color = teamColors[name];
         }
       }
     }
 
+    // Collapse teammate re-spawns: when a teammate goes idle and is later re-engaged,
+    // a fresh agentId is spawned. Hide older idle/stopped entries when a newer same-name
+    // teammate exists; never hide an `active` agent (parallel teammate work would vanish).
+    // Subagents (Explore, general-purpose, etc.) are not in teamMemberNames and bypass
+    // dedup entirely, so parallel siblings of the same subagent type remain visible.
+    let visibleAgents = agents;
+    if (teamMemberNames && teamMemberNames.size) {
+      const groups = new Map();
+      for (const a of agents) {
+        const t = agentDisplayName(a);
+        if (!t || !teamMemberNames.has(t)) continue;
+        const list = groups.get(t) || [];
+        list.push(a);
+        groups.set(t, list);
+      }
+      const hidden = new Set();
+      for (const list of groups.values()) {
+        if (list.length < 2) continue;
+        list.sort((a, b) => new Date(b.startedAt || 0) - new Date(a.startedAt || 0));
+        for (const older of list.slice(1)) {
+          if (older.status === 'idle' || older.status === 'stopped') hidden.add(older.agentId);
+        }
+      }
+      if (hidden.size) visibleAgents = agents.filter(a => !hidden.has(a.agentId));
+    }
+
     const waitingForUser = checkWaitingForUser(agentDir, logMtime);
-    res.json({ agents, waitingForUser, teamColors });
+    res.json({ agents: visibleAgents, waitingForUser, teamColors });
   } catch (e) {
     res.json({ agents: [], waitingForUser: null });
   }
@@ -1184,13 +1226,14 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
 app.post('/api/sessions/:sessionId/agents/:agentId/stop', (req, res) => {
   const sessionId = resolveSessionId(req.params.sessionId);
   const agentId = sanitizeAgentId(req.params.agentId);
-  const agentFile = path.join(AGENT_ACTIVITY_DIR, sessionId, agentId + '.json');
+  const agentFile = path.join(AGENT_ACTIVITY_DIR, sessionId, agentId + '.jsonl');
   if (!existsSync(agentFile)) return res.status(404).json({ error: 'Agent not found' });
   try {
-    const agent = JSON.parse(readFileSync(agentFile, 'utf8'));
+    const agent = readAgentJsonl(agentFile);
     agent.status = 'stopped';
     agent.stoppedAt = new Date().toISOString();
-    writeFileSync(agentFile, JSON.stringify(agent), 'utf8'); // sync — response depends on write
+    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);
@@ -1214,30 +1257,122 @@ function subagentJsonlPath(meta, agentId) {
 }
 
 // Claude Code can scatter a session's records across multiple project dirs
-// (e.g. main repo + worktree), so the subagent JSONL may live under a
-// different project dir than meta.jsonlPath. Fall back to scanning when the
-// derived path is missing.
+// (e.g. main repo + worktree) and across sibling sessionId dirs when a
+// session is forked/resumed — the subagent JSONL stays under the original
+// parent sessionId. Fall back to scanning when the derived path is missing.
 const subagentPathCache = new Map();
+function findSubagentJsonlInProject(projPath, sessionId, agentId) {
+  const sameSid = path.join(projPath, sessionId, 'subagents', 'agent-' + agentId + '.jsonl');
+  if (existsSync(sameSid)) return sameSid;
+  let sessions;
+  try { sessions = readdirSync(projPath, { withFileTypes: true }); } catch { return null; }
+  for (const sess of sessions) {
+    if (!sess.isDirectory() || sess.name === sessionId) continue;
+    const candidate = path.join(projPath, sess.name, 'subagents', 'agent-' + agentId + '.jsonl');
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
 function resolveSubagentJsonl(meta, sessionId, agentId) {
   const primary = subagentJsonlPath(meta, agentId);
   if (existsSync(primary)) return primary;
   const key = sessionId + '/' + agentId;
-  if (subagentPathCache.has(key)) return subagentPathCache.get(key) || primary;
+  const cached = subagentPathCache.get(key);
+  if (cached) return cached;
   let found = null;
-  try {
-    for (const entry of readdirSync(PROJECTS_DIR, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      const candidate = path.join(
-        PROJECTS_DIR, entry.name, sessionId,
-        'subagents', 'agent-' + agentId + '.jsonl'
-      );
-      if (existsSync(candidate)) { found = candidate; break; }
-    }
-  } catch (_) { /* projects dir missing */ }
-  subagentPathCache.set(key, found);
+  const parent = lookupParentSession(sessionId);
+  if (parent.parentSessionId && parent.parentJsonlPath) {
+    const projDir = path.dirname(parent.parentJsonlPath);
+    const candidate = path.join(projDir, parent.parentSessionId, 'subagents', 'agent-' + agentId + '.jsonl');
+    if (existsSync(candidate)) found = candidate;
+  }
+  if (!found) {
+    try {
+      for (const proj of readdirSync(PROJECTS_DIR, { withFileTypes: true })) {
+        if (!proj.isDirectory()) continue;
+        found = findSubagentJsonlInProject(path.join(PROJECTS_DIR, proj.name), sessionId, agentId);
+        if (found) break;
+      }
+    } catch (_) { /* projects dir missing */ }
+  }
+  if (found) subagentPathCache.set(key, found);
   return found || primary;
 }
 
+// Claude Code marks fork lineage in two ways:
+//   1. `logicalParentUuid` on a system record (when present) points to a uuid
+//      in the parent session's JSONL.
+//   2. When absent, the fork copies the parent's early records verbatim, so
+//      the earliest `uuid` in this session also exists (same uuid+timestamp)
+//      in the parent's JSONL.
+// We try (1) first, then fall back to (2).
+const parentSessionCache = new Map();
+// Both anchor signals live in the first few records (system marker on top,
+// fork-copy starts at line 0), so cap the scan instead of reading the whole file.
+const FORK_ANCHOR_SCAN_LINES = 10;
+function findForkAnchorUuid(jsonlPath) {
+  let text;
+  try { text = readFileSync(jsonlPath, 'utf8'); } catch { return null; }
+  let firstUuid = null;
+  let scanned = 0;
+  for (const l of text.split('\n')) {
+    if (!l) continue;
+    if (scanned++ >= FORK_ANCHOR_SCAN_LINES) break;
+    try {
+      const d = JSON.parse(l);
+      if (d.logicalParentUuid) return d.logicalParentUuid;
+      if (!firstUuid && d.uuid) firstUuid = d.uuid;
+    } catch { /* skip malformed */ }
+  }
+  return firstUuid;
+}
+function findSessionContainingUuid(projectDir, targetUuid, excludeJsonlPath) {
+  let files;
+  try { files = readdirSync(projectDir); } catch { return null; }
+  const candidates = [];
+  for (const f of files) {
+    if (!f.endsWith('.jsonl')) continue;
+    const fp = path.join(projectDir, f);
+    if (fp === excludeJsonlPath) continue;
+    let text;
+    try { text = readFileSync(fp, 'utf8'); } catch { continue; }
+    if (!text.includes(targetUuid)) continue;
+    for (const l of text.split('\n')) {
+      if (!l || !l.includes(targetUuid)) continue;
+      try {
+        const d = JSON.parse(l);
+        if (d.uuid === targetUuid && d.sessionId) {
+          let mtime = 0;
+          try { mtime = statSync(fp).mtimeMs; } catch { /* ignore */ }
+          candidates.push({ parentSessionId: d.sessionId, parentJsonlPath: fp, mtime });
+          break;
+        }
+      } catch { /* skip */ }
+    }
+  }
+  if (!candidates.length) return null;
+  candidates.sort((a, b) => a.mtime - b.mtime);
+  const { parentSessionId, parentJsonlPath } = candidates[0];
+  return { parentSessionId, parentJsonlPath };
+}
+function lookupParentSession(sessionId) {
+  if (parentSessionCache.has(sessionId)) return parentSessionCache.get(sessionId);
+  const meta = loadSessionMetadata()[sessionId];
+  const result = { parentSessionId: null, parentJsonlPath: null };
+  if (meta?.jsonlPath) {
+    const anchorUuid = findForkAnchorUuid(meta.jsonlPath);
+    if (anchorUuid) {
+      const hit = findSessionContainingUuid(path.dirname(meta.jsonlPath), anchorUuid, meta.jsonlPath);
+      if (hit) Object.assign(result, hit);
+    }
+  }
+  if (result.parentSessionId) parentSessionCache.set(sessionId, result);
+  return result;
+}
+app.get('/api/sessions/:sessionId/parent', (req, res) => {
+  res.json(lookupParentSession(resolveSessionId(req.params.sessionId)));
+});
+
 app.get('/api/sessions/:sessionId/agents/:agentId/messages', (req, res) => {
   const sessionId = resolveSessionId(req.params.sessionId);
   const agentId = sanitizeAgentId(req.params.agentId);
@@ -1331,8 +1466,8 @@ app.get('/api/sessions/:sessionId/messages', (req, res) => {
         if (entry.description) msg.agentDescription = entry.description;
         if (entry.prompt && !msg.agentPrompt) msg.agentPrompt = entry.prompt;
         try {
-          const agentFile = path.join(agentDir, entry.agentId + '.json');
-          const agent = JSON.parse(readFileSync(agentFile, 'utf8'));
+          const agentFile = path.join(agentDir, entry.agentId + '.jsonl');
+          const agent = readAgentJsonl(agentFile);
           if (agent.lastMessage) msg.agentLastMessage = agent.lastMessage;
           if (agent.prompt && !msg.agentPrompt) msg.agentPrompt = agent.prompt;
           const prompt = msg.agentPrompt || entry.prompt;
@@ -1380,6 +1515,19 @@ app.get('/api/sessions/:sessionId/tool-result/:toolUseId', (req, res) => {
   res.json({ toolUseId: req.params.toolUseId, content });
 });
 
+app.get('/api/sessions/:sessionId/user-image/:msgUuid/:blockIndex', (req, res) => {
+  const metadata = loadSessionMetadata();
+  const meta = metadata[req.params.sessionId];
+  const jsonlPath = meta?.jsonlPath;
+  if (!jsonlPath) return res.status(404).end();
+  const img = readUserImage(jsonlPath, req.params.msgUuid, req.params.blockIndex);
+  if (!img) return res.status(404).end();
+  const buf = Buffer.from(img.data, 'base64');
+  res.setHeader('Content-Type', img.mediaType);
+  res.setHeader('Cache-Control', 'no-store');
+  res.end(buf);
+});
+
 app.get('/api/version', (req, res) => {
   const pkg = require('./package.json');
   res.json({ version: pkg.version });
@@ -1819,14 +1967,16 @@ const agentActivityWatcher = chokidar.watch(AGENT_ACTIVITY_DIR, {
 const AGENT_FILE_CAP = 20;
 
 agentActivityWatcher.on('all', (event, filePath) => {
-  if ((event === 'add' || event === 'change' || event === 'unlink') && filePath.endsWith('.json')) {
+  const base = path.basename(filePath);
+  const isAgentEvent = filePath.endsWith('.jsonl') || base === '_waiting.json';
+  if ((event === 'add' || event === 'change' || event === 'unlink') && isAgentEvent) {
     const relativePath = path.relative(AGENT_ACTIVITY_DIR, filePath);
     const sessionId = relativePath.split(path.sep)[0];
     // Cleanup: if session dir exceeds cap, delete oldest files by mtime
-    if (event === 'add') {
+    if (event === 'add' && filePath.endsWith('.jsonl')) {
       try {
         const sessionDir = path.join(AGENT_ACTIVITY_DIR, sessionId);
-        const files = readdirSync(sessionDir).filter(f => f.endsWith('.json') && !f.startsWith('_'));
+        const files = readdirSync(sessionDir).filter(f => f.endsWith('.jsonl') && !f.startsWith('_'));
         if (files.length > AGENT_FILE_CAP) {
           const withStats = files.map(f => {
             const fp = path.join(sessionDir, f);
@@ -1880,7 +2030,6 @@ contextStatusWatcher.on('all', (event, filePath) => {
   }
 });
 
-const CTX_CLEANUP_MAX_AGE_MS = 2 * 60 * 60 * 1000;
 async function cleanupContextStatus() {
   try {
     const entries = await fs.readdir(CONTEXT_STATUS_DIR);
@@ -1899,10 +2048,6 @@ async function cleanupContextStatus() {
   } catch (e) { /* dir may not exist */ }
 }
 
-// Cleanup agent-activity folders older than 2 days
-const CLEANUP_MAX_AGE_MS = 2 * 24 * 60 * 60 * 1000;
-const CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
-
 async function cleanupAgentActivity() {
   try {
     const entries = await fs.readdir(AGENT_ACTIVITY_DIR, { withFileTypes: true });