claude-code-kanban 7.5.0 → 7.6.1

package/lib/show.js

@@ -0,0 +1,385 @@
+// The show overlay's server side: posts a terminal's session makes through the plugin's show tool.
+// The card belongs to the terminal and the posts to the session, so the store maps terminal id
+// to its current session and keeps each session's posts in <scratchpad>/.cck/show/.
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const express = require('express');
+const { httpError } = require('./http-error');
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const SHOW_PATH = '/api/terminals/:terminalId/show';
+const BODY_LIMIT = '16kb';
+const MAX_LABEL = 200;
+const EXT = { markdown: 'md', html: 'html' };
+const CONTENT_FILE_RE = new RegExp(`^(${UUID_RE.source.slice(1, -1)})\\.(md|html)$`, 'i');
+// An editor can save in two steps, so a refresh waits for the writes to settle.
+const SETTLE_MS = 200;
+
+function isLabel(v) {
+  return typeof v === 'string' && v.trim() !== '' && v.length <= MAX_LABEL;
+}
+
+// A string is a reason the body is refused.
+function parsePost(body) {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return 'body must be a JSON object';
+  const { sessionId, title, key, kind = 'markdown', content, file } = body;
+  if (typeof sessionId !== 'string' || !UUID_RE.test(sessionId)) return 'invalid sessionId';
+  if (!isLabel(title)) return `title must be a non-empty string of at most ${MAX_LABEL} characters`;
+  if (key != null && !isLabel(key)) return `key must be a non-empty string of at most ${MAX_LABEL} characters`;
+  if (!Object.hasOwn(EXT, kind)) return 'kind must be markdown or html';
+  if (content != null) return 'content is not accepted: call show with only title and key to get a file to write the card into';
+  if (file != null && (typeof file !== 'string' || !path.isAbsolute(file))) return 'file must be an absolute path';
+  return { sessionId, title, key: key ?? null, kind, file: file ?? null };
+}
+
+function writeAtomic(file, text) {
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.writeFileSync(tmp, text, 'utf8');
+    fs.renameSync(tmp, file);
+  } catch (e) {
+    fs.rmSync(tmp, { force: true });
+    throw e;
+  }
+}
+
+/**
+ * @param {object} o
+ * @param {() => Object<string, string>|null} o.load  terminal id → session id, as saved
+ * @param {() => void} o.onChange  the map changed and should be saved
+ * @param {(sessionId: string) => string|null} o.resolveDir  the session's scratchpad, null when its transcript is unknown
+ * @param {(terminalId: string) => string|null} [o.startedSession]  the session a live terminal was started with
+ * @param {(e: object) => void} [o.onPosted]  a post was made or its file changed on disk, once per terminal showing its session
+ * @param {() => number} [o.now]
+ */
+function createShowStore(o) {
+  const now = o.now || Date.now;
+  const current = new Map();
+  const watchers = new Map();
+  // Post id → the claim file's mtime as cck last saw it, so a second watch event for one save is not a change.
+  const seen = new Map();
+  for (const [terminalId, sessionId] of Object.entries(o.load?.() || {})) {
+    if (UUID_RE.test(terminalId) && typeof sessionId === 'string' && UUID_RE.test(sessionId)) current.set(terminalId, sessionId);
+  }
+
+  function folder(sessionId) {
+    const dir = o.resolveDir(sessionId);
+    return dir ? path.join(dir, '.cck', 'show') : null;
+  }
+
+  function contentPath(dir, entry) {
+    return path.join(dir, `${entry.id}.${EXT[entry.kind]}`);
+  }
+
+  function postPath(dir, entry) {
+    return entry.file || contentPath(dir, entry);
+  }
+
+  function locate(terminalId, postId) {
+    const sessionId = sessionOf(terminalId);
+    const dir = sessionId && UUID_RE.test(postId) ? folder(sessionId) : null;
+    const posts = dir ? readPosts(dir) : [];
+    return { sessionId, dir, posts, at: posts.findIndex((p) => p.id === postId) };
+  }
+
+  function writeIndex(dir, sessionId, posts) {
+    writeAtomic(path.join(dir, 'index.json'), JSON.stringify({ sessionId, posts }, null, 2));
+  }
+
+  function notify(sessionId, entry, at, count, replaced) {
+    if (!o.onPosted) return;
+    for (const [terminalId, s] of current) {
+      if (s !== sessionId) continue;
+      o.onPosted({ terminalId, sessionId, id: entry.id, title: entry.title, key: entry.key, index: at + 1, count, replaced });
+    }
+  }
+
+  function touch(sessionId, dir, postId) {
+    const posts = readPosts(dir);
+    const at = posts.findIndex((p) => p.id === postId);
+    const entry = posts[at];
+    if (!entry || entry.file) return;
+    let mtime;
+    try {
+      mtime = fs.statSync(contentPath(dir, entry)).mtimeMs;
+    } catch {
+      return;
+    }
+    if (mtime === seen.get(postId)) return;
+    seen.set(postId, mtime);
+    entry.updatedAt = new Date(now()).toISOString();
+    writeIndex(dir, sessionId, posts);
+    notify(sessionId, entry, at, posts.length, true);
+  }
+
+  function watch(sessionId, dir) {
+    if (!o.onPosted || watchers.has(sessionId)) return;
+    let w;
+    try {
+      // libuv aborts the process on a change under an 8.3 short path (NIKIFO~1), so watch the long form.
+      w = fs.watch(fs.realpathSync.native(dir));
+    } catch {
+      return;
+    }
+    w.unref();
+    const timers = new Map();
+    // A watch left on a deleted folder keeps the process from exiting on Windows.
+    w.on('change', (event, name) => {
+      if (event === 'rename' && !fs.existsSync(dir)) return unwatch(sessionId);
+      const id = CONTENT_FILE_RE.exec(String(name ?? ''))?.[1];
+      if (!id) return;
+      clearTimeout(timers.get(id));
+      const t = setTimeout(() => {
+        timers.delete(id);
+        try {
+          touch(sessionId, dir, id);
+        } catch (e) {
+          console.error('[show] refresh failed:', e.message);
+        }
+      }, SETTLE_MS);
+      t.unref();
+      timers.set(id, t);
+    });
+    w.on('error', () => unwatch(sessionId));
+    watchers.set(sessionId, () => {
+      for (const t of timers.values()) clearTimeout(t);
+      w.close();
+    });
+  }
+
+  function unwatch(sessionId) {
+    watchers.get(sessionId)?.();
+    watchers.delete(sessionId);
+  }
+
+  function unwatchUnused() {
+    const used = new Set(current.values());
+    for (const sessionId of watchers.keys()) if (!used.has(sessionId)) unwatch(sessionId);
+  }
+
+  function readPosts(dir) {
+    try {
+      const index = JSON.parse(fs.readFileSync(path.join(dir, 'index.json'), 'utf8'));
+      if (Array.isArray(index.posts)) return index.posts;
+    } catch { /* no posts yet */ }
+    return [];
+  }
+
+  function removeContent(dir, id) {
+    for (const ext of Object.values(EXT)) fs.rmSync(path.join(dir, `${id}.${ext}`), { force: true });
+  }
+
+  // A session resumed in a new terminal gets a new terminal id, so a terminal with no posts yet
+  // takes the posts of the session it was started with.
+  function sessionOf(terminalId) {
+    const known = current.get(terminalId);
+    if (known) return known;
+    const started = o.startedSession?.(terminalId);
+    const dir = started && UUID_RE.test(started) ? folder(started) : null;
+    if (!dir || !readPosts(dir).length) return null;
+    bind(terminalId, started);
+    return started;
+  }
+
+  function bind(terminalId, sessionId) {
+    if (current.get(terminalId) === sessionId) return;
+    current.set(terminalId, sessionId);
+    unwatchUnused();
+    o.onChange();
+  }
+
+  // `kind` of a file post is the one readPreviewFile gave when it was posted. A post without a file
+  // is a claim: cck names the file and the session writes it. cck does not create it, because
+  // Claude Code's Write refuses to overwrite a file the session has not read.
+  function post(terminalId, { sessionId, title, key, kind, file }) {
+    const dir = folder(sessionId);
+    if (!dir) throw httpError(409, 'no transcript found for that session');
+    fs.mkdirSync(dir, { recursive: true });
+    const posts = readPosts(dir);
+    let at = key == null ? -1 : posts.findIndex((p) => p.key === key);
+    const old = at >= 0 ? posts[at] : null;
+    const id = old ? old.id : crypto.randomUUID();
+    const target = file == null ? contentPath(dir, { id, kind }) : null;
+    if (target && old && !old.file) {
+      const from = contentPath(dir, old);
+      if (from !== target && fs.existsSync(from)) fs.renameSync(from, target);
+    } else if (old) {
+      removeContent(dir, id);
+      seen.delete(id);
+    }
+    if (!old) at = posts.length;
+    const entry = { id, title, key, kind, file, updatedAt: new Date(now()).toISOString() };
+    posts[at] = entry;
+    writeIndex(dir, sessionId, posts);
+    bind(terminalId, sessionId);
+    watch(sessionId, dir);
+    notify(sessionId, entry, at, posts.length, !!old);
+    return { id, title, key, index: at + 1, count: posts.length, replaced: !!old, path: target };
+  }
+
+  function list(terminalId) {
+    const sessionId = sessionOf(terminalId);
+    if (!sessionId) return { sessionId: null, posts: [] };
+    const dir = folder(sessionId);
+    const posts = dir ? readPosts(dir) : [];
+    if (posts.length) watch(sessionId, dir);
+    return { sessionId, posts };
+  }
+
+  // The post's index entry and its stored content; `waiting` when a claim file is not written yet.
+  function get(terminalId, postId) {
+    const { dir, posts, at } = locate(terminalId, postId);
+    if (at < 0) return null;
+    const entry = posts[at];
+    const file = postPath(dir, entry);
+    if (entry.file) return { entry, content: null, path: file };
+    try {
+      return { entry, content: fs.readFileSync(file, 'utf8'), path: file };
+    } catch {
+      return { entry, content: null, path: file, waiting: true };
+    }
+  }
+
+  // Returns the session and the paths of the posts it had.
+  function clear(terminalId) {
+    const sessionId = sessionOf(terminalId);
+    const dir = sessionId && folder(sessionId);
+    const paths = [];
+    if (dir) {
+      unwatch(sessionId);
+      for (const p of readPosts(dir)) {
+        seen.delete(p.id);
+        paths.push(postPath(dir, p));
+      }
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+    return { sessionId, paths };
+  }
+
+  // A file post's file belongs to the session, so only cck's own copy is deleted.
+  function remove(terminalId, postId) {
+    const { sessionId, dir, posts, at } = locate(terminalId, postId);
+    if (at < 0) return null;
+    const [entry] = posts.splice(at, 1);
+    writeIndex(dir, sessionId, posts);
+    removeContent(dir, postId);
+    seen.delete(postId);
+    return { sessionId, count: posts.length, path: postPath(dir, entry) };
+  }
+
+  // Drops the terminals that `keep` no longer knows, and gives the map to save.
+  function prune(keep) {
+    for (const terminalId of current.keys()) if (!keep(terminalId)) current.delete(terminalId);
+    unwatchUnused();
+    return Object.fromEntries(current);
+  }
+
+  return { sessionOf, post, list, get, clear, remove, prune };
+}
+
+// Mounted before the global JSON parser: the parser that runs first owns the body.
+function showBodyParser() {
+  return express.json({ limit: BODY_LIMIT });
+}
+
+/**
+ * @param {import('express').Express} app
+ * @param {object} o
+ * @param {ReturnType<typeof createShowStore>} o.store
+ * @param {(token: string|undefined) => boolean} o.authorized  the terminal token
+ * @param {(terminalId: string) => boolean} o.hasTerminal  a live terminal has this id
+ * @param {(absPath: string) => Promise<{content: string|null, kind: string|null}>} o.readPreviewFile
+ * @param {(event: object) => void} o.broadcast
+ * @param {(sessionId: string, paths: string[]) => void} [o.onRemoved]  posts left the card; their files' panes go too
+ */
+function mountShowRoutes(app, o) {
+  const { store } = o;
+
+  function guard(req, res) {
+    if (!o.authorized(req.get('x-terminal-token'))) return res.status(401).json({ error: 'invalid terminal token' });
+    if (!o.hasTerminal(req.params.terminalId)) return res.status(404).json({ error: 'no live terminal with that id' });
+    return null;
+  }
+
+  async function readFilePost(file) {
+    let read;
+    try {
+      read = await o.readPreviewFile(file);
+    } catch (e) {
+      if (e.status === 404) throw httpError(404, `file not found: ${file}`);
+      throw e;
+    }
+    if (!read.kind) throw httpError(400, 'not a markdown, HTML, text or image file');
+    // The previewer shows SVG as source; the card draws it in its sandboxed frame. The prolog
+    // would read as a whole document there.
+    if (read.kind === 'text' && /\.svg$/i.test(file)) {
+      return { kind: 'html', content: read.content.replace(/^(?:\s*(?:<\?xml[\s\S]*?\?>|<!doctype[^>]*>))*/i, '') };
+    }
+    return read;
+  }
+
+  const route = (fn) => (req, res) => fn(req, res).catch((e) => {
+    if (res.headersSent) return;
+    if (!e.status) console.error(`Error in ${req.method} ${req.path}:`, e);
+    res.status(e.status || 500).json({ error: e.status ? e.message : 'Internal error' });
+  });
+
+  app.post(SHOW_PATH, route(async (req, res) => {
+    if (guard(req, res)) return;
+    const p = parsePost(req.body);
+    if (typeof p === 'string') return res.status(400).json({ error: p });
+    if (p.file) {
+      try {
+        p.kind = (await readFilePost(p.file)).kind;
+      } catch (e) {
+        return res.status(400).json({ error: e.message });
+      }
+    }
+    res.json(store.post(req.params.terminalId, p));
+  }));
+
+  app.get(SHOW_PATH, (req, res) => {
+    res.setHeader('Cache-Control', 'no-store');
+    res.json(store.list(req.params.terminalId));
+  });
+
+  app.get(`${SHOW_PATH}/:postId`, route(async (req, res) => {
+    res.setHeader('Cache-Control', 'no-store');
+    const found = store.get(req.params.terminalId, req.params.postId);
+    if (!found) return res.status(404).json({ error: 'no such post' });
+    const { entry } = found;
+    const out = { id: entry.id, title: entry.title, key: entry.key, kind: entry.kind, content: found.content, file: entry.file, path: found.path, url: null };
+    if (found.waiting) out.waiting = true;
+    if (entry.file) {
+      const { content, kind } = await readFilePost(entry.file);
+      out.kind = kind;
+      out.content = content;
+      if (kind === 'image') out.url = `/api/preview/image?path=${encodeURIComponent(entry.file)}`;
+    }
+    res.json(out);
+  }));
+
+  app.delete(SHOW_PATH, route(async (req, res) => {
+    if (guard(req, res)) return;
+    const { sessionId, paths } = store.clear(req.params.terminalId);
+    if (sessionId) {
+      o.broadcast({ type: 'show:cleared', terminalId: req.params.terminalId, sessionId });
+      if (paths.length) o.onRemoved?.(sessionId, paths);
+    }
+    res.status(204).end();
+  }));
+
+  app.delete(`${SHOW_PATH}/:postId`, route(async (req, res) => {
+    if (guard(req, res)) return;
+    const { terminalId, postId } = req.params;
+    const removed = store.remove(terminalId, postId);
+    if (!removed) return res.status(404).json({ error: 'no such post' });
+    o.broadcast({ type: 'show:removed', terminalId, sessionId: removed.sessionId, id: postId, count: removed.count });
+    o.onRemoved?.(removed.sessionId, [removed.path]);
+    res.status(204).end();
+  }));
+}
+
+module.exports = { createShowStore, mountShowRoutes, showBodyParser, parsePost, SHOW_PATH };

package/lib/terminal-client.js

@@ -41,6 +41,7 @@ function createTerminalClient(o) {
   let child = null;
   let hostReason = null;
   let ids = [];
+  let terminalIds = [];
   let serverUrl = null;
   let restoreAsked = false;
   let stopped = false;
@@ -76,6 +77,7 @@ function createTerminalClient(o) {
     if (msg.t === 'state') {
       hostReason = msg.reason;
       ids = msg.ids;
+      terminalIds = msg.terminalIds || [];
       settle(hostReason);
       o.onChange?.();
     } else if (msg.t === 'exit') o.onExit?.(msg.id);
@@ -118,6 +120,7 @@ function createTerminalClient(o) {
     console.log(`Terminal host exited (${signal || code})`);
     const lost = ids;
     ids = [];
+    terminalIds = [];
     for (const id of lost) o.onExit?.(id);
     o.onChange?.();
     const now = Date.now();
@@ -162,6 +165,16 @@ function createTerminalClient(o) {
     return ids.includes(id);
   }
 
+  function hasTerminal(terminalId) {
+    return terminalIds.includes(terminalId);
+  }
+
+  // The host sends both lists from one array of terminals.
+  function sessionOfTerminal(terminalId) {
+    const at = terminalIds.indexOf(terminalId);
+    return at < 0 ? null : ids[at];
+  }
+
   async function startNew(msg, extraEnv) {
     if (localReason) return { status: 403, error: localReason };
     return call('startNew', msg, extraEnv);
@@ -212,7 +225,7 @@ function createTerminalClient(o) {
   else spawn();
 
   return {
-    token, handleUpgrade, clientConfig, unavailableReason, authorized, isRunning, startNew, end, paste, restore,
+    token, handleUpgrade, clientConfig, unavailableReason, authorized, isRunning, hasTerminal, sessionOfTerminal, startNew, end, paste, restore,
     setServerUrl, sessions, stats, shutdown, started,
     ids: () => [...ids],
   };

package/lib/terminal-host.js

@@ -27,7 +27,8 @@ function ask(op, arg) {
 
 // The service reports every attach and detach too; cck needs only a change of ids or reason.
 function pushState() {
-  const state = { t: 'state', reason: service.unavailableReason(), ids: service.list().map((s) => s.id) };
+  const live = service.list();
+  const state = { t: 'state', reason: service.unavailableReason(), ids: live.map((s) => s.id), terminalIds: live.map((s) => s.terminalId) };
   const key = JSON.stringify(state);
   if (key === lastState) return;
   lastState = key;

package/lib/terminal.js

@@ -74,6 +74,8 @@ const STRIP_ENV = [
   // session's child and writes no live-session registry entry, which the resume picker relies on.
   'CLAUDE_CODE_CHILD_SESSION', 'CLAUDE_CODE_SESSION_ID', 'CLAUDE_PID', 'CLAUDE_CODE_SESSION_ATTENDED',
   'CLAUDE_CODE_MESSAGING_SOCKET', 'CLAUDE_CODE_MESSAGING_TOKEN', 'CLAUDE_CODE_EXECPATH',
+  // The parent session's effort level; a terminal session takes its own from settings or --effort.
+  'CLAUDE_EFFORT',
   // A shared task list is opt-in per dispatch (taskList), never inherited from cck's own env.
   'CLAUDE_CODE_TASK_LIST_ID',
   // A cck started inside tmux passes these on, and claude then lists its session under a tmux pane it is not in.
@@ -252,14 +254,17 @@ function screenText(term) {
 // Claude Code keeps .claude.json beside ~/.claude when CLAUDE_CONFIG_DIR is unset but
 // inside the dir when set, so the default dir must stay unset, not be spelled out.
 // CCK_URL pins the CLI and the doorbell mod to this board: two boards on one config dir share
-// one server.json, and the last one started owns it.
-function ptyEnv({ claudeDir, isDefaultDir, noFlicker, cckUrl }) {
+// one server.json, and the last one started owns it. CCK_TERMINAL_ID names the terminal the
+// show tool posts to.
+function ptyEnv({ claudeDir, isDefaultDir, noFlicker, cckUrl, terminalId }) {
   const env = { ...process.env };
   for (const k of STRIP_ENV) delete env[k];
   if (isDefaultDir) delete env.CLAUDE_CONFIG_DIR;
   else env.CLAUDE_CONFIG_DIR = claudeDir;
   if (cckUrl) env.CCK_URL = cckUrl;
   else delete env.CCK_URL;
+  if (terminalId) env.CCK_TERMINAL_ID = terminalId;
+  else delete env.CCK_TERMINAL_ID;
   // xterm.js #5801: a clear inside a synchronized-output block jumps the viewport.
   if (noFlicker) env.CLAUDE_CODE_NO_FLICKER = '1';
   env.TERM = 'xterm-256color';
@@ -360,6 +365,11 @@ function createTerminalService(o) {
   for (const [id, list] of Object.entries(savedState?.taskLists || {})) {
     if (restoreQueue.includes(id) && typeof list === 'string' && TASK_LIST_RE.test(list)) savedTaskLists[id] = list;
   }
+  // A resumed terminal keeps its id, so its show card keeps its posts.
+  const savedTerminalIds = {};
+  for (const [id, terminalId] of Object.entries(savedState?.terminalIds || {})) {
+    if (restoreQueue.includes(id) && typeof terminalId === 'string' && UUID_RE.test(terminalId)) savedTerminalIds[id] = terminalId;
+  }
 
   // Lazy and optional: a missing prebuilt or shell must hide the feature, not crash cck.
   function load() {
@@ -402,13 +412,22 @@ function createTerminalService(o) {
     saveTimer = null;
     const ids = new Set(restoreQueue);
     const taskLists = {};
-    for (const id of restoreQueue) if (savedTaskLists[id]) taskLists[id] = savedTaskLists[id];
+    const terminalIds = {};
+    for (const id of restoreQueue) {
+      if (savedTaskLists[id]) taskLists[id] = savedTaskLists[id];
+      if (savedTerminalIds[id]) terminalIds[id] = savedTerminalIds[id];
+    }
     for (const s of sessions.values()) {
       if (s.ended || s.claudeExitedAt || !RESTORABLE_MODES.has(s.mode)) continue;
       ids.add(s.id);
       if (s.taskList) taskLists[s.id] = s.taskList;
+      terminalIds[s.id] = s.terminalId;
     }
-    const data = { sessions: [...ids], ...(Object.keys(taskLists).length && { taskLists }) };
+    const data = {
+      sessions: [...ids],
+      ...(Object.keys(taskLists).length && { taskLists }),
+      ...(Object.keys(terminalIds).length && { terminalIds }),
+    };
     const json = JSON.stringify(data);
     if (json === lastSaved) return;
     lastSaved = json;
@@ -556,7 +575,8 @@ function createTerminalService(o) {
 
   function spawnSession(id, mode, cwdCandidate, cols, rows, spec, extraEnv) {
     const cwd = cwdCandidate && fs.existsSync(cwdCandidate) ? cwdCandidate : os.homedir();
-    const env = { ...ptyEnv({ claudeDir: o.claudeDir, isDefaultDir: o.isDefaultDir, noFlicker: config.noFlicker, cckUrl: o.serverUrl?.() }), ...extraEnv };
+    const terminalId = savedTerminalIds[id] || crypto.randomUUID();
+    const env = { ...ptyEnv({ claudeDir: o.claudeDir, isDefaultDir: o.isDefaultDir, noFlicker: config.noFlicker, cckUrl: o.serverUrl?.(), terminalId }), ...extraEnv };
     const taskList = spec?.taskList || savedTaskLists[id] || null;
     if (taskList) env.CLAUDE_CODE_TASK_LIST_ID = taskList;
     // Git Bash's login profile cds to $HOME unless this is set.
@@ -573,7 +593,7 @@ function createTerminalService(o) {
     const serializer = new Serialize();
     term.loadAddon(serializer);
     const s = {
-      id, mode, cwd, pty: proc, term, serializer, sockets: new Set(), exited: false, ended: false, paused: false, startedAt: Date.now(),
+      id, terminalId, mode, cwd, pty: proc, term, serializer, sockets: new Set(), exited: false, ended: false, paused: false, startedAt: Date.now(),
       name: spec?.name || null, worktree: spec?.worktree || false, taskList, onOutput: null, edit: !!spec?.edit,
       forkOf: spec?.forkOf || null,
     };
@@ -782,7 +802,7 @@ function createTerminalService(o) {
 
   function list() {
     return [...sessions.values()].filter((s) => !s.ended).map((s) => ({
-      id: s.id, mode: s.mode, cwd: s.cwd, pid: s.pty.pid, clients: s.sockets.size, startedAt: s.startedAt,
+      id: s.id, terminalId: s.terminalId, mode: s.mode, cwd: s.cwd, pid: s.pty.pid, clients: s.sockets.size, startedAt: s.startedAt,
       name: s.name, worktree: s.worktree, edit: s.edit, forkOf: s.forkOf,
     }));
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "7.5.0",
+  "version": "7.6.1",
   "description": "A web-based Kanban board for viewing Claude Code tasks with agent teams support",
   "main": "server.js",
   "type": "commonjs",

package/plugin/plugins/claude-code-kanban/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "claude-code-kanban",
-  "version": "3.0.1",
+  "version": "3.5.0",
   "description": "claude-code-kanban dashboard integration: agent activity tracking, context and cost tracking, board moves and reviews delivered to the session, and skills to drive the board from a session"
 }

package/plugin/plugins/claude-code-kanban/hooks/doorbell.ts

@@ -37,31 +37,87 @@ async function findBoard($: EngineInterface) {
   }
 }
 
-async function poll($: EngineInterface, url: string, sessionId: string, first: boolean) {
-  const query = `wait=${WAIT_SEC}${first ? '&first=1' : ''}`
+type Line = { text: string; seq?: number }
+
+// A board before acks sends no seqs and drops a line once it answers with it.
+export function parseReply(text: string) {
+  const { events, seqs, board } = JSON.parse(text) as { events?: unknown; seqs?: unknown; board?: unknown }
+  const lines: Line[] = Array.isArray(events)
+    ? events.flatMap((e, i) =>
+        typeof e === 'string'
+          ? [{ text: e, seq: Array.isArray(seqs) && Number.isInteger(seqs[i]) ? (seqs[i] as number) : undefined }]
+          : [],
+      )
+    : []
+  return { lines, board: typeof board === 'string' ? board : '' }
+}
+
+async function poll($: EngineInterface, url: string, sessionId: string, query: string) {
   const r = await $.http.fetch(`${url}/api/sessions/${encodeURIComponent(sessionId)}/events?${query}`)
   if (!r.ok) throw new Error(`HTTP ${r.status}`)
-  const { events } = JSON.parse(r.text) as { events?: unknown }
-  return Array.isArray(events) ? events.filter((e): e is string => typeof e === 'string') : []
+  return parseReply(r.text)
 }
 
+// The board keeps a line until a poll acks it, and the ack goes out only after the submit, so a
+// line the mod never got to the session is sent again. Seqs count per board run: `board` names
+// the run, and the board ignores `got` and `ack` from another one.
+//
 // The session id changes on /clear, so it is read for every poll. The first poll for an id drops
-// what the board queued before this session listened: a move from hours ago is not an instruction.
+// the task moves the board queued before this session listened (a move from hours ago is not an
+// instruction) and names the id it leaves, so the board moves that id's reviews over.
 async function listen($: EngineInterface) {
   let attached: string | undefined
+  let board = ''
+  let got = 0
+  let acked = 0
+  const buffer: Line[] = []
+  let submitting = false
+
+  // A submit waits until the session is idle. The loop keeps polling meanwhile, so the board sees
+  // a live doorbell, and lines that come in wait here to go out as one prompt.
+  const flush = () => {
+    if (submitting || !buffer.length) return
+    const burst = buffer.splice(0)
+    const forBoard = board
+    submitting = true
+    void $.prompt
+      .submit({ text: burst.map(l => l.text).join('\n') })
+      .catch(() => {})
+      .finally(() => {
+        if (forBoard === board) for (const l of burst) if (l.seq !== undefined && l.seq > acked) acked = l.seq
+        submitting = false
+        flush()
+      })
+  }
+
   for (;;) {
     const [url, sessionId] = await Promise.all([findBoard($), $.session.id()])
-    let events: string[] | undefined
+    const first = attached !== sessionId
+    const query = [`wait=${WAIT_SEC}`, `board=${encodeURIComponent(board)}`, `got=${got}`, `ack=${acked}`]
+    if (first) query.push('first=1')
+    if (first && attached) query.push(`prev=${encodeURIComponent(attached)}`)
+    let reply: ReturnType<typeof parseReply> | undefined
     try {
-      if (url) events = await poll($, url, sessionId, attached !== sessionId)
+      if (url) reply = await poll($, url, sessionId, query.join('&'))
     } catch {}
-    if (!events) {
+    if (!reply) {
       await $.clock.sleep(RETRY_MS)
       continue
     }
     attached = sessionId
-    // A submit waits until the session is idle, and one prompt keeps a burst of moves in one turn.
-    if (events.length) await $.prompt.submit({ text: events.join('\n') }).catch(() => {})
+    if (reply.board !== board) {
+      board = reply.board
+      got = 0
+      acked = 0
+    }
+    for (const line of reply.lines) {
+      if (line.seq !== undefined) {
+        if (line.seq <= got) continue
+        got = line.seq
+      }
+      buffer.push(line)
+    }
+    flush()
   }
 }
 

package/plugin/plugins/claude-code-kanban/hooks/index.ts

@@ -2,9 +2,11 @@ import type { Register } from 'claude-code'
 import { register as activity } from './activity'
 import { register as context } from './context'
 import { register as doorbell } from './doorbell'
+import { register as show } from './show'
 
 export const register: Register = (on, options) => {
   context(on, options)
   activity(on, options)
   doorbell(on, options)
+  show(on, options)
 }