claude-code-kanban 6.1.2 → 7.0.1

package/lib/panes.js

@@ -0,0 +1,174 @@
+// Per-session pane layout: the tabs next to Board. The file is the only copy, shared by every
+// board process on the config dir, the CLI and the agent. Which tab is on screen is each
+// browser tab's own state, not stored here. Expiry: docs/retention.md.
+
+const path = require('node:path');
+const { httpError } = require('./http-error');
+const { canonicalPath } = require('./linked-docs');
+const { isLoopbackAddress } = require('./net-guard');
+const { oneLine } = require('./one-line');
+const { pruneMap } = require('./retention');
+
+const MAX_PANES = 50;
+const MAX_TITLE = 100;
+const KINDS = new Set(['url', 'html', 'markdown', 'text', 'image']);
+
+const portOf = (u) => Number(u.port || (u.protocol === 'https:' ? 443 : 80));
+
+// A frame with allow-scripts plus allow-same-origin on the board's origin or the hub's can reach
+// into its parent and drop its own sandbox. Every name either one is served under counts.
+function isOwnOrigin(url, { boardPort, boardHosts = [], hubUrl }) {
+  let u;
+  try {
+    u = new URL(url);
+  } catch {
+    return false;
+  }
+  const port = portOf(u);
+  const loopback = isLoopbackAddress(u.hostname);
+  if (u.protocol === 'http:' && port === boardPort && (loopback || boardHosts.includes(u.hostname))) return true;
+  let hub;
+  try {
+    hub = new URL(hubUrl);
+  } catch {
+    return false;
+  }
+  const hubHost = u.hostname === hub.hostname || (loopback && isLoopbackAddress(hub.hostname));
+  return u.protocol === hub.protocol && port === portOf(hub) && hubHost;
+}
+
+const emptyLayout = () => ({ rev: 0, nextId: 1, panes: [], updatedAt: null });
+
+const targetKey = (kind, target) => (kind === 'url' ? `url:${target}` : `file:${canonicalPath(target)}`);
+
+function defaultTitle(kind, target) {
+  if (kind !== 'url') return path.basename(target);
+  try {
+    return new URL(target).host;
+  } catch {
+    return target;
+  }
+}
+
+const idNumber = (id) => Number(id.slice(1)) || 0;
+
+function cleanLayout(raw) {
+  if (!raw || !Array.isArray(raw.panes) || !Number.isFinite(raw.updatedAt)) return null;
+  const ids = new Set();
+  const panes = raw.panes.filter((p) => {
+    const ok = p && typeof p.id === 'string' && !ids.has(p.id) && KINDS.has(p.kind) && typeof p.target === 'string' && p.target;
+    if (ok) ids.add(p.id);
+    return ok;
+  });
+  const nextId = Math.max(Number.isInteger(raw.nextId) ? raw.nextId : 1, ...panes.map((p) => idNumber(p.id) + 1));
+  const rev = Number.isInteger(raw.rev) && raw.rev > 0 ? raw.rev : 1;
+  return { rev, nextId, panes: panes.slice(0, MAX_PANES), updatedAt: raw.updatedAt };
+}
+
+const publicLayout = (l) => ({ rev: l.rev, panes: l.panes.map((p) => ({ ...p })), updatedAt: l.updatedAt });
+
+/**
+ * Every write re-reads the file first, so two boards on one config dir add to each other's
+ * layouts instead of overwriting them. The read-to-rename window is left open: both writers
+ * are one user's own board tabs and CLI calls.
+ *
+ * @param {object} o
+ * @param {() => object|null|undefined} o.load returns `{version: 2, sessions: {[id]: {rev, nextId, panes, updatedAt}}}`,
+ *   null when there is no file, or undefined when the file has not changed since the last load or save
+ * @param {(data: object) => void} o.save
+ * @param {(sessionId: string, layout: object) => void} [o.onChange] called for each layout whose rev
+ *   moved, from this store's writes and from `reload()` alike
+ */
+function createPaneStore({ load, save, onChange = () => {}, now = Date.now }) {
+  let bySession = new Map();
+
+  function reload() {
+    const data = load();
+    if (data === undefined) return;
+    const next = new Map();
+    const saved = data?.sessions;
+    if (saved && typeof saved === 'object') {
+      for (const [id, raw] of Object.entries(saved)) {
+        const layout = cleanLayout(raw);
+        if (layout) next.set(id, layout);
+      }
+    }
+    const before = bySession;
+    bySession = next;
+    for (const [id, layout] of next) {
+      if (before.get(id)?.rev !== layout.rev) onChange(id, publicLayout(layout));
+    }
+  }
+  reload();
+
+  const persist = () => save({ version: 2, sessions: Object.fromEntries(bySession) });
+
+  function write(sessionId, layout) {
+    layout.rev += 1;
+    layout.updatedAt = now();
+    bySession.set(sessionId, layout);
+    persist();
+    onChange(sessionId, publicLayout(layout));
+    return publicLayout(layout);
+  }
+
+  function get(sessionId) {
+    const layout = bySession.get(sessionId);
+    return publicLayout(layout || emptyLayout());
+  }
+
+  // The same target added again returns its pane where it is, so a repeated `pane add` is harmless.
+  function add(sessionId, { kind, target, title }) {
+    if (!KINDS.has(kind)) throw httpError(400, `Unknown pane kind: ${kind}`, 'bad_kind');
+    reload();
+    const layout = bySession.get(sessionId) || emptyLayout();
+    const key = targetKey(kind, target);
+    const existing = layout.panes.find((p) => targetKey(p.kind, p.target) === key);
+    if (existing) return { pane: { ...existing }, added: false, layout: publicLayout(layout) };
+    if (layout.panes.length >= MAX_PANES) throw httpError(409, `A session holds at most ${MAX_PANES} panes`, 'pane_limit');
+    const pane = {
+      id: `p${layout.nextId++}`,
+      kind,
+      target,
+      title: oneLine(title, MAX_TITLE) || oneLine(defaultTitle(kind, target), MAX_TITLE),
+      addedAt: now(),
+    };
+    layout.panes.push(pane);
+    return { pane: { ...pane }, added: true, layout: write(sessionId, layout) };
+  }
+
+  // Returns the new layout, or null when the session has no such pane. An emptied layout stays
+  // until retention drops it, so its ids and rev keep counting up.
+  function remove(sessionId, paneId) {
+    reload();
+    const layout = bySession.get(sessionId);
+    const i = layout ? layout.panes.findIndex((p) => p.id === paneId) : -1;
+    if (i < 0) return null;
+    layout.panes.splice(i, 1);
+    return write(sessionId, layout);
+  }
+
+  // `order` is every pane id of the session, in the new tab order.
+  function reorder(sessionId, order) {
+    reload();
+    const layout = bySession.get(sessionId);
+    const ids = layout ? layout.panes.map((p) => p.id) : [];
+    const valid = Array.isArray(order) && order.length === ids.length && new Set(order).size === ids.length;
+    if (!valid || !order.every((id) => ids.includes(id))) throw httpError(400, 'order must list every pane id once', 'bad_order');
+    if (!layout || order.every((id, i) => id === ids[i])) return get(sessionId);
+    layout.panes = order.map((id) => layout.panes.find((p) => p.id === id));
+    return write(sessionId, layout);
+  }
+
+  // Returns how many layouts went; writes only when one did.
+  function prune({ known, maxAgeMs }) {
+    reload();
+    const removed = pruneMap(bySession, (l) => l.updatedAt, { known, maxAgeMs, now: now() });
+    if (removed) persist();
+    return removed;
+  }
+
+  return { get, add, remove, reorder, prune, reload };
+}
+
+module.exports = { createPaneStore, isOwnOrigin, portOf, MAX_PANES, MAX_TITLE };

