claude-code-kanban 6.1.1 → 7.0.0

package/server.js

@@ -15,6 +15,8 @@ const { createNetGuard } = require('./lib/net-guard');
 const { isContained } = require('./lib/contain');
 const { resolveScratchSubdir, listScratchDir } = require('./lib/scratch-files');
 const { fileUrlToPath } = require('./lib/file-url');
+const { httpError: previewError } = require('./lib/http-error');
+const { oneLine } = require('./lib/one-line');
 const { pluginStatus } = require('./lib/plugin-status');
 const { getAutoCompact } = require('./lib/auto-compact');
 
@@ -22,12 +24,14 @@ const {
   readRecentMessages: _readRecentMessagesUncached,
   readMessagesPage: _readMessagesPageUncached,
   readSessionInfoFromJsonl,
+  modelDisplayName,
   buildSessionDigest,
   readCompactSummaries,
   readArtifactLinks,
   readScratchpadCreations,
   extractPromptFromTranscript,
   extractModelFromTranscript,
+  readSubagentMeta,
   extractAgentResultFromTranscript,
   extractTranscriptStats,
   readFullToolResult,
@@ -40,17 +44,21 @@ const {
 } = require('./lib/parsers');
 const { inlineHtmlAssets, MIME_BY_EXT } = require('./lib/inline-assets');
 const { buildDecision, decisionFileName, isDecisionFile, approvalsFrom, boardRefusal } = require('./lib/approvals');
-const { getClaudeDir, getArgValue, storageNamespace, isDefaultClaudeDir, encodeProjectDirName } = require('./lib/claude-dir');
+const { getClaudeDir, getArgValue, storageNamespace, isDefaultClaudeDir } = require('./lib/claude-dir');
 const { readTerminalConfig } = require('./lib/terminal');
 const { createTerminalClient } = require('./lib/terminal-client');
 const { readLiveSessions, isPidAlive, isSessionLive } = require('./lib/live-sessions');
 const { createProcStats } = require('./lib/proc-stats');
 const { createDispatchRegistry } = require('./lib/dispatch');
 const { createGroupStore, isGroupName, suggestGroupName } = require('./lib/dispatch-groups');
-const { createDispatchedStore, scanTranscripts, pruneSessionDirs, retentionMs } = require('./lib/retention');
+const { createDispatchedStore, scanTranscripts, pruneSessionDirs, pruneContextStatus, retentionMs } = require('./lib/retention');
+const { freshRateLimits } = require('./lib/rate-limits');
 const { createWorktreeStore } = require('./lib/worktrees');
+const { createScratchpadDirResolver } = require('./lib/scratchpad-dir');
 const { readGitBranch, sessionGitBranch } = require('./lib/git-branch');
 const { createLinkedDocStore, linkUrl } = require('./lib/linked-docs');
+const { createPaneStore, isOwnOrigin } = require('./lib/panes');
+const { probeFraming, parseOrigin } = require('./lib/frame-policy');
 const { pickFolder } = require('./lib/folder-dialog');
 const { loadSessionCache, saveSessionCache } = require('./lib/session-cache');
 const { countTaskDir } = require('./lib/task-counts');
@@ -102,6 +110,7 @@ const DISPATCH_GROUPS_FILE = path.join(CCK_DIR, 'dispatch-groups.json');
 const DISPATCHED_FILE = path.join(CCK_DIR, 'dispatched.json');
 const WORKTREES_FILE = path.join(CCK_DIR, 'worktrees.json');
 const LINKED_DOCS_FILE = path.join(CCK_DIR, 'linked-docs.json');
+const PANES_FILE = path.join(CCK_DIR, 'panes.json');
 const SERVER_INFO_FILE = path.join(CCK_DIR, 'server.json');
 const TERMINAL_TOKENS_DIR = path.join(CCK_DIR, 'terminal-tokens');
 const SESSION_CACHE_FILE = path.join(CCK_DIR, 'session-cache.json');
@@ -208,7 +217,6 @@ const SESSION_STALE_MS = 5 * 60 * 1000;
 // never the "active" status (which stays accurate via hasRecentLog).
 const SESSION_GRACE_MS = 2 * 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;
 const RETENTION_FIRST_RUN_MS = 5 * 60 * 1000;
@@ -302,11 +310,12 @@ function getContextStatus(sessionId, meta) {
 }
 
 function getContextFields(sessionId, meta) {
-  const contextStatus = getContextStatus(sessionId, meta);
+  // A team dir has no transcript of its own; its lead's transcript has the requests.
+  const m = meta?.teamLeaderId ? sessionMetadataCache[meta.teamLeaderId] : meta;
+  const reply = m?.lastReply;
   return {
-    contextStatus,
-    autoCompact: contextStatus ? getAutoCompact(CLAUDE_DIR, meta?.project) : null,
-    cacheTtl: meta?.cacheTtl || null,
+    contextStatus: getContextStatus(sessionId, meta),
+    cache: reply ? { ttl: m.cacheTtl || null, ...reply, modelName: modelDisplayName(reply.model) } : null,
   };
 }
 
@@ -828,6 +837,7 @@ function refreshSessionMetadataPath(jsonlPath) {
   if (info.compactBoundaryUuid) existing.compactBoundaryUuid = info.compactBoundaryUuid;
   existing.permissionMode = info.permissionMode;
   existing.cacheTtl = info.cacheTtl;
+  existing.lastReply = info.lastReply;
   return true;
 }
 
@@ -916,7 +926,8 @@ function loadSessionMetadata() {
           logicalParentUuid: sessionInfo.logicalParentUuid || null,
           compactBoundaryUuid: sessionInfo.compactBoundaryUuid || null,
           permissionMode: sessionInfo.permissionMode,
-          cacheTtl: sessionInfo.cacheTtl || null
+          cacheTtl: sessionInfo.cacheTtl || null,
+          lastReply: sessionInfo.lastReply || null
         };
         sessionIds.push(sessionId);
       }
