claude-code-kanban 5.1.1 → 5.3.0

package/README.md

@@ -71,8 +71,9 @@ Run `claude` in any project. You do not configure anything per project. Claude C
 - **Answer prompts from the board.** When Claude asks for permission, asks a question or waits for plan approval, the session gets an amber highlight and the ask shows with Allow and Deny buttons or an answer form. The terminal prompt stays open, and the first answer wins. [Answer prompts from the board](https://nikiforovall.blog/claude-code-kanban/guides/waiting-prompts/)
 - **Embedded terminal.** Run a real Claude Code process for any session next to its board (<kbd>Ctrl</kbd>+<kbd>&#96;</kbd>). <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>R</kbd> resumes a past session and <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>S</kbd> swaps to the previous one. The terminal is off by default when the board runs alone. Start it with `--enable-terminal` and open the `#t=<token>` link the server prints. [Embedded terminal](https://nikiforovall.blog/claude-code-kanban/guides/embedded-terminal/)
 - **New session.** <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>N</kbd> opens a dialog to pick a folder, a name, a model, an optional git worktree and a first prompt. Needs the terminal.
-- **Dispatch.** Hand a written task to a new session with `claude-code-kanban dispatch start`, or ask Claude to do it with the `kanban-dispatch` skill. Add `--report` to get the outcome back. Needs the terminal. [Dispatch tasks to other sessions](https://nikiforovall.blog/claude-code-kanban/guides/dispatch/)
-- **Steer with card moves.** Run `/claude-code-kanban:kanban-follow` in a session, then drag its cards. Claude starts, parks or stops the task. [Claude Code plugin skills](https://nikiforovall.blog/claude-code-kanban/guides/plugin-skills/)
+- **Dispatch.** Hand a written task to a new session with `claude-code-kanban dispatch start`, or ask Claude to do it with the `dispatch` skill. Add `--report` to get the outcome back. Needs the terminal. [Dispatch tasks to other sessions](https://nikiforovall.blog/claude-code-kanban/guides/dispatch/)
+- **Steer with card moves.** Run `/claude-code-kanban:follow` in a session, then drag its cards. Claude starts, parks or stops the task. [Claude Code plugin skills](https://nikiforovall.blog/claude-code-kanban/guides/plugin-skills/)
+- **Review comments.** Select text in a previewed file or the plan, add comments and send them to the session in one step. [Review comments](https://nikiforovall.blog/claude-code-kanban/guides/review-comments/)
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="website/public/shots/themes/ember-11-waiting-prompt-dark.webp">

package/lib/auto-compact.js

@@ -0,0 +1,42 @@
+const path = require('node:path');
+const { readSettings } = require('./claude-settings');
+
+const MIN_WINDOW = 100000;
+const MAX_WINDOW = 1000000;
+
+function toInt(v) {
+  const n = typeof v === 'number' ? v : typeof v === 'string' && /^\d+$/.test(v.trim()) ? Number(v) : NaN;
+  return Number.isFinite(n) ? n : null;
+}
+
+// Claude Code merges settings as project local > project > user, and an env var beats the
+// `autoCompactWindow` key. Shell env and managed settings are not visible from here.
+// https://code.claude.com/docs/en/env-vars.md, https://code.claude.com/docs/en/settings-reference.md
+function getAutoCompact(claudeDir, projectPath) {
+  const files = [path.join(claudeDir, 'settings.json')];
+  if (projectPath) {
+    files.push(path.join(projectPath, '.claude', 'settings.json'), path.join(projectPath, '.claude', 'settings.local.json'));
+  }
+  let enabled = true;
+  let envWindow = null;
+  let keyWindow = null;
+  let pct = null;
+  for (const file of files) {
+    const s = readSettings(file);
+    if (!s || typeof s !== 'object') continue;
+    if (typeof s.autoCompactEnabled === 'boolean') enabled = s.autoCompactEnabled;
+    keyWindow = toInt(s.autoCompactWindow) ?? keyWindow;
+    envWindow = toInt(s.env?.CLAUDE_CODE_AUTO_COMPACT_WINDOW) ?? envWindow;
+    pct = toInt(s.env?.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE) ?? pct;
+  }
+  if (!enabled) return null;
+  const window = envWindow ?? keyWindow;
+  const validPct = pct != null && pct >= 1 && pct <= 100 ? pct : null;
+  if (window == null && validPct == null) return null;
+  return {
+    window: window == null ? null : Math.min(MAX_WINDOW, Math.max(MIN_WINDOW, window)),
+    pct: validPct,
+  };
+}
+
+module.exports = { getAutoCompact };

package/lib/claude-dir.js

@@ -50,4 +50,10 @@ function displayPath(p) {
   return rel.split(path.sep).join('/');
 }
 
-module.exports = { getArgValue, getClaudeDir, claudeCliEnv, isDefaultClaudeDir, displayPath, storageNamespace };
+// The harness spells a project path into a temp/log dir name by replacing every
+// non-alphanumeric character with a dash, drive colon and separators included.
+function encodeProjectDirName(p) {
+  return p.replace(/[^a-zA-Z0-9]/g, '-');
+}
+
+module.exports = { getArgValue, getClaudeDir, claudeCliEnv, isDefaultClaudeDir, displayPath, storageNamespace, encodeProjectDirName };

package/lib/claude-settings.js

@@ -0,0 +1,21 @@
+const fs = require('node:fs');
+
+const fileCache = new Map();
+
+// Parsed Claude Code settings file, or null when it is missing or invalid. Re-read only
+// after its mtime changes.
+function readSettings(file) {
+  const mtime = fs.statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? null;
+  const hit = fileCache.get(file);
+  if (hit && hit.mtime === mtime) return hit.data;
+  let data = null;
+  if (mtime !== null) {
+    try {
+      data = JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch {}
+  }
+  fileCache.set(file, { mtime, data });
+  return data;
+}
+
+module.exports = { readSettings };

package/lib/dispatch.js

@@ -8,7 +8,7 @@
 
 const crypto = require('node:crypto');
 const { tokenMatches } = require('./terminal');
-const { clampWait } = require('./session-events');
+const { clampWait, EVENT_PREFIX } = require('./session-events');
 
 const OUTCOMES = new Set(['succeeded', 'failed']);
 const MAX_SUMMARY = 4000;
@@ -45,9 +45,16 @@ function formatPreamble(record, cli = 'claude-code-kanban') {
 
 // The line reaches the parent through the postman at hook trust level; the summary is
 // last so no summary text can pose as a further field.
+const DISPATCH_OUTCOME = {
+  succeeded: 'reported success',
+  failed: 'reported failure',
+  exited: 'ended without a report',
+};
+
 function formatDispatchLine(r) {
-  const head = `cck:1 dispatch.${r.status} ${r.id} session=${r.session}`;
-  return r.summary ? `${head} summary=${r.summary}` : head;
+  const outcome = DISPATCH_OUTCOME[r.status] || r.status;
+  const head = `${EVENT_PREFIX} Dispatch ${r.id} (session ${r.session}) ${outcome}.`;
+  return r.summary ? `${head} Summary: ${r.summary}` : head;
 }
 
 function publicView(r) {
@@ -169,4 +176,4 @@ function createDispatchRegistry({ onSettle, now = Date.now } = {}) {
   return { create, attach, discard, settle, sessionExited, list, wait };
 }
 
-module.exports = { createDispatchRegistry, formatPreamble, formatDispatchLine, isPeerName };
+module.exports = { createDispatchRegistry, formatPreamble, formatDispatchLine, isPeerName, DISPATCH_OUTCOME };

package/lib/net-guard.js

@@ -37,11 +37,14 @@ const PORT_RE = /^[0-9]{1,5}$/;
 // port dynamic, so only the host is allowlisted.
 const validPort = (p) => PORT_RE.test(p) && Number(p) >= 1 && Number(p) <= 65535;
 const KEEP_ALIVE_MS = 65000;
+// A whole IPv4 literal: a prefix test would let a rebinding name like 127.evil.com through.
+const LOOPBACK_V4_RE = /^127(?:\.(?:25[0-5]|2[0-4]\d|1?\d?\d)){3}$/;
 
 function isLoopbackAddress(host) {
   if (!host) return false;
-  const h = String(host).toLowerCase();
-  return LOOPBACK_HOSTS.has(h) || h.startsWith('127.');
+  // An Origin or URL host carries an IPv6 literal in brackets.
+  const h = String(host).toLowerCase().replace(/^\[(.*)\]$/, '$1');
+  return LOOPBACK_HOSTS.has(h) || LOOPBACK_V4_RE.test(h);
 }
 
 // Hand-parsed rather than via new URL(), which is far more permissive than we
@@ -102,7 +105,7 @@ function getFlag(name) {
 }
 
 /**
- * @param {{appName?: string}} [config]
+ * @param {{appName?: string, selfFramedPaths?: string[]}} [config]
  */
 function createNetGuard(config = {}) {
   const appName = config.appName || 'This app';
@@ -216,9 +219,18 @@ function createNetGuard(config = {}) {
     CSP = "frame-ancestors 'none'";
   }
 
-  function frameGuard(_req, res, next) {
+  // Alone, these pages may be framed by this app's own port under its loopback names, for a page
+  // that frames itself from its other name to get its own renderer process.
+  const selfFramed = new Set(config.selfFramedPaths || []);
+
+  function frameGuard(req, res, next) {
     res.setHeader('X-Content-Type-Options', 'nosniff');
     res.setHeader('Referrer-Policy', 'no-referrer');
+    if (!hubOrigin && selfFramed.has(req.path)) {
+      const port = req.socket.localPort;
+      res.setHeader('Content-Security-Policy', `frame-ancestors 'self' http://localhost:${port} http://127.0.0.1:${port}`);
+      return next();
+    }
     res.setHeader('Content-Security-Policy', CSP);
     if (!hubOrigin) res.setHeader('X-Frame-Options', 'DENY');
     next();
@@ -232,7 +244,10 @@ function createNetGuard(config = {}) {
    * the OS resolver orders A/AAAA records - binding only 127.0.0.1 breaks hosts
    * where `localhost` resolves to ::1, and vice versa. Doing it on the *resolved*
    * port means every existing URL, startup banner and postMessage origin is
-   * unchanged. Failures are swallowed: it is an optimization, not a requirement.
+   * unchanged. A family the host does not have is skipped. A port that another
+   * process holds on the other family is treated as busy: the primary closes and
+   * emits EADDRINUSE (port 0 picks another random port instead), because that process would answer `localhost:<port>` (and a
+   * cross-site frame on it) in our name. onReady waits for the second bind.
    *
    * Returns the primary server, so callers keep attaching their own 'error'
    * handler for the EADDRINUSE fallback.
@@ -259,18 +274,30 @@ function createNetGuard(config = {}) {
     };
     const server = makeServer(app);
     let secondary = null;
+    let randomTries = 0;
 
     server.on('listening', () => {
-      actualPort = server.address().port;
-      if (!EXPOSED) {
-        const otherFamily = BIND_HOST.includes(':') ? '127.0.0.1' : '::1';
-        try {
-          secondary = makeServer(app);
-          secondary.on('error', () => {}); // that family may not exist on this host
-          secondary.listen({ host: otherFamily, port: actualPort, ipv6Only: otherFamily === '::1' });
-        } catch { /* best effort */ }
+      const boundPort = server.address().port;
+      actualPort = boundPort;
+      // Not actualPort: the hub listens several servers through one guard, and another one can bind
+      // while this one waits for its second family.
+      const ready = () => { if (onReady) onReady(boundPort); };
+      if (EXPOSED) return ready();
+      const otherFamily = BIND_HOST.includes(':') ? '127.0.0.1' : '::1';
+      try {
+        secondary = makeServer(app);
+        secondary.once('listening', ready);
+        secondary.on('error', (err) => {
+          if (err.code !== 'EADDRINUSE') return ready();
+          // A caller asking for port 0 has no fallback of its own, so it gets another random port here.
+          if (port === 0 && ++randomTries < 5) return server.close(() => server.listen(0, BIND_HOST));
+          server.close();
+          server.emit('error', err);
+        });
+        secondary.listen({ host: otherFamily, port: boundPort, ipv6Only: otherFamily === '::1' });
+      } catch {
+        ready();
       }
-      if (onReady) onReady(actualPort);
     });
     server.on('close', () => { try { if (secondary) secondary.close(); } catch { /* already gone */ } });
 

package/lib/proc-stats.js

@@ -0,0 +1,82 @@
+'use strict';
+
+// Memory and CPU of a few processes in one OS call. Only the processes named: a process-tree walk
+// costs more than the number is worth. CPU is the change in cumulative CPU time since the last
+// call, so the first call for a pid has none.
+const { execFile } = require('node:child_process');
+
+const QUERY_TIMEOUT_MS = 10000;
+// An older sample would turn the CPU number into an average over minutes.
+const MAX_BASELINE_MS = 30000;
+
+function parseCpuTime(text) {
+  const [days, clock] = text.includes('-') ? text.split('-') : ['0', text];
+  const seconds = clock.split(':').reduce((acc, part) => acc * 60 + Number.parseFloat(part), 0);
+  return (Number(days) * 86400 + seconds) * 1000;
+}
+
+// Lines of "pid workingSetBytes cpuMs".
+function parseWindows(stdout) {
+  const out = new Map();
+  for (const line of stdout.split(/\r?\n/)) {
+    const [pid, rss, cpuMs] = line.trim().split(/\s+/).map(Number);
+    if (pid && Number.isFinite(rss) && Number.isFinite(cpuMs)) out.set(pid, { rss, cpuMs });
+  }
+  return out;
+}
+
+// Lines of `ps -o pid=,rss=,time=`: rss in KiB, time as [dd-]hh:mm:ss on Linux or mm:ss.ss on macOS.
+function parsePs(stdout) {
+  const out = new Map();
+  for (const line of stdout.split(/\r?\n/)) {
+    const [pid, rss, time] = line.trim().split(/\s+/);
+    if (!time) continue;
+    const cpuMs = parseCpuTime(time);
+    if (Number(pid) && Number.isFinite(cpuMs)) out.set(Number(pid), { rss: Number(rss) * 1024, cpuMs });
+  }
+  return out;
+}
+
+function query(pids, platform = process.platform) {
+  return new Promise((resolve) => {
+    const ids = pids.join(',');
+    const [file, args, parse] = platform === 'win32'
+      ? ['powershell.exe', ['-NoProfile', '-NonInteractive', '-Command',
+        `Get-Process -Id ${ids} -ErrorAction SilentlyContinue | ForEach-Object { "$($_.Id) $($_.WorkingSet64) $([long]$_.TotalProcessorTime.TotalMilliseconds)" }`], parseWindows]
+      : ['ps', ['-o', 'pid=,rss=,time=', '-p', ids], parsePs];
+    // ps exits 1 when a pid is gone, and still prints the others.
+    execFile(file, args, { windowsHide: true, timeout: QUERY_TIMEOUT_MS }, (_err, stdout) => resolve(parse(stdout || '')));
+  });
+}
+
+function createProcStats({ run = query, now = Date.now } = {}) {
+  let last = new Map();
+  let inFlight = null;
+
+  async function sample(pids) {
+    const at = now();
+    const found = await run(pids);
+    const next = new Map();
+    const result = {};
+    for (const pid of pids) {
+      const cur = found.get(pid);
+      if (!cur) continue;
+      const prev = last.get(pid);
+      const fresh = prev && at - prev.at <= MAX_BASELINE_MS && cur.cpuMs >= prev.cpuMs;
+      result[pid] = { rss: cur.rss, cpu: fresh ? Math.round(((cur.cpuMs - prev.cpuMs) / (at - prev.at)) * 100) : null };
+      next.set(pid, { at, cpuMs: cur.cpuMs });
+    }
+    last = next;
+    return result;
+  }
+
+  // Asks that overlap share one OS call.
+  return function stats(pids) {
+    const valid = [...new Set(pids)].filter((p) => Number.isInteger(p) && p > 0);
+    if (!valid.length) return Promise.resolve({});
+    inFlight ??= sample(valid).finally(() => { inFlight = null; });
+    return inFlight;
+  };
+}
+
+module.exports = { createProcStats, parseWindows, parsePs, parseCpuTime };

package/lib/retention.js

@@ -0,0 +1,140 @@
+// Expiry of per-session state cck writes. The rule and the sweep: docs/retention.md.
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { readSettings } = require('./claude-settings');
+const { DISPATCH_OUTCOME } = require('./dispatch');
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_CLEANUP_DAYS = 30;
+// A started session writes its transcript a moment after the record; the sweep must not
+// read that gap as a deleted transcript.
+const GRACE_MS = 60 * 60 * 1000;
+const MAX_DISPATCHED = 500;
+const OUTCOMES = new Set(Object.keys(DISPATCH_OUTCOME));
+
+// Only the config dir's settings: retention is per config dir, not per project.
+function retentionMs(claudeDir) {
+  const days = readSettings(path.join(claudeDir, 'settings.json'))?.cleanupPeriodDays;
+  return (Number.isInteger(days) && days > 0 ? days : DEFAULT_CLEANUP_DAYS) * DAY_MS;
+}
+
+// `known` is the set of session ids with a transcript, or null when the scan found none,
+// so a failed scan never reads as every transcript gone.
+function isExpired(id, at, { known, maxAgeMs, now }) {
+  const age = now - at;
+  if (age < GRACE_MS) return false;
+  return (known && !known.has(id)) || age > maxAgeMs;
+}
+
+/**
+ * Sessions started through `dispatch start`, kept after the dispatch settles so the card
+ * keeps its marker.
+ * @param {object} o
+ * @param {() => object|null} o.load returns `{version: 1, sessions: {[id]: {parent, status, at}}}` or null
+ * @param {(data: object) => void} o.save
+ */
+function createDispatchedStore({ load, save, now = Date.now }) {
+  // Insertion order is oldest first, so the cap drops the first key.
+  const entries = new Map();
+  const saved = load()?.sessions;
+  if (saved && typeof saved === 'object') {
+    for (const [id, e] of Object.entries(saved)) {
+      if (!e || !Number.isFinite(e.at)) continue;
+      // The dispatch registry is in memory: a dispatch that was running when the server
+      // stopped can never settle, so it reads as ended.
+      const status = OUTCOMES.has(e.status) ? e.status : 'exited';
+      entries.set(id, { parent: typeof e.parent === 'string' ? e.parent : null, status, at: e.at });
+    }
+  }
+
+  const persist = () => save({ version: 1, sessions: Object.fromEntries(entries) });
+
+  function record(id, parent) {
+    entries.delete(id);
+    entries.set(id, { parent: parent || null, status: 'running', at: now() });
+    if (entries.size > MAX_DISPATCHED) entries.delete(entries.keys().next().value);
+    persist();
+  }
+
+  function settle(id, status) {
+    const e = entries.get(id);
+    if (!e || e.status !== 'running' || !OUTCOMES.has(status)) return;
+    e.status = status;
+    persist();
+  }
+
+  // Returns how many entries went; writes only when one did.
+  function prune({ known, maxAgeMs }) {
+    const t = now();
+    let removed = 0;
+    for (const [id, e] of entries) {
+      if (isExpired(id, e.at, { known, maxAgeMs, now: t })) {
+        entries.delete(id);
+        removed++;
+      }
+    }
+    if (removed) persist();
+    return removed;
+  }
+
+  return { record, settle, prune, get: (id) => entries.get(id) || null };
+}
+
+// Names only, no stat or parse: the sweep needs which transcripts exist, not what they hold.
+// `ids` are session ids and `dirs` the project dir names holding at least one transcript. Null
+// when none is found, so a missing or unreadable projects dir never reads as every transcript gone.
+async function scanTranscripts(projectsDir) {
+  const ids = new Set();
+  const dirs = new Set();
+  let entries;
+  try {
+    entries = await fs.readdir(projectsDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const d of entries) {
+    if (!d.isDirectory()) continue;
+    try {
+      for (const f of await fs.readdir(path.join(projectsDir, d.name))) {
+        if (!f.endsWith('.jsonl')) continue;
+        ids.add(f.slice(0, -'.jsonl'.length));
+        dirs.add(d.name);
+      }
+    } catch {}
+  }
+  return ids.size ? { ids, dirs } : null;
+}
+
+// `<dir>/<session id>/<ts>.md`, one folder per session.
+async function pruneSessionDirs(dir, { known, maxAgeMs, now = Date.now() }) {
+  let removed = 0;
+  let sessionDirs;
+  try {
+    sessionDirs = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const d of sessionDirs) {
+    if (!d.isDirectory()) continue;
+    const sessionDir = path.join(dir, d.name);
+    try {
+      const files = await fs.readdir(sessionDir);
+      let kept = 0;
+      for (const f of files) {
+        const file = path.join(sessionDir, f);
+        const { mtimeMs } = await fs.stat(file);
+        if (isExpired(d.name, mtimeMs, { known, maxAgeMs, now })) {
+          await fs.rm(file, { force: true });
+          removed++;
+        } else kept++;
+      }
+      // An old mtime means no file was added since the read, so a review written right
+      // now cannot lose its folder.
+      if (!kept && now - (await fs.stat(sessionDir)).mtimeMs >= GRACE_MS) await fs.rmdir(sessionDir);
+    } catch {}
+  }
+  return removed;
+}
+
+module.exports = { createDispatchedStore, scanTranscripts, pruneSessionDirs, retentionMs, GRACE_MS, MAX_DISPATCHED, DAY_MS };

package/lib/session-events.js

@@ -29,13 +29,33 @@ function sanitizeEventLine(line) {
   return line.replace(/[\x00-\x1f\x7f]/g, ' ').trim().slice(0, 1500);
 }
 
-// Everything after `description=` is the description verbatim to end of line, so no amount
-// of board text can pose as a further field. That leaves the subject as the only value
-// that needs delimiting.
+// Lines are plain sentences so they still read right once the skill that explains them has
+// left the agent's context. EVENT_PREFIX marks the board as the sender.
+const EVENT_PREFIX = '[kanban board]';
+
+// Everything after `Description:` is the description verbatim to end of line, so no amount
+// of board text can pose as a further part of the line. That leaves the subject as the only
+// value that needs delimiting.
 function formatTaskMoved(taskId, prevStatus, task) {
   const subject = String(task.subject || '').replace(/(["\\])/g, '\\$1');
-  const head = `cck:1 task.moved ${taskId} ${prevStatus || 'none'}>${task.status} subject="${subject}"`;
-  return task.description ? `${head} description=${task.description}` : head;
+  const from = prevStatus ? ` from ${prevStatus}` : '';
+  const head = `${EVENT_PREFIX} The user moved task ${taskId} "${subject}"${from} to ${task.status}.`;
+  return task.description ? `${head} Description: ${task.description}` : head;
+}
+
+// The comments themselves live in the review file; the line only points at it, because a
+// batch of quotes would not survive the one-line cap. The path comes last and runs to end
+// of line, so a space in the config dir cannot split it.
+function formatReviewSubmitted(count, label, reviewFile) {
+  const comments = `${count} review comment${count === 1 ? '' : 's'}`;
+  return `${EVENT_PREFIX} The user left ${comments} on ${label}. Address them: ${reviewFile}`;
+}
+
+// A postman between two polls has no waiter for a moment, so this can miss a live one.
+// The caller then falls back to another route, which only costs a duplicate route, never
+// a lost review.
+function hasSessionListener(sessionId) {
+  return !!sessionEventBuckets.get(sessionId)?.waiters.size;
 }
 
 function enqueueSessionEvent(sessionId, line) {
@@ -59,8 +79,8 @@ function clampWait(sec) {
   return Math.min(Math.max(Number(sec) || 0, 0), MAX_WAIT_SEC);
 }
 
-// Each topic rides its own bucket, so the kanban-dispatch postman never prints task moves
-// the user did not grant with kanban-follow. No topic is the task-move bucket.
+// Each topic rides its own bucket, so the dispatch postman never prints task moves
+// the user did not grant with the follow skill. No topic is the task-move bucket.
 function topicKey(topic, sessionId) {
   return topic ? `${topic}:${sessionId}` : sessionId;
 }
@@ -109,9 +129,12 @@ function drain(sessionId, bucket) {
 }
 
 module.exports = {
+  EVENT_PREFIX,
   sessionEventBuckets,
   sanitizeEventLine,
   formatTaskMoved,
+  formatReviewSubmitted,
+  hasSessionListener,
   enqueueSessionEvent,
   handleSessionEvents,
   topicKey,

package/lib/terminal.js

@@ -356,16 +356,24 @@ function createTerminalService(o) {
   // Waits for claude to turn on bracketed paste (its input box is live), then for the
   // screen to settle. A folder-trust question also takes input, and Enter there would
   // answer it, so the prompt waits for as long as that question is on screen.
+  function bracketed(text) {
+    return `\x1b[200~${text.replace(/\r?\n/g, '\r')}\x1b[201~`;
+  }
+
+  function onTrustScreen(s) {
+    return /\btrust\b/i.test(screenText(s.term));
+  }
+
   function queuePrompt(s, prompt) {
     let armed = false;
     let timer = null;
-    const text = `\x1b[200~${prompt.replace(/\r?\n/g, '\r')}\x1b[201~`;
+    const text = bracketed(prompt);
     s.onOutput = (data) => {
       if (!armed && data.includes('\x1b[?2004h')) armed = true;
       if (!armed) return;
       clearTimeout(timer);
       timer = setTimeout(() => {
-        if (s.exited || /\btrust\b/i.test(screenText(s.term))) return;
+        if (s.exited || onTrustScreen(s)) return;
         s.onOutput = null;
         s.pty.write(text);
         setTimeout(() => { if (!s.exited) s.pty.write('\r'); }, 100);
@@ -379,9 +387,13 @@ function createTerminalService(o) {
     if (s.claudePid || s.mode === 'pick') return s.claudePid;
     const live = o.liveSessions();
     const own = live.find((l) => l.pid && l.sessionId === s.id && l.startedAt >= s.startedAt - PICK_START_SLACK_MS);
-    if (own || s.mode !== 'fork') return own?.pid;
+    if (own || s.mode !== 'fork') {
+      s.claudePid = own?.pid;
+      return s.claudePid;
+    }
     const claimed = new Set([...sessions.values()].map((x) => x.claudePid).filter(Boolean));
-    return findPickProcess(live, s, claimed);
+    s.claudePid = findPickProcess(live, s, claimed);
+    return s.claudePid;
   }
 
   // claude writes its registry entry a moment after it starts, so the pid is polled for.
@@ -396,7 +408,6 @@ function createTerminalService(o) {
         clearInterval(s.boostTimer);
         s.boostTimer = null;
         if (!pid) return;
-        if (s.mode !== 'shell') s.claudePid = pid;
         const before = priority.raise(pid);
         s.boost = { pid, before };
       };
@@ -627,6 +638,16 @@ function createTerminalService(o) {
     }));
   }
 
+  function claudePids() {
+    const out = {};
+    for (const s of sessions.values()) {
+      if (s.ended || s.exited || s.mode === 'shell') continue;
+      const pid = inputPid(s);
+      if (pid) out[s.id] = pid;
+    }
+    return out;
+  }
+
   function isRunning(id) {
     const s = sessions.get(id);
     return !!s && !s.ended;
@@ -654,6 +675,18 @@ function createTerminalService(o) {
     return r.error ? r : { id: r.session.id, cwd: r.session.cwd };
   }
 
+  // Pastes into claude's input box and stops there: Enter would also submit whatever the
+  // user had half-typed, and over a permission dialog it would answer it. A fork runs under
+  // a new session id, so its terminal id does not name the session the text is for. A
+  // pending queued prompt owns the input box until it is sent.
+  function paste(id, text) {
+    const s = sessions.get(id);
+    if (!s || s.ended || s.exited || s.onOutput || s.mode === 'shell' || s.mode === 'fork') return false;
+    if (onTrustScreen(s)) return false;
+    s.pty.write(bracketed(text));
+    return true;
+  }
+
   function shutdown() {
     shuttingDown = true;
     clearTimeout(saveTimer);
@@ -663,7 +696,7 @@ function createTerminalService(o) {
     sessions.clear();
   }
 
-  return { token, handleUpgrade, clientConfig, list, isRunning, end, authorized, startNew, restore, shutdown, unavailableReason };
+  return { token, handleUpgrade, clientConfig, list, claudePids, isRunning, end, authorized, startNew, paste, restore, shutdown, unavailableReason };
 }
 
 module.exports = { createTerminalService, readTerminalConfig, ptyEnv, shellArgs, resolveShell, claudeArgsFor, parseNewSpec, findPickProcess, tokenMatches };