claude-code-kanban 7.5.0 → 7.6.0

package/hub-app.json

@@ -6,6 +6,11 @@
   "run": { "entry": "server.js", "defaultPort": 3541 },
   "publishes": ["session.changed"],
   "keys": { "keeps": ["ctrl+alt+n", "ctrl+alt+r", "ctrl+alt+s"] },
+  "plugin": {
+    "id": "claude-code-kanban@claude-code-kanban",
+    "path": "plugin/plugins/claude-code-kanban",
+    "install": "claude-code-kanban --install --yes"
+  },
   "provides": {
     "projects": { "path": "/api/projects" },
     "terminal": { "liveWork": "/api/terminals" }

package/lib/panes.js

@@ -124,7 +124,8 @@ function createPaneStore({ load, save, onChange = () => {}, now = Date.now }) {
   }
 
   // The same target added again returns its pane where it is, so a repeated `pane add` is harmless.
-  function add(sessionId, { kind, target, title }) {
+  // `show` marks a show card's file, which the board renders with the card's theme.
+  function add(sessionId, { kind, target, title, show }) {
     if (!KINDS.has(kind)) throw httpError(400, `Unknown pane kind: ${kind}`, 'bad_kind');
     if (kind === 'message' && target.length > MAX_MESSAGE_TARGET) {
       throw httpError(400, `A message target holds at most ${MAX_MESSAGE_TARGET} characters`, 'bad_target');
@@ -140,6 +141,7 @@ function createPaneStore({ load, save, onChange = () => {}, now = Date.now }) {
       kind,
       target,
       title: paneTitle(kind, target, title),
+      ...(show && { show: true }),
       addedAt: now(),
     };
     layout.panes.push(pane);
@@ -157,6 +159,18 @@ function createPaneStore({ load, save, onChange = () => {}, now = Date.now }) {
     return write(sessionId, layout);
   }
 
+  // Drops the show panes of these files; returns the new layout, or null when none matched.
+  function removeShow(sessionId, files) {
+    reload();
+    const layout = bySession.get(sessionId);
+    if (!layout) return null;
+    const keys = new Set(files.map((f) => targetKey('html', f)));
+    const kept = layout.panes.filter((p) => !(p.show && keys.has(targetKey(p.kind, p.target))));
+    if (kept.length === layout.panes.length) return null;
+    layout.panes = kept;
+    return write(sessionId, layout);
+  }
+
   // An empty title gives the pane its default title back. Returns null when the session has no such pane.
   function rename(sessionId, paneId, title) {
     reload();
@@ -197,7 +211,7 @@ function createPaneStore({ load, save, onChange = () => {}, now = Date.now }) {
     return out;
   }
 
-  return { get, add, remove, rename, reorder, prune, reload, fileTargets };
+  return { get, add, remove, removeShow, rename, reorder, prune, reload, fileTargets };
 }
 
 module.exports = { createPaneStore, isOwnOrigin, portOf, MAX_PANES, MAX_TITLE };

package/lib/parsers.js

@@ -1634,7 +1634,7 @@ async function readCompactSummaries(jsonlPath) {
         if (!text) continue;
         // Strip the "This session is being continued..." preamble if present.
         text = text.replace(/^This session is being continued[^\n]*\n+(The summary below[^\n]*\n+)?/i, '').trim();
-        if (text) results.push({ timestamp: obj.timestamp, summary: text });
+        if (text) results.push({ timestamp: obj.timestamp, summary: text, source: 'inline' });
       } catch (_) {}
     }
   } catch (_) {}
@@ -1665,7 +1665,7 @@ async function readCompactSummaries(jsonlPath) {
           for (const b of blocks) {
             if (b.type !== 'text' || !b.text) continue;
             const match = b.text.match(/<summary>([\s\S]*?)(?:<\/summary>|$)/);
-            if (match) { results.push({ timestamp: lastTs, summary: match[1].trim() }); found = true; break; }
+            if (match) { results.push({ timestamp: lastTs, summary: match[1].trim(), source: 'subagent' }); found = true; break; }
           }
           if (found) break;
         } catch (_) {}
@@ -1675,6 +1675,30 @@ async function readCompactSummaries(jsonlPath) {
   return results.sort((a, b) => (a.timestamp || '').localeCompare(b.timestamp || ''));
 }
 
+// A subagent summary's timestamp is the compact agent's last record, written just
+// before the parent's isCompactSummary record; compactions are minutes apart.
+const COMPACT_SUMMARY_MATCH_MS = 2 * 60 * 1000;
+
+function fillCompactSummaries(chips, summaries) {
+  const candidates = summaries.filter(s => s.source === 'subagent' && s.timestamp);
+  const used = new Set();
+  for (const chip of chips) {
+    if (chip.compactSummary || !chip.timestamp) continue;
+    const at = Date.parse(chip.timestamp);
+    let best = null;
+    let bestGap = COMPACT_SUMMARY_MATCH_MS;
+    for (const s of candidates) {
+      if (used.has(s)) continue;
+      const gap = Math.abs(Date.parse(s.timestamp) - at);
+      if (gap <= bestGap) { best = s; bestGap = gap; }
+    }
+    if (best) {
+      used.add(best);
+      chip.compactSummary = best.summary;
+    }
+  }
+}
+
 async function findTerminatedTeammates(jsonlPath) {
   return (await buildSessionDigest(jsonlPath)).terminated;
 }
@@ -2028,6 +2052,7 @@ module.exports = {
   buildAgentProgressMap,
   buildSessionDigest,
   readCompactSummaries,
+  fillCompactSummaries,
   readArtifactLinks,
   readScratchpadCreations,
   findTerminatedTeammates,

package/lib/retention.js

@@ -38,11 +38,24 @@ function pruneMap(map, atOf, { known, maxAgeMs, now }) {
   return removed;
 }
 
+const textOrNull = (v) => (typeof v === 'string' && v ? v : null);
+
+function dispatchedEntry(e) {
+  return {
+    parent: textOrNull(e.parent),
+    at: e.at,
+    name: textOrNull(e.name),
+    group: textOrNull(e.group),
+    cwd: textOrNull(e.cwd),
+    worktree: e.worktree === true ? true : textOrNull(e.worktree),
+  };
+}
+
 /**
  * Sessions started through `dispatch start`, kept after their terminal ends so the card
- * keeps its marker.
+ * keeps its marker, and across a restart so `dispatch list` finds a session cck resumes.
  * @param {object} o
- * @param {() => object|null} o.load returns `{version: 1, sessions: {[id]: {parent, at}}}` or null
+ * @param {() => object|null} o.load returns `{version: 1, sessions: {[id]: {parent, at, name, group, cwd, worktree}}}` or null
  * @param {(data: object) => void} o.save
  */
 function createDispatchedStore({ load, save, now = Date.now }) {
@@ -52,15 +65,15 @@ function createDispatchedStore({ load, save, now = Date.now }) {
   if (saved && typeof saved === 'object') {
     for (const [id, e] of Object.entries(saved)) {
       if (!e || !Number.isFinite(e.at)) continue;
-      entries.set(id, { parent: typeof e.parent === 'string' ? e.parent : null, at: e.at });
+      entries.set(id, dispatchedEntry(e));
     }
   }
 
   const persist = () => save({ version: 1, sessions: Object.fromEntries(entries) });
 
-  function record(id, parent) {
+  function record(id, info = {}) {
     entries.delete(id);
-    entries.set(id, { parent: parent || null, at: now() });
+    entries.set(id, dispatchedEntry({ ...info, at: now() }));
     if (entries.size > MAX_DISPATCHED) entries.delete(entries.keys().next().value);
     persist();
   }
@@ -72,7 +85,17 @@ function createDispatchedStore({ load, save, now = Date.now }) {
     return removed;
   }
 
-  return { record, prune, get: (id) => entries.get(id) || null, entries: () => entries.entries() };
+  // Derived, not kept: cck resumes every terminal on restart, and a list kept in memory
+  // would lose those sessions.
+  function running(isRunning, { parent } = {}) {
+    const out = [];
+    for (const [session, { at, ...m }] of entries) {
+      if (isRunning(session) && (!parent || m.parent === parent)) out.push({ session, ...m, startedAt: at });
+    }
+    return out;
+  }
+
+  return { record, prune, running, get: (id) => entries.get(id) || null, entries: () => entries.entries() };
 }
 
 // Names only, no stat or parse: the sweep needs which transcripts exist, not what they hold.

package/lib/session-events.js

@@ -3,6 +3,7 @@
 // bucket-map invariants here are the difference between a bounded queue and a map that
 // grows one permanent entry per session id ever named in a request path.
 
+const crypto = require('node:crypto');
 const { oneLine } = require('./one-line');
 
 // Tells a live session that the board moved one of its tasks. The plugin's doorbell mod
@@ -14,6 +15,11 @@ const { oneLine } = require('./one-line');
 // disk queue would buy nothing. Reading consumes, so a restarted session never replays
 // a backlog and acts on the same move twice.
 //
+// A mod that acks changes when a line leaves: on its ack, not on the read. A line with a
+// `marker` (a review) is the durable exception. Its comments exist nowhere else the agent
+// reads, so it survives the first-attach drop and /clear, and server.js keeps the marker
+// file until the ack, which `restore` reads back after a board restart.
+//
 // A bucket exists only while it holds something: an undelivered line or a waiting
 // poller. Without that, the map would grow one permanent entry per session id ever
 // asked for -- and the id comes straight off the request path.
@@ -32,14 +38,12 @@ const sanitizeEventLine = (line) => oneLine(line, 1500);
 // marks the board as the sender.
 const EVENT_PREFIX = '[kanban board]';
 
-function moveMeaning(from, to) {
-  if (to === 'in_progress') {
-    return 'Start this task now, and set it to completed with TaskUpdate when the work is done.';
-  }
-  if (from === 'in_progress' && to === 'pending') return 'Stop working on it and park it.';
-  if (to === 'completed') return 'The user considers it done: do not keep working on it.';
-  if (to === 'cancelled') return 'Abandon it. Undo nothing unless asked.';
-  return '';
+function moveCommand(from, to, ref) {
+  if (to === 'in_progress') return `Start task ${ref} now. Mark it completed when done.`;
+  if (from === 'in_progress' && to === 'pending') return `Stop work on task ${ref} and leave it for later.`;
+  if (to === 'completed') return `Stop work on task ${ref}: it is done.`;
+  if (to === 'cancelled') return `Drop task ${ref}. Keep the changes made so far.`;
+  return `Task ${ref} is now ${to}.`;
 }
 
 // Everything after `Description:` is the description verbatim to end of line, so no amount
@@ -47,9 +51,7 @@ function moveMeaning(from, to) {
 // value that needs delimiting.
 function formatTaskMoved(taskId, prevStatus, task) {
   const subject = String(task.subject || '').replace(/(["\\])/g, '\\$1');
-  const from = prevStatus ? ` from ${prevStatus}` : '';
-  const meaning = moveMeaning(prevStatus, task.status);
-  const head = `${EVENT_PREFIX} The user moved task ${taskId} "${subject}"${from} to ${task.status}.${meaning ? ` ${meaning}` : ''}`;
+  const head = `${EVENT_PREFIX} ${moveCommand(prevStatus, task.status, `${taskId} "${subject}"`)}`;
   return task.description ? `${head} Description: ${task.description}` : head;
 }
 
@@ -63,30 +65,98 @@ function boardEventsOn(cfg) {
 // 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}`;
+  return `${EVENT_PREFIX} Address ${comments} on ${label}: ${reviewFile}`;
 }
 
-// A doorbell 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;
+// Names this board run in every reply, so a mod drops `got` and `ack` counted against a run
+// that has since restarted.
+const BOARD_RUN = crypto.randomBytes(6).toString('hex');
+let lastSeq = 0;
+
+// Ids come off request paths, so both maps are capped; the oldest entry goes first.
+const MAX_IDS = 500;
+const doorbells = new Map();
+const aliases = new Map();
+
+function remember(map, key, value) {
+  map.delete(key);
+  map.set(key, value);
+  if (map.size > MAX_IDS) map.delete(map.keys().next().value);
 }
 
-function enqueueSessionEvent(sessionId, line) {
-  const text = sanitizeEventLine(line);
-  if (!sessionId || !text) return;
-  let bucket = sessionEventBuckets.get(sessionId);
+// Set by server.js: `onDelivered(entry)` runs once a review line is acked (or drained by a
+// mod without acks); `restore(sessionId)` returns the review lines still pending on disk.
+const hooks = { onDelivered: null, restore: null };
+
+function configureSessionEvents(opts) {
+  Object.assign(hooks, opts);
+}
+
+// After /clear the mod polls under a new id, and the board may still send to the old one.
+// `adopt` keeps each alias pointing at the newest id, so one lookup is enough.
+function resolveSessionId(sessionId) {
+  return aliases.get(sessionId) ?? sessionId;
+}
+
+function bucketFor(key) {
+  let bucket = sessionEventBuckets.get(key);
   if (!bucket) {
     bucket = { queue: [], waiters: new Set() };
-    sessionEventBuckets.set(sessionId, bucket);
+    sessionEventBuckets.set(key, bucket);
   }
-  bucket.queue.push(text);
+  return bucket;
+}
+
+function partition(list, pred) {
+  const yes = [];
+  const no = [];
+  for (const e of list) (pred(e) ? yes : no).push(e);
+  return [yes, no];
+}
+
+// True once this session's doorbell has polled during this board run. A review then always
+// goes into the queue: the mod takes it on its next poll, so a busy turn only delays it.
+function hasDoorbell(sessionId) {
+  return doorbells.has(resolveSessionId(sessionId));
+}
+
+function enqueueSessionEvent(sessionId, line, { marker } = {}) {
+  const text = sanitizeEventLine(line);
+  if (!sessionId || !text) return;
+  const bucket = bucketFor(resolveSessionId(sessionId));
+  bucket.queue.push({ seq: ++lastSeq, text, marker });
   // A session with no doorbell attached must not grow without bound.
   if (bucket.queue.length > 50) bucket.queue.splice(0, bucket.queue.length - 50);
   for (const wake of [...bucket.waiters]) wake();
 }
 
+function delivered(entries) {
+  for (const e of entries) if (e.marker) hooks.onDelivered?.(e);
+}
+
+function adopt(prev, sessionId) {
+  if (!prev || prev === sessionId) return;
+  for (const [from, to] of aliases) if (to === prev) aliases.set(from, sessionId);
+  remember(aliases, prev, sessionId);
+  const old = sessionEventBuckets.get(prev);
+  if (!old) return;
+  const [durable, rest] = partition(old.queue, (e) => e.marker);
+  old.queue = rest;
+  evictIfEmpty(prev, old);
+  if (!durable.length) return;
+  const bucket = bucketFor(sessionId);
+  bucket.queue.push(...durable);
+  bucket.queue.sort((a, b) => a.seq - b.seq);
+}
+
+async function restorePending(sessionId) {
+  const lines = await hooks.restore(sessionId).catch(() => []);
+  const queued = new Set(sessionEventBuckets.get(sessionId)?.queue.map((e) => e.marker));
+  for (const { text, marker } of lines) {
+    if (!queued.has(marker)) enqueueSessionEvent(sessionId, text, { marker });
+  }
+}
+
 const MAX_WAIT_SEC = 120;
 const TOPIC_RE = /^[a-z]+$/;
 
@@ -100,46 +170,87 @@ function topicKey(topic, sessionId) {
   return topic ? `${topic}:${sessionId}` : sessionId;
 }
 
+function seqParam(value) {
+  const n = Number(value);
+  return Number.isSafeInteger(n) && n > 0 ? n : 0;
+}
+
 // Long-poll drained by the doorbell mod. Routing stays in server.js; this is the handler.
-function handleSessionEvents(req, res) {
+//
+// A mod that acks sends `got` (the last seq it took) and `ack` (the last seq it submitted to
+// the session). The board answers only lines past `got` and keeps each line until its ack, so
+// a reply lost on the way, or a mod that dies before its submit, gets the line again. A mod
+// before acks sends neither, and a line is gone once a reply carries it.
+async function handleSessionEvents(req, res) {
   const topic = req.query.topic;
   if (topic !== undefined && !(typeof topic === 'string' && TOPIC_RE.test(topic))) {
     return res.status(400).json({ error: 'invalid topic' });
   }
   const sessionId = topicKey(topic, req.params.sessionId);
-  const bucket = sessionEventBuckets.get(sessionId);
   const wait = clampWait(req.query.wait);
+  const acks = req.query.got !== undefined;
+  const trusted = acks && req.query.board === BOARD_RUN;
+  const got = trusted ? seqParam(req.query.got) : 0;
+  const ack = trusted ? seqParam(req.query.ack) : 0;
+
+  if (!topic) {
+    aliases.delete(sessionId);
+    const known = doorbells.has(sessionId);
+    remember(doorbells, sessionId, true);
+    if (req.query.first === '1' && typeof req.query.prev === 'string') adopt(req.query.prev, sessionId);
+    if (!known && hooks.restore) await restorePending(sessionId);
+  }
+
+  const bucket = sessionEventBuckets.get(sessionId);
+  if (bucket && ack) {
+    const [done, rest] = partition(bucket.queue, (e) => e.seq <= ack);
+    bucket.queue = rest;
+    delivered(done);
+  }
 
   // A doorbell can attach long after the board moved something (a resumed session, a board
   // that came up later). Those lines are read as instructions, and an hours-old instruction
-  // is worse than no instruction, so `first=1` drops the whole backlog. drain() (not a bare
-  // truncate) so an emptied bucket is still evicted from the map.
-  if (bucket && req.query.first === '1') drain(sessionId, bucket);
+  // is worse than no instruction, so `first=1` drops the backlog of moves, and an emptied
+  // bucket is still evicted from the map. Reviews are kept: the review file says what to
+  // address however late it arrives.
+  if (bucket && req.query.first === '1') bucket.queue = bucket.queue.filter((e) => e.marker);
+
+  const take = (b) => {
+    if (acks) return b.queue.filter((e) => e.seq > got);
+    const all = b.queue.splice(0);
+    delivered(all);
+    return all;
+  };
+  const reply = (entries) => ({ events: entries.map((e) => e.text), seqs: entries.map((e) => e.seq), board: BOARD_RUN });
 
-  if (bucket?.queue.length) return res.json({ events: drain(sessionId, bucket) });
-  if (!wait) return res.json({ events: [] });
+  const ready = bucket ? take(bucket) : [];
+  if (bucket) evictIfEmpty(sessionId, bucket);
+  if (ready.length) return res.json(reply(ready));
+  if (!wait) return res.json(reply([]));
 
-  const pending = bucket || { queue: [], waiters: new Set() };
-  sessionEventBuckets.set(sessionId, pending);
+  const pending = bucketFor(sessionId);
 
-  const send = () => {
+  // A closed request has nobody to read the answer, so its lines stay queued.
+  const send = (closed) => {
     // Set.delete is the whole idempotency story: whichever of enqueue, timeout, or
     // client disconnect gets here first is the one that answers.
     if (!pending.waiters.delete(send)) return;
     clearTimeout(timer);
-    req.removeListener('close', send);
-    const events = drain(sessionId, pending);
-    if (!res.writableEnded) res.json({ events });
+    req.removeListener('close', onClose);
+    const entries = closed === true || res.writableEnded ? [] : take(pending);
+    evictIfEmpty(sessionId, pending);
+    if (!res.writableEnded) res.json(reply(entries));
   };
+  const onClose = () => send(true);
   const timer = setTimeout(send, wait * 1000);
   pending.waiters.add(send);
-  req.on('close', send);
+  req.on('close', onClose);
 }
 
-function drain(sessionId, bucket) {
-  const events = bucket.queue.splice(0);
-  if (!bucket.queue.length && !bucket.waiters.size) sessionEventBuckets.delete(sessionId);
-  return events;
+function evictIfEmpty(sessionId, bucket) {
+  if (!bucket.queue.length && !bucket.waiters.size && sessionEventBuckets.get(sessionId) === bucket) {
+    sessionEventBuckets.delete(sessionId);
+  }
 }
 
 module.exports = {
@@ -149,7 +260,8 @@ module.exports = {
   formatTaskMoved,
   boardEventsOn,
   formatReviewSubmitted,
-  hasSessionListener,
+  hasDoorbell,
+  configureSessionEvents,
   enqueueSessionEvent,
   handleSessionEvents,
   topicKey,