@@ -1117,25 +1128,10 @@ function getSessionDisplayName(_sessionId, meta) {
   return null;
 }
 
-// Derived by convention, not looked up: the harness creates the dir lazily, so a
-// stat here would report "missing" for every session that has not written a temp
-// file yet — and it would put IO on the session-list hot path. Pure string join.
-function getScratchpadDir(id, meta) {
-  if (!meta.jsonlPath) return null;
-  const byProject = path.join(SCRATCHPAD_ROOT, path.basename(path.dirname(meta.jsonlPath)), id, 'scratchpad');
-
-  // A session launched with `claude -w` starts in the main checkout and enters the
-  // worktree afterwards, so the harness keys its scratchpad on the repo while the
-  // transcript ends up filed under the worktree. Neither the project nor any `cwd`
-  // in the log records that, so the two candidates are told apart by which one the
-  // harness actually created. Probed only for worktree sessions, and only until one
-  // of them exists — before that there is nothing to disambiguate and `byProject`,
-  // right for a session started inside the worktree, stands.
-  const wt = worktrees.resolve(meta.project);
-  if (!wt || existsSync(byProject)) return byProject;
-  const byRepo = path.join(SCRATCHPAD_ROOT, encodeProjectDirName(wt.repo), id, 'scratchpad');
-  return existsSync(byRepo) ? byRepo : byProject;
-}
+const getScratchpadDir = createScratchpadDirResolver({
+  root: SCRATCHPAD_ROOT,
+  resolveWorktree: worktrees.resolve,
+});
 
 function buildSessionObject(id, meta, overrides = {}) {
   const logStat = overrides._logStat || getSessionLogStat(meta);
@@ -1573,7 +1569,14 @@ app.get('/api/sessions', async (req, res) => {
     }
 
     // Loop info can mean a full read of the transcript, so only the rows sent pay for it.
-    for (const s of sessions) s.loopInfo = getLoopInfoSummary(s);
+    // Same for autoCompact: up to 3 settings stats per call.
+    const autoCompactByProject = new Map();
+    for (const s of sessions) {
+      s.loopInfo = getLoopInfoSummary(s);
+      if (!s.contextStatus) continue;
+      if (!autoCompactByProject.has(s.project)) autoCompactByProject.set(s.project, getAutoCompact(CLAUDE_DIR, s.project));
+      s.autoCompact = autoCompactByProject.get(s.project);
+    }
 
     res.json(withDispatchPlacement(sessions));
     startPrewarm();
@@ -2147,10 +2150,7 @@ app.get('/api/sessions/:sessionId/workflows/:wfId/run', async (req, res) => {
       for (const f of files) {
         const agentId = f.slice('agent-'.length, -'.jsonl'.length);
         const stats = (await extractTranscriptStats(path.join(runDir, f))) || {};
-        let type = null;
-        try {
-          type = JSON.parse(readFileSync(path.join(runDir, `agent-${agentId}.meta.json`), 'utf8')).agentType || null;
-        } catch (_) {}
+        const type = readSubagentMeta(path.join(runDir, f))?.agentType || null;
         const entry = journal.get(agentId);
         const durationMs = stats.firstTs && stats.lastTs ? new Date(stats.lastTs) - new Date(stats.firstTs) : null;
         if (stats.lastTs && (!stoppedAt || stats.lastTs > stoppedAt)) stoppedAt = stats.lastTs;
@@ -2382,6 +2382,8 @@ app.get('/api/teams/:name', (req, res) => {
 // The resultUnavailable latch is persisted on the agent record. Bump this when
 // extractAgentResultFromTranscript finds more, so agents latched earlier rescan once.
 const RESULT_SCAN = 3;
+// Same for the modelUnavailable latch and extractModelFromTranscript.
+const MODEL_SCAN = 2;
 
 app.get('/api/sessions/:sessionId/agents', async (req, res) => {
   const sessionId = resolveSessionId(req.params.sessionId);
@@ -2523,19 +2525,34 @@ app.get('/api/sessions/:sessionId/agents', async (req, res) => {
       }
     }
 
-    // Retry stopped agents even if modelUnavailable was set — it may have been marked
-    // unavailable while the agent was still active and its JSONL wasn't ready yet.
-    const agentsNeedingModel = agents.filter(a => !a.model && (!a.modelUnavailable || a.status === 'stopped'));
+    // The plugin's start record carries the model; this covers sessions without it.
+    const agentsNeedingModel = agents.filter(a => !a.model && a.modelUnavailable !== MODEL_SCAN);
     if (agentsNeedingModel.length && meta.jsonlPath) {
       for (const agent of agentsNeedingModel) {
+        const jsonl = subagentJsonlForExtraction(meta, agent.agentId);
         let model = null;
-        try { model = extractModelFromTranscript(subagentJsonlForExtraction(meta, agent.agentId)); } catch (_) {}
+        try { model = extractModelFromTranscript(jsonl); } catch (_) {}
         if (model) {
           agent.model = model;
           delete agent.modelUnavailable;
+          delete agent.modelAlias;
           dirty.add(agent);
-        } else if (agent.status === 'stopped' && !agent.modelUnavailable) {
-          agent.modelUnavailable = true;
+          continue;
+        }
+        // Until the transcript has an assistant line, show the requested alias.
+        // agent.model stays empty so the exact id is still looked up.
+        if (!agent.modelAlias) {
+          let alias = readSubagentMeta(jsonl)?.model || null;
+          if (alias === 'inherit') {
+            try { alias = extractModelFromTranscript(meta.jsonlPath); } catch (_) { alias = null; }
+          }
+          if (alias) {
+            agent.modelAlias = alias;
+            dirty.add(agent);
+          }
+        }
+        if (agent.status === 'stopped') {
+          agent.modelUnavailable = MODEL_SCAN;
           dirty.add(agent);
         }
       }
@@ -3662,25 +3679,19 @@ const PREVIEW_MAX_BYTES = 8 * 1024 * 1024;
 // Source in a modal is for reading, not for scrolling a generated bundle.
 const PREVIEW_TEXT_MAX_BYTES = 2 * 1024 * 1024;
 
-function previewError(status, message) {
-  const err = new Error(message);
-  err.status = status;
-  return err;
-}
-
 // Existence + kind of a file target, with the HTTP status codes both the preview and
 // the link-a-file endpoints report. `kind` is null for anything the previewer can't
 // render — the caller decides whether that disqualifies the path.
 async function statFileTarget(absPath) {
   try {
     const stats = await fs.stat(absPath);
-    if (!stats.isFile()) throw previewError(400, 'Not a file');
+    if (!stats.isFile()) throw previewError(400, 'Not a file', 'not_a_file');
     const kind = previewKindFor(absPath);
     return { size: stats.size, kind: kind === 'image' ? kind : await confirmKind(absPath, kind) };
   } catch (e) {
     if (e.status) throw e;
-    if (e.code === 'ENOENT') throw previewError(404, 'File not found');
-    if (e.code === 'EISDIR') throw previewError(400, 'Not a file');
+    if (e.code === 'ENOENT') throw previewError(404, 'File not found', 'file_not_found');
+    if (e.code === 'EISDIR') throw previewError(400, 'Not a file', 'not_a_file');
     throw e;
   }
 }
@@ -3688,7 +3699,7 @@ async function statFileTarget(absPath) {
 function enforcePreviewSize(kind, size) {
   const max = kind === 'text' ? PREVIEW_TEXT_MAX_BYTES : PREVIEW_MAX_BYTES;
   if (size > max) {
-    throw previewError(400, `Preview too large (${Math.round(size / 1048576)}MB, max ${max / 1048576}MB)`);
+    throw previewError(400, `Preview too large (${Math.round(size / 1048576)}MB, max ${max / 1048576}MB)`, 'too_large');
   }
 }
 
@@ -3696,7 +3707,7 @@ function enforcePreviewSize(kind, size) {
 // validation (and its status codes) but never the content.
 async function validatePreviewFile(absPath) {
   const { kind, size } = await statFileTarget(absPath);
-  if (!kind) throw previewError(400, 'Not a previewable text, markdown, HTML or image file');
+  if (!kind) throw previewError(400, 'Not a previewable text, markdown, HTML or image file', 'not_previewable');
   enforcePreviewSize(kind, size);
   return { kind, size };
 }
@@ -3778,7 +3789,7 @@ app.post('/api/preview', async (req, res) => {
 // API: Link a file to a session's sidebar docs without opening the preview modal.
 // Not extension-restricted, matching /api/file/resolve — an unpreviewable link just
 // opens in the editor. Unlinking skips the stat so a deleted file can still be removed.
-// An http(s) URL is linked as it is. `open` comes from `preview-doc <url>`: a tab cannot
+// An http(s) URL is linked as it is. `open` comes from `doc preview <url>`: a tab cannot
 // open a URL without a click, so the tab on screen offers an Open button.
 app.post('/api/document/link', async (req, res) => {
   try {
@@ -3933,6 +3944,116 @@ app.get('/api/file/resolve', async (req, res) => {
 
 // #endregion
 
+// #region PANES
+// Tabs next to Board in a session view. Each change broadcasts the whole layout with its rev,
+// so a tab replaces its copy when the rev is newer instead of applying a diff. Another board
+// on the same config dir writes the same file; the watcher broadcasts its changes here.
+const panesFileStamp = () => {
+  try {
+    const s = statSync(PANES_FILE);
+    return `${s.mtimeMs}:${s.size}`;
+  } catch {
+    return null;
+  }
+};
+let panesStamp;
+const panes = createPaneStore({
+  load: () => {
+    const stamp = panesFileStamp();
+    if (stamp === panesStamp) return undefined;
+    panesStamp = stamp;
+    try { return JSON.parse(readFileSync(PANES_FILE, 'utf8')); } catch { return null; }
+  },
+  save: (data) => {
+    writeJsonAtomic(PANES_FILE, data);
+    panesStamp = panesFileStamp();
+  },
+  onChange: (sessionId, layout) => broadcast({ type: 'pane:changed', sessionId, layout }),
+});
+chokidar.watch(PANES_FILE, { ignoreInitial: true }).on('all', (event) => {
+  if (event === 'add' || event === 'change') panes.reload();
+});
+
+let boardPort = null;
+const boardHosts = [...net.ALLOWED_HOSTS.split(','), net.EXPOSED ? net.BIND_HOST : '']
+  .map((h) => h.trim().toLowerCase())
+  .filter(Boolean);
+
+function paneRouteError(res, error, what) {
+  if (!error.status) console.error(`Error in ${what}:`, error);
+  const code = error.status ? error.code : 'internal';
+  res.status(error.status || 500).json({ error: error.message || `${what} failed`, code });
+}
+
+async function resolvePaneTarget(target, base) {
+  const url = linkUrl(target);
+  if (url) {
+    if (isOwnOrigin(url, { boardPort, boardHosts, hubUrl: process.env.HUB_URL })) {
+      throw previewError(400, 'A pane cannot show the board or the hub itself', 'own_origin');
+    }
+    return { kind: 'url', target: url };
+  }
+  const hasBase = typeof base === 'string' && path.isAbsolute(base);
+  if (!hasBase && !path.isAbsolute(fileUrlToPath(target))) {
+    throw previewError(400, 'target must be an http(s) URL, an absolute file path, or a relative path with an absolute base', 'bad_target');
+  }
+  const abs = resolvePreviewPath(target, base);
+  const { kind } = await validatePreviewFile(abs);
+  return { kind, target: await fs.realpath(abs) };
+}
+
+app.get('/api/panes/:sessionId', (req, res) => {
+  res.setHeader('Cache-Control', 'no-store');
+  res.json(panes.get(req.params.sessionId));
+});
+
+app.post('/api/panes/:sessionId', async (req, res) => {
+  try {
+    const { target, base, title } = req.body || {};
+    if (typeof target !== 'string' || !target) throw previewError(400, 'target is required', 'bad_target');
+    res.json(panes.add(req.params.sessionId, { ...(await resolvePaneTarget(target, base)), title }));
+  } catch (error) {
+    paneRouteError(res, error, 'POST /api/panes');
+  }
+});
+
+app.patch('/api/panes/:sessionId', (req, res) => {
+  try {
+    res.json({ layout: panes.reorder(req.params.sessionId, req.body?.order) });
+  } catch (error) {
+    paneRouteError(res, error, 'PATCH /api/panes');
+  }
+});
+
+// Probes only a pane's own target, so the route cannot fetch an arbitrary URL. `ancestors` is
+// the comma-separated origins above the frame: the board's page origin, then the hub's. The CLI
+// has no page, so without it the board's own origin and HUB_URL stand in; under the hub the page
+// is on the proxy port, which agrees for 'self', 'none' and policies that name neither.
+app.get('/api/panes/:sessionId/:paneId/framing', async (req, res) => {
+  try {
+    const { sessionId, paneId } = req.params;
+    const pane = panes.get(sessionId).panes.find((p) => p.id === paneId && p.kind === 'url');
+    if (!pane) throw previewError(404, `No URL pane ${paneId} in session ${sessionId}`, 'no_pane');
+    const fallback = [`http://localhost:${boardPort}`, process.env.HUB_URL].filter(Boolean).join(',');
+    const ancestors = String(req.query.ancestors || fallback)
+      .split(',')
+      .slice(0, 5)
+      .filter((o) => parseOrigin(o));
+    if (!ancestors.length) throw previewError(400, 'ancestors must name at least one http(s) origin', 'bad_ancestors');
+    res.json({ frameable: await probeFraming(pane.target, ancestors) });
+  } catch (error) {
+    paneRouteError(res, error, 'GET /api/panes/framing');
+  }
+});
+
+app.delete('/api/panes/:sessionId/:paneId', (req, res) => {
+  const { sessionId, paneId } = req.params;
+  const layout = panes.remove(sessionId, paneId);
+  if (!layout) return res.status(404).json({ error: `No pane ${paneId} in session ${sessionId}`, code: 'no_pane' });
+  res.json({ layout });
+});
+// #endregion
+
 // #region REVIEW
 // API: Send review comments on something the board shows (a file preview today) to a
 // session. The source is described, not interpreted, so a new kind of preview needs a
@@ -3947,11 +4068,7 @@ function parseReviewBody(body) {
   const { source, comments } = body || {};
   if (!source || !REVIEW_KIND_RE.test(source.kind)) throw previewError(400, 'source.kind is required');
   // The label is pasted into the terminal; an ESC could end bracketed paste and submit text.
-  const label = String(source.label || '')
-    // biome-ignore lint/suspicious/noControlCharactersInRegex: strips control characters on purpose
-    .replace(/[\x00-\x1f\x7f]/g, ' ')
-    .trim()
-    .slice(0, 200);
+  const label = oneLine(source.label, 200);
   if (!label) throw previewError(400, 'source.label is required');
   if (!Array.isArray(comments) || !comments.length || comments.length > REVIEW_MAX_COMMENTS) {
     throw previewError(400, `comments must hold 1 to ${REVIEW_MAX_COMMENTS} items`);
@@ -4063,6 +4180,10 @@ app.get('/api/context-status', (_req, res) => {
   res.json(Object.fromEntries(contextStatusCache));
 });
 
+app.get('/api/rate-limits', (_req, res) => {
+  res.json(freshRateLimits(contextStatusCache.values(), Date.now() / 1000));
+});
+
 app.use('/api', (_req, res) => {
   res.status(404).json({ error: 'Not found' });
 });
@@ -4246,47 +4367,35 @@ agentActivityWatcher.on('all', (event, filePath) => {
 const contextStatusWatcher = chokidar.watch(CONTEXT_STATUS_DIR, {
   persistent: true,
   ignoreInitial: false,
+  alwaysStat: true,
   depth: 0
 });
 
-contextStatusWatcher.on('all', (event, filePath) => {
+// The initial scan adds one event per kept file (up to MAX_CONTEXT_STATUS), so it broadcasts once at the end.
+let contextStatusReady = false;
+contextStatusWatcher.on('ready', () => {
+  contextStatusReady = true;
+  broadcast({ type: 'context-update', sessionId: null });
+});
+
+contextStatusWatcher.on('all', (event, filePath, stats) => {
   if (!filePath.endsWith('.json')) return;
   const sessionId = path.basename(filePath, '.json');
   if (event === 'add' || event === 'change') {
     try {
       const data = JSON.parse(readFileSync(filePath, 'utf8'));
-      try { data._updatedAt = statSync(filePath).mtimeMs; } catch (_) { data._updatedAt = Date.now(); }
+      data._updatedAt = stats?.mtimeMs ?? Date.now();
       contextStatusCache.set(sessionId, data);
-      evictStaleCache(contextStatusCache);
     } catch { /* ignore malformed */ }
-    broadcast({ type: 'context-update', sessionId });
   } else if (event === 'unlink') {
     contextStatusCache.delete(sessionId);
-    broadcast({ type: 'context-update', sessionId });
-  }
+  } else return;
+  if (contextStatusReady) broadcast({ type: 'context-update', sessionId });
 });
 
 // #endregion
 
 // #region CLEANUP
-async function cleanupContextStatus() {
-  try {
-    const entries = await fs.readdir(CONTEXT_STATUS_DIR);
-    const now = Date.now();
-    for (const f of entries) {
-      if (!f.endsWith('.json')) continue;
-      try {
-        const fp = path.join(CONTEXT_STATUS_DIR, f);
-        const st = statSync(fp);
-        if (now - st.mtimeMs > CTX_CLEANUP_MAX_AGE_MS) {
-          await fs.unlink(fp);
-          contextStatusCache.delete(path.basename(f, '.json'));
-        }
-      } catch { /* ignore */ }
-    }
-  } catch { /* dir may not exist */ }
-}
-
 async function cleanupAgentActivity() {
   try {
     const entries = await fs.readdir(AGENT_ACTIVITY_DIR, { withFileTypes: true });
@@ -4317,16 +4426,18 @@ async function cleanupAgentActivity() {
   } catch { /* agent-activity dir may not exist */ }
 }
 
-// Dispatch markers, reviews and worktrees: see docs/retention.md.
+// Dispatch markers, pane layouts, reviews, context status and worktrees: see docs/retention.md.
 async function runRetention() {
   try {
     const scan = await scanTranscripts(PROJECTS_DIR);
     const opts = { known: scan?.ids, maxAgeMs: retentionMs(CLAUDE_DIR) };
     const markers = dispatched.prune(opts);
+    const layouts = panes.prune(opts);
     const reviews = await pruneSessionDirs(REVIEW_DIR, opts);
+    const contexts = await pruneContextStatus(CONTEXT_STATUS_DIR, opts);
     const wts = worktrees.prune(scan?.dirs);
-    if (markers || reviews || wts) {
-      console.log(`[retention] removed ${markers} dispatch markers, ${reviews} reviews, ${wts} worktrees`);
+    if (markers || layouts || reviews || contexts || wts) {
+      console.log(`[retention] removed ${markers} dispatch markers, ${layouts} pane layouts, ${reviews} reviews, ${contexts} context status files, ${wts} worktrees`);
     }
   } catch (e) {
     console.warn('[retention] failed:', e.message);
@@ -4334,9 +4445,7 @@ async function runRetention() {
 }
 
 cleanupAgentActivity();
-cleanupContextStatus();
 setInterval(cleanupAgentActivity, CLEANUP_INTERVAL_MS);
-setInterval(cleanupContextStatus, 30 * 60 * 1000);
 // Later than the startup scan and prewarm, so the first sweep never competes with them.
 setTimeout(() => {
   runRetention();
@@ -4387,6 +4496,7 @@ async function prewarmCaches() {
 }
 
   const onReady = (actualPort) => {
+    boardPort = Number(actualPort);
     terminal.setServerUrl(`http://127.0.0.1:${actualPort}`);
     // The port is configurable and falls back to a random one when taken, so the postman
     // monitor cannot assume it -- publish the live one where it can read it.

package/skill-guides/dispatch.md

@@ -31,5 +31,5 @@ A crashed session sends nothing. To learn when one ends, `SendMessage` it with `
 
 ```bash
 claude-code-kanban dispatch list --json            # still running in cck's terminal
-claude-code-kanban session peek <session-id> --limit 20
+claude-code-kanban session view <session-id>       # its transcript path; read the last lines
 ```