claude-code-kanban 6.1.1 → 7.0.0

package/lib/session-cache.js

@@ -4,7 +4,7 @@ const { exportParentVerdicts, importParentVerdicts, parentVerdictsDirty } = requ
 const { exportTaskCounts, importTaskCounts, taskCountsDirty } = require('./task-counts');
 
 // Bump when an entry's shape or meaning changes: a file with another version is ignored.
-const VERSION = 4;
+const VERSION = 5;
 // A cache this large is not one cck wrote for a normal set of transcripts. Rebuild it cold.
 const MAX_BYTES = 8 * 1024 * 1024;
 

package/lib/session-events.js

@@ -3,6 +3,8 @@
 // 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 { oneLine } = require('./one-line');
+
 // Tells a live session that the board moved one of its tasks. The postman monitor
 // (plugin/plugins/claude-code-kanban/scripts/postman.js) drains this queue and prints
 // each line, which Claude Code delivers into that session as a task notification.
@@ -24,10 +26,7 @@ const sessionEventBuckets = new Map();
 //
 // One cap for the whole line rather than one per field, because the description comes
 // last: truncation eats its tail first and leaves the machine-readable head intact.
-function sanitizeEventLine(line) {
-  // biome-ignore lint/suspicious/noControlCharactersInRegex: strips control characters on purpose
-  return line.replace(/[\x00-\x1f\x7f]/g, ' ').trim().slice(0, 1500);
-}
+const sanitizeEventLine = (line) => oneLine(line, 1500);
 
 // 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.

package/lib/terminal.js

@@ -17,6 +17,7 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const { isContained } = require('./contain');
+const { isPidAlive } = require('./live-sessions');
 const priority = require('./priority');
 
 const WS_PATH = '/api/terminal/ws';
@@ -57,6 +58,8 @@ const RESTORE_GAP_MS = 2000;
 const SAVE_DELAY_MS = 1000;
 // A fork runs under its parent's id until claude names the new one, so it has no id to resume.
 const RESTORABLE_MODES = new Set(['resume', 'new']);
+// Quitting claude drops the PTY to its shell, so the PTY's exit cannot tell cck that claude is gone.
+const CLAUDE_EXIT_POLL_MS = 5000;
 // The size of a PTY no browser has attached to yet; the first attach resizes it.
 const HEADLESS_COLS = 120;
 const HEADLESS_ROWS = 32;