package/lib/retention.js

@@ -26,6 +26,18 @@ function isExpired(id, at, { known, maxAgeMs, now }) {
   return (known && !known.has(id)) || age > maxAgeMs;
 }
 
+// Deletes the expired entries of a session-keyed map and returns how many went.
+function pruneMap(map, atOf, { known, maxAgeMs, now }) {
+  let removed = 0;
+  for (const [id, entry] of map) {
+    if (isExpired(id, atOf(entry), { known, maxAgeMs, now })) {
+      map.delete(id);
+      removed++;
+    }
+  }
+  return removed;
+}
+
 /**
  * Sessions started through `dispatch start`, kept after their terminal ends so the card
  * keeps its marker.
@@ -55,14 +67,7 @@ function createDispatchedStore({ load, save, now = Date.now }) {
 
   // 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++;
-      }
-    }
+    const removed = pruneMap(entries, (e) => e.at, { known, maxAgeMs, now: now() });
     if (removed) persist();
     return removed;
   }
@@ -159,6 +164,7 @@ async function pruneContextStatus(dir, { known, maxAgeMs, now = Date.now(), max
 }
 
 module.exports = {
+  pruneMap,
   createDispatchedStore,
   scanTranscripts,
   pruneSessionDirs,

package/lib/scratchpad-dir.js

@@ -0,0 +1,41 @@
+// Where the harness puts a session's scratchpad. The rule and its probes: docs/session-scanning.md.
+
+const path = require('node:path');
+const { existsSync, opendirSync } = require('node:fs');
+const { encodeProjectDirName } = require('./claude-dir');
+
+function isEmptyDir(dir) {
+  let handle;
+  try {
+    handle = opendirSync(dir);
+    return handle.readSync() === null;
+  } catch {
+    return true;
+  } finally {
+    handle?.closeSync();
+  }
+}
+
+function createScratchpadDirResolver({ root, resolveWorktree, exists = existsSync, isEmpty = isEmptyDir }) {
+  // A by-project dir that holds an entry always wins, so that answer is kept and never probed again.
+  const settled = new Map();
+
+  return function getScratchpadDir(id, meta) {
+    if (!meta.jsonlPath) return null;
+    const byProject = path.join(root, path.basename(path.dirname(meta.jsonlPath)), id, 'scratchpad');
+    if (settled.get(id) === byProject) return byProject;
+
+    // Claude Code keys the scratchpad on the process's original cwd, while entering a worktree
+    // moves the transcript under the worktree.
+    const wt = resolveWorktree(meta.project);
+    const launch = wt ? wt.repo : meta.project;
+    if (!launch) return byProject;
+    const byLaunch = path.join(root, encodeProjectDirName(launch), id, 'scratchpad');
+    if (byLaunch === byProject || !exists(byLaunch)) return byProject;
+    if (isEmpty(byProject)) return byLaunch;
+    settled.set(id, byProject);
+    return byProject;
+  };
+}
+
+module.exports = { createScratchpadDirResolver };

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.2",
+  "version": "7.0.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,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "2.24.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/skills/kanban/SKILL.md

@@ -1,37 +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
 
-`preview` and `link` take markdown (`.md`) and HTML (`.html`). HTML renders as authored in a sandboxed iframe, and cck inlines its local stylesheets, scripts and images, `url()` refs in `<style>` blocks included. To show the user a page, a prototype or a collage of screenshots, write the HTML and preview that file: do not render it to an image first or serve it over HTTP.
+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.