@@ -315,6 +318,10 @@ function createTerminalService(o) {
   let lastSaved = null;
   const saveDelayMs = o.saveDelayMs ?? SAVE_DELAY_MS;
   const restoreGapMs = o.restoreGapMs ?? RESTORE_GAP_MS;
+  const exitPollMs = o.exitPollMs ?? CLAUDE_EXIT_POLL_MS;
+  const pidAlive = o.isPidAlive || isPidAlive;
+  const exitTimer = setInterval(checkExits, exitPollMs);
+  exitTimer.unref();
   // Read before any terminal starts, so the first save keeps the ids still waiting to restore.
   const saved = config.restore ? o.load?.()?.sessions : null;
   const restoreQueue = Array.isArray(saved) ? saved.filter((id) => typeof id === 'string' && UUID_RE.test(id)) : [];
@@ -359,7 +366,7 @@ function createTerminalService(o) {
   function saveState() {
     saveTimer = null;
     const ids = new Set(restoreQueue);
-    for (const s of sessions.values()) if (!s.ended && RESTORABLE_MODES.has(s.mode)) ids.add(s.id);
+    for (const s of sessions.values()) if (!s.ended && !s.claudeExitedAt && RESTORABLE_MODES.has(s.mode)) ids.add(s.id);
     const data = { sessions: [...ids] };
     const json = JSON.stringify(data);
     if (json === lastSaved) return;
@@ -435,11 +442,12 @@ function createTerminalService(o) {
   }
 
   // The process a viewer types into: claude, found through its registry entry, or the shell.
-  function inputPid(s) {
+  function inputPid(s, registry) {
     if (s.mode === 'shell') return s.pty.pid;
+    if (s.claudeExitedAt) return null;
     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);
+    const live = registry || o.liveSessions();
+    const own = ownEntry(live, s, s.startedAt);
     if (own || s.mode !== 'fork') {
       s.claudePid = own?.pid;
       return s.claudePid;
@@ -449,6 +457,36 @@ function createTerminalService(o) {
     return s.claudePid;
   }
 
+  // Claude deletes its registry entry on exit, and a crash leaves one with a dead pid. A terminal
+  // with no pid yet is still starting. Matching by pid keeps a /clear or /resume, which rewrite
+  // the entry's sessionId, from reading as an exit.
+  function checkExits() {
+    const watched = [...sessions.values()].filter((s) => !s.exited && !s.ended && s.mode !== 'shell');
+    if (!watched.length) return;
+    const live = o.liveSessions();
+    let moved = false;
+    for (const s of watched) {
+      if (s.claudeExitedAt) {
+        const back = ownEntry(live, s, s.claudeExitedAt);
+        if (!back || !pidAlive(back.pid)) continue;
+        s.claudeExitedAt = null;
+        s.claudePid = back.pid;
+        moved = true;
+        continue;
+      }
+      const pid = inputPid(s, live);
+      if (!pid || (live.some((l) => l.pid === pid) && pidAlive(pid))) continue;
+      s.claudeExitedAt = Date.now();
+      s.claudePid = null;
+      moved = true;
+    }
+    if (moved) changed();
+  }
+
+  function ownEntry(live, s, since) {
+    return live.find((l) => l.pid && l.sessionId === s.id && l.startedAt >= since - PICK_START_SLACK_MS);
+  }
+
   // claude writes its registry entry a moment after it starts, so the pid is polled for.
   function syncBoost(s) {
     const want = s.sockets.size > 0 && !s.exited;
@@ -699,9 +737,10 @@ function createTerminalService(o) {
 
   function claudePids() {
     const out = {};
+    const live = sessions.size ? o.liveSessions() : [];
     for (const s of sessions.values()) {
       if (s.ended || s.exited || s.mode === 'shell') continue;
-      const pid = inputPid(s);
+      const pid = inputPid(s, live);
       if (pid) out[s.id] = pid;
     }
     return out;
@@ -741,7 +780,7 @@ function createTerminalService(o) {
   // 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 (!s || s.ended || s.exited || s.claudeExitedAt || s.onOutput || s.mode === 'shell' || s.mode === 'fork') return false;
     if (onTrustScreen(s)) return false;
     s.pty.write(bracketed(text));
     return true;
@@ -750,6 +789,7 @@ function createTerminalService(o) {
   function shutdown() {
     shuttingDown = true;
     clearTimeout(saveTimer);
+    clearInterval(exitTimer);
     for (const s of sessions.values()) {
       try { s.pty.kill(); } catch { /* already gone */ }
     }

package/lib/worktrees.js

@@ -10,6 +10,11 @@ const { encodeProjectDirName } = require('./claude-dir');
 // main checkout is readable without spawning git. Path shape alone would not do: only some
 // worktrees live under `<repo>/.claude/worktrees/`, the rest sit beside the repo.
 const GITDIR_WORKTREE_RE = /^gitdir:\s*(.*)[/\\]\.git[/\\]worktrees[/\\]([^/\\]+)[/\\]?$/;
+// A submodule's worktree points into the superproject: `<super>/.git/modules/<sub>/worktrees/<name>`,
+// nested as `<a>/modules/<b>`. The checkout is taken to sit at `<super>/<sub>`, which holds while
+// the submodule's name is its path, the git default; reading `core.worktree` would cost a read.
+const GITDIR_SUBMODULE_WORKTREE_RE =
+  /^gitdir:\s*(.*)[/\\]\.git[/\\]modules[/\\](.+?)[/\\]worktrees[/\\]([^/\\]+)[/\\]?$/;
 // Where `claude -w` puts a worktree. Used only once the `.git` file is gone, because Claude
 // Code removes worktrees while their transcripts stay.
 const CLAUDE_WORKTREE_RE = /^(.*)[/\\]\.claude[/\\]worktrees[/\\]([^/\\]+)[/\\]?$/;
@@ -20,9 +25,13 @@ function readGitFile(dir) {
 }
 
 function fromGitFile(dir, text) {
-  const m = GITDIR_WORKTREE_RE.exec(text.trim());
+  const pointer = text.trim();
+  const m = GITDIR_WORKTREE_RE.exec(pointer);
   // Git writes the pointer with forward slashes on Windows; the project path uses the OS spelling.
-  return m ? { repo: path.resolve(dir, m[1]), name: m[2] } : null;
+  if (m) return { repo: path.resolve(dir, m[1]), name: m[2] };
+  const sub = GITDIR_SUBMODULE_WORKTREE_RE.exec(pointer);
+  if (!sub) return null;
+  return { repo: path.resolve(dir, sub[1], ...sub[2].split(/[/\\]modules[/\\]/)), name: sub[3] };
 }
 
 function fromPathShape(dir) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "6.1.1",
+  "version": "7.0.0",
   "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,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "2.23.0",
+  "version": "2.25.1",
   "description": "claude-code-kanban dashboard integration: agent activity tracking, context and cost tracking, skills to drive the board from a session and to follow it",
   "experimental": {
     "monitors": "./monitors.json"

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

@@ -149,13 +149,14 @@ async function markStopped($: EngineInterface) {
 }
 
 // The name map lets TeammateIdle, which names the teammate, find its agent id.
-async function agentStarted($: EngineInterface, agentId: string, type: string, name?: string) {
+async function agentStarted($: EngineInterface, agentId: string, type: string, model: string, name?: string) {
   const dir = await sessionDir($)
   const ts = new Date().toISOString()
   await Promise.all([
     appendLine($, `${dir}/${agentId}.jsonl`, {
       agentId,
       type,
+      model,
       event: 'start',
       status: 'active',
       startedAt: ts,
@@ -248,7 +249,7 @@ export const register: Register = on => {
   })
   on('agent.spawn', async ($, e, next) => {
     const result = await next(e)
-    if (result.agentId) await agentStarted($, result.agentId, e.subagentType, e.name)
+    if (result.agentId) await agentStarted($, result.agentId, e.subagentType, result.model, e.name)
     return result
   })
   // An interrupted turn fires no Stop hook, so it does not mark the session unread either.

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

@@ -42,22 +42,17 @@ function cckDir($: EngineInterface) {
   return cck
 }
 
-let lastUsage: ModelUsage | undefined
-let lastModel: string | undefined
-let lastRequestAt: number | undefined
-const lastWritten = new Map<string, string>()
+// Keyed by session id: `/clear` keeps the process and changes the id.
+const sessions = new Map<string, { req?: { usage: ModelUsage; model: string; at: number }; written?: string }>()
 
-async function write($: EngineInterface, m: Measure) {
-  const [sessionId, model, dir] = await Promise.all([
-    $.session.id(),
-    lastModel ?? $.session.model(),
-    cckDir($),
-  ])
-  const text = JSON.stringify(toStatus(model, m, lastUsage, lastRequestAt))
-  const file = `${dir}/context-status/${sessionId}.json`
-  if (lastWritten.get(file) === text) return
-  await $.fs.write(file, text)
-  lastWritten.set(file, text)
+async function write($: EngineInterface, m: Measure, id?: string) {
+  const [sessionId, dir] = await Promise.all([id ?? $.session.id(), cckDir($)])
+  const s = sessions.get(sessionId) ?? {}
+  const model = s.req?.model ?? (await $.session.model())
+  const text = JSON.stringify(toStatus(model, m, s.req?.usage, s.req?.at))
+  if (s.written === text) return
+  await $.fs.write(`${dir}/context-status/${sessionId}.json`, text)
+  sessions.set(sessionId, { ...s, written: text })
 }
 
 export const register: Register = on => {
@@ -65,10 +60,9 @@ export const register: Register = on => {
     const result = yield* next(e)
     if (e.agentId === undefined && result.usage) {
       const { model, ...usage } = result.usage
-      lastUsage = usage
-      lastModel = model
-      lastRequestAt = Date.now()
-      await write($, await $.session.usage())
+      const sessionId = await $.session.id()
+      sessions.set(sessionId, { ...sessions.get(sessionId), req: { usage, model, at: Date.now() } })
+      await write($, await $.session.usage(), sessionId)
     }
     return result
   })
@@ -77,4 +71,9 @@ export const register: Register = on => {
     await write($, e)
     return next(e)
   })
+
+  on('session.end', async ($, e, next) => {
+    sessions.delete(e.sessionId)
+    return next(e)
+  })
 }

package/plugin/plugins/claude-code-kanban/skills/kanban/SKILL.md

@@ -1,35 +1,45 @@
 ---
 name: kanban
-description: Drive the kanban board — open, pin, preview, link, inspect.
-argument-hint: '[open|pin|unpin|preview|link] [target]'
+description: Kanban board CLI — show the user a file or page, link a doc or PR, add a pane, open or pin a session, find a session's transcript, list tasks.
+argument-hint: '[doc|pane|session|task|project|dispatch] <subcommand> [target]'
 ---
 
 # Kanban Skill
 
-This session id is `${CLAUDE_SESSION_ID}`, substituted when the skill loads.
+The skill is a thin wrapper over the `claude-code-kanban` CLI: the argument is a command and its subcommand, such as `doc link plan.md` or `session pin`. Run the bare binary, or `npx claude-code-kanban` when it is off PATH or the user asks for npx.
 
-An argument names the command that handles it; with no argument, open the current session. Prefer the bare `claude-code-kanban` binary, falling back to `npx claude-code-kanban` when it is off PATH or the user asks for npx.
+This session id is `${CLAUDE_SESSION_ID}`. `--session` defaults to it through `$CLAUDE_CODE_SESSION_ID`, so pass the flag only for another session.
 
-The CLI help is the reference, and it always matches the installed binary. Read it before you run a command, instead of guessing flags:
+## Commands
 
-```bash
-claude-code-kanban help                        # every command
-claude-code-kanban help <command>              # its subcommands
-claude-code-kanban help <command> <subcommand> # flags and examples
-```
-
-| Argument | Command |
+| Command | Subcommands |
 |---|---|
-| `open` (or none) | `session open ${CLAUDE_SESSION_ID}` |
-| `pin` / `unpin` | `session pin ${CLAUDE_SESSION_ID}` (`--sticky`, `--unpin`) |
-| `preview` | `preview-doc <file> --session ${CLAUDE_SESSION_ID}` — opens a modal on the user's screen |
-| `link` | `link-doc <file\|url> --session ${CLAUDE_SESSION_ID}` — no modal, so it is the safe choice while the user is working. An http(s) URL (a PR, an artifact) opens in a new tab |
-| `list` / `search` | `session list`, `session search <text>` |
-| `view` / `peek` | `session view <id>`, `session peek <id>` |
-| tasks, projects | `task list`, `project list` |
+| `doc` | `link`, `unlink` a file or URL to the session · `list` its links · `preview` a file in a modal |
+| `pane` | `add` a URL or a local file as a background tab · `rm` · `list` |
+| `session` | `list` · `search <text>` · `open <id>` focuses it · `view <id>` stats and transcript path · `plan <id>` · `agents <id>` · `pin <id>` |
+| `task` | `list` for a session, a project or the whole board |
+| `project` | `list` |
+| `dispatch` | `start`, `list` — run `/claude-code-kanban:dispatch` instead |
+
+## Run a command
+
+1. Read `claude-code-kanban help <command> <subcommand>` for the flags. It matches the installed binary, so its flags are the ones that work.
+2. Run the command and report its output line to the user.
+
+With no argument, run nothing on the board: show the user the table above.
+
+## Keep the board still
+
+The user works in other windows while you run, so pick the quiet command. `doc link` and `pane add` add an entry the user opens when ready. `doc preview` is the one command that opens a modal on the user's screen: use it when the user asks to see something now.
+
+To show the user a page, a prototype or a collage of screenshots, write it as HTML and link or preview that file. The preview renders HTML as authored in a sandboxed iframe and inlines its local stylesheets, scripts and images, so the file alone is enough.
+
+## Another session
+
+Read its transcript. `session view <id>` and `session search <text> --json` print the path.
 
-To be driven *by* the board instead — card moves arriving as instructions — the user types `/claude-code-kanban:follow`.
+To have card moves arrive in this session as instructions, the user types `/claude-code-kanban:follow`.
 
 ## Troubleshooting
 
-- **"Cannot reach cck server…"** → the error names the config dir and the port it tried. Ask the user to start the server with `claude-code-kanban`. If they run it elsewhere, set `PORT=<n>` or `CCK_URL=<url>` when invoking the CLI.
+- **"Cannot reach cck server…"** → the error names the config dir and the port it tried. Ask the user to start the server with `claude-code-kanban`. If it runs elsewhere, set `PORT=<n>` or `CCK_URL=<url>` when invoking the CLI.

package/plugin/plugins/claude-code-kanban/tests/activity.test.ts

@@ -253,7 +253,7 @@ test('a subagent spawn then finish records start and stop', async ($, on) => {
   await $.turn.complete(turn({ agentId: 'a1', answer: 'Task done with "quotes"' }))
 
   const [start, stop] = lines(files[`${SESSION}/a1.jsonl`])
-  expect(start).toMatchObject({ agentId: 'a1', type: 'general-purpose', event: 'start', status: 'active' })
+  expect(start).toMatchObject({ agentId: 'a1', type: 'general-purpose', model: 'haiku', event: 'start', status: 'active' })
   expect(stop).toMatchObject({ agentId: 'a1', event: 'stop', status: 'stopped', lastMessage: 'Task done with "quotes"' })
   expect('type' in stop).toBe(false)
   expect(files[`${SESSION}/_name-general-purpose.id`]).toBe('a1')

package/plugin/plugins/claude-code-kanban/tests/context.test.ts

@@ -12,14 +12,14 @@ const MEASURE: SessionMeasureInput = {
   changed: ['context', 'rateLimits', 'cost'],
 }
 
-function engine(on: On, env: Record<string, string>, sessionId: string) {
+function engine(on: On, env: Record<string, string>, sessionId: string | (() => string)) {
   const writes: { path: string; text: string }[] = []
   on('fs.write', (_$, e) => {
     writes.push({ path: e.path.replaceAll('\\', '/'), text: e.text })
     return { value: undefined }
   })
   on('env.get', (_$, e) => ({ value: env[e.name] }))
-  on('session.id', () => ({ value: sessionId }))
+  on('session.id', () => ({ value: typeof sessionId === 'function' ? sessionId() : sessionId }))
   on('session.model', () => ({ value: 'claude-opus-5-5' }))
   on('session.measure', (_$, e) => ({ changed: [...e.changed] }))
   return writes
@@ -53,6 +53,37 @@ test('session.measure writes no cache entry before the first request', async ($,
   expect(JSON.parse(writes[0]?.text ?? '{}').cache).toBeUndefined()
 })
 
+const USAGE = { input_tokens: 2, output_tokens: 100, cache_read_input_tokens: 5000, cache_creation_input_tokens: 300 }
+
+test('after /clear the new session id does not get the old request', async ($, on) => {
+  let sid = 'sid-old'
+  const writes = engine(on, { CLAUDE_CONFIG_DIR: 'C:/cfg' }, () => sid)
+  on('session.usage', () => ({ value: MEASURE }))
+  on('session.end', (_$, e) => ({ sessionId: e.sessionId }))
+  on('turn.step', async function* (_$, e) {
+    return { turnId: e.turnId, index: e.index, answer: 'ok', toolUses: [], stopReason: 'end_turn', usage: { ...USAGE, model: 'claude-fable-5-1' } }
+  })
+
+  const step = $.turn.step({ turnId: 't1', index: 0, model: 'claude-fable-5-1', messageCount: 1 })
+  for await (const _ of step);
+  await step.result
+  expect(writes.length).toBe(1)
+  const old = JSON.parse(writes.at(-1)?.text ?? '{}')
+  expect(old.cache?.last_request_at).toBeGreaterThan(0)
+  expect(old.context_window.current_usage).toEqual(USAGE)
+  expect(old.model.id).toBe('claude-fable-5-1')
+
+  await $.session.end({ reason: 'clear', sessionId: 'sid-old', resume: {} as never })
+  sid = 'sid-new'
+  await $.session.measure(MEASURE)
+
+  expect(writes.at(-1)?.path).toBe('C:/cfg/.cck/context-status/sid-new.json')
+  const fresh = JSON.parse(writes.at(-1)?.text ?? '{}')
+  expect(fresh.cache).toBeUndefined()
+  expect(fresh.context_window.current_usage).toBeNull()
+  expect(fresh.model.id).toBe('claude-opus-5-5')
+})
+
 test('toStatus adds the last request time', async () => {
   const status = toStatus('claude-opus-5-5', MEASURE, undefined, 1_790_000_000_000)
   expect(status.cache).toEqual({ last_request_at: 1_790_000_000_000 })