claude-code-kanban 7.20.0 → 7.22.0

package/lib/addons.js

@@ -0,0 +1,238 @@
+// Dock add-ons: web pages on the rail beside the embedded terminal. A global entry shows in every
+// session; a session's entries and its param overrides expire with the session (docs/retention.md).
+// The file is shared by every board process on the config dir and the CLI, as panes.json is.
+
+const path = require('node:path');
+const { httpError } = require('./http-error');
+const { isLoopbackAddress } = require('./net-guard');
+const { oneLine } = require('./one-line');
+const { pruneMap } = require('./retention');
+
+const MAX_ADDONS = 20;
+const MAX_TITLE = 100;
+const MAX_ICON = 2;
+const MAX_PARAM = 500;
+const MAX_RUN = 1000;
+const BUILTINS = ['sessionId', 'cwd', 'project'];
+const PARAM_NAME = /^[A-Za-z][\w-]{0,31}$/;
+const KEY = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+const PLACEHOLDER = /\{([^{}]*)\}/g;
+
+const placeholders = (url) => [...url.matchAll(PLACEHOLDER)].map((m) => m[1]);
+const sampleUrl = (url) => url.replace(PLACEHOLDER, 'x');
+
+// A value of '' in an override drops that key, so the entry's own value applies again.
+function cleanParams(raw, { allowEmpty = false } = {}) {
+  if (raw == null) return {};
+  if (typeof raw !== 'object' || Array.isArray(raw)) throw httpError(400, 'params must be an object', 'bad_param');
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (!PARAM_NAME.test(k) || BUILTINS.includes(k)) throw httpError(400, `Bad param name: ${k}`, 'bad_param');
+    if (typeof v !== 'string' || v.length > MAX_PARAM || (!v && !allowEmpty)) {
+      throw httpError(400, `Param ${k} needs a value of at most ${MAX_PARAM} characters`, 'bad_param');
+    }
+    out[k] = v;
+  }
+  return out;
+}
+
+// Returns the URL with each placeholder filled by `x`, for the syntax and origin checks.
+function checkAddonUrl(url, params) {
+  if (typeof url !== 'string' || !url) throw httpError(400, 'url is required', 'bad_url');
+  for (const name of placeholders(url)) {
+    if (!BUILTINS.includes(name) && !(name in params)) {
+      throw httpError(400, `No value for {${name}}: pass --param ${name}=<value>, or use {${BUILTINS.join('}, {')}}`, 'missing_param');
+    }
+  }
+  const sample = sampleUrl(url);
+  let u;
+  try {
+    u = new URL(sample);
+  } catch {
+    throw httpError(400, `Not a URL: ${url}`, 'bad_url');
+  }
+  if (u.protocol !== 'http:' && u.protocol !== 'https:') throw httpError(400, 'An add-on URL must be http(s)', 'bad_url');
+  return sample;
+}
+
+// cck starts `run` only for a page on this machine, so the port it checks is the server's own.
+function cleanRun(run, cwd, sample, isGlobal) {
+  if (run == null || run === '') {
+    if (cwd) throw httpError(400, 'cwd needs run', 'bad_run');
+    return {};
+  }
+  if (!isGlobal) throw httpError(400, 'Only a global add-on has a run command', 'bad_run');
+  if (typeof run !== 'string' || run.length > MAX_RUN || /[\r\n\0]/.test(run)) {
+    throw httpError(400, `run must be one line of at most ${MAX_RUN} characters`, 'bad_run');
+  }
+  if (cwd != null && (typeof cwd !== 'string' || !path.isAbsolute(cwd))) throw httpError(400, 'cwd must be an absolute path', 'bad_run');
+  if (!isLoopbackAddress(new URL(sample).hostname)) throw httpError(400, 'A run command needs a URL on localhost', 'bad_run');
+  return { run, ...(cwd && { cwd }) };
+}
+
+const emptyData = () => ({ nextId: 1, global: [], sessions: new Map() });
+const copy = (e) => ({ ...e, params: { ...e.params } });
+
+const isEntry = (e) => e && typeof e.id === 'string' && typeof e.url === 'string' && typeof e.title === 'string';
+
+function cleanData(raw) {
+  const data = emptyData();
+  if (!raw || typeof raw !== 'object') return data;
+  const ids = new Set();
+  const keep = (list) =>
+    (Array.isArray(list) ? list : [])
+      .filter((e) => isEntry(e) && !ids.has(e.id) && ids.add(e.id))
+      .slice(0, MAX_ADDONS)
+      .map((e) => ({ ...e, params: e.params && typeof e.params === 'object' ? e.params : {} }));
+  data.global = keep(raw.global);
+  for (const [sid, s] of Object.entries(raw.sessions || {})) {
+    if (!s || !Number.isFinite(s.updatedAt)) continue;
+    data.sessions.set(sid, { addons: keep(s.addons), params: s.params && typeof s.params === 'object' ? s.params : {}, updatedAt: s.updatedAt });
+  }
+  const maxId = Math.max(0, ...[...ids].map((id) => Number(id.slice(1)) || 0));
+  data.nextId = Math.max(Number.isInteger(raw.nextId) ? raw.nextId : 1, maxId + 1);
+  return data;
+}
+
+const toFile = (data) => ({ version: 1, nextId: data.nextId, global: data.global, sessions: Object.fromEntries(data.sessions) });
+
+/**
+ * @param {object} o
+ * @param {() => object|null|undefined} o.load the file's JSON, null when there is none, or undefined
+ *   when it has not changed since the last load or save
+ * @param {(data: object) => void} o.save
+ * @param {(global: object[]) => void} [o.onChange] called with the global entries after a write, and after a
+ *   reload that changed something
+ * @param {(url: string) => boolean} [o.isOwnOrigin] true for a URL on the board's or the hub's origin
+ */
+function createAddonStore({ load, save, onChange = () => {}, isOwnOrigin = () => false, now = Date.now }) {
+  let data = emptyData();
+  let saved = '';
+
+  function reload() {
+    const raw = load();
+    if (raw === undefined) return;
+    data = cleanData(raw);
+    const next = JSON.stringify(toFile(data));
+    if (next === saved) return;
+    saved = next;
+    onChange(data.global.map(copy));
+  }
+  reload();
+
+  function write() {
+    const file = toFile(data);
+    saved = JSON.stringify(file);
+    save(file);
+    onChange(data.global.map(copy));
+  }
+
+  const session = (sid) => data.sessions.get(sid) || { addons: [], params: {}, updatedAt: 0 };
+
+  function touch(sid, s) {
+    s.updatedAt = now();
+    data.sessions.set(sid, s);
+  }
+
+  function list(sid) {
+    const s = sid ? session(sid) : null;
+    return {
+      global: data.global.map(copy),
+      session: s ? s.addons.map(copy) : [],
+      params: s ? structuredClone(s.params) : {},
+    };
+  }
+
+  // The same URL added again in the same scope returns its entry, so a repeated add is harmless;
+  // a new `run` or `cwd` replaces the entry's. `scope` is 'global' or a session id.
+  // A `key` (an installer's name for the entry, such as a manifest id) finds the entry instead,
+  // else the entry with the same URL, and the add replaces its fields: an update keeps the id.
+  function add(scope, { url, title, icon, params, run, cwd, key }) {
+    if (key != null && (typeof key !== 'string' || !KEY.test(key))) throw httpError(400, `Bad key: ${key}`, 'bad_key');
+    const clean = cleanParams(params);
+    const sample = checkAddonUrl(url, clean);
+    if (isOwnOrigin(sample)) throw httpError(400, 'An add-on cannot show the board or the hub itself', 'own_origin');
+    const isGlobal = scope === 'global';
+    const start = cleanRun(run, cwd, sample, isGlobal);
+    reload();
+    const s = isGlobal ? null : session(scope);
+    const addons = isGlobal ? data.global : s.addons;
+    const glyph = [...oneLine(icon, 16)].slice(0, MAX_ICON).join('');
+    const fields = { url, title: oneLine(title, MAX_TITLE) || new URL(sample).host, ...(glyph && { icon: glyph }), ...start, params: clean };
+    const found = key
+      ? (addons.find((e) => e.key === key) ?? addons.find((e) => e.url === url && !e.key))
+      : addons.find((e) => e.url === url);
+    if (found) {
+      let next = found;
+      if (key) next = { id: found.id, key, ...fields, addedAt: found.addedAt };
+      else if (start.run && (start.run !== found.run || start.cwd !== found.cwd)) {
+        next = { ...found, ...start };
+        if (!start.cwd) delete next.cwd;
+      }
+      if (JSON.stringify(next) !== JSON.stringify(found)) {
+        addons[addons.indexOf(found)] = next;
+        if (!isGlobal) touch(scope, s);
+        write();
+      }
+      return { addon: copy(next), added: false };
+    }
+    if (addons.length >= MAX_ADDONS) throw httpError(409, `At most ${MAX_ADDONS} add-ons ${isGlobal ? 'are global' : 'per session'}`, 'addon_limit');
+    const addon = { id: `a${data.nextId++}`, ...(key && { key }), ...fields, addedAt: now() };
+    addons.push(addon);
+    if (!isGlobal) touch(scope, s);
+    write();
+    return { addon: copy(addon), added: true };
+  }
+
+  // A global id needs no session. Returns the removed entry with its scope, or null.
+  function remove(sid, id) {
+    reload();
+    const g = data.global.findIndex((e) => e.id === id);
+    if (g >= 0) {
+      const [addon] = data.global.splice(g, 1);
+      for (const s of data.sessions.values()) delete s.params[id];
+      write();
+      return { addon, scope: 'global' };
+    }
+    const s = sid && data.sessions.get(sid);
+    const i = s ? s.addons.findIndex((e) => e.id === id) : -1;
+    if (i < 0) return null;
+    const [addon] = s.addons.splice(i, 1);
+    delete s.params[id];
+    touch(sid, s);
+    write();
+    return { addon, scope: sid };
+  }
+
+  // Sets this session's values for the add-on's params. Returns null when the session sees no such add-on.
+  function setParams(sid, id, params) {
+    const clean = cleanParams(params, { allowEmpty: true });
+    reload();
+    const s = session(sid);
+    if (!data.global.some((e) => e.id === id) && !s.addons.some((e) => e.id === id)) return null;
+    const next = { ...s.params[id], ...clean };
+    for (const [k, v] of Object.entries(next)) if (!v) delete next[k];
+    if (Object.keys(next).length) s.params[id] = next;
+    else delete s.params[id];
+    touch(sid, s);
+    write();
+    return list(sid);
+  }
+
+  // Returns how many sessions went; writes only when one did. Global entries never expire.
+  function prune({ known, maxAgeMs }) {
+    reload();
+    const removed = pruneMap(data.sessions, (s) => s.updatedAt, { known, maxAgeMs, now: now() });
+    if (removed) write();
+    return removed;
+  }
+
+  function getGlobal(id) {
+    const e = data.global.find((g) => g.id === id);
+    return e ? copy(e) : null;
+  }
+
+  return { list, getGlobal, add, remove, setParams, prune, reload };
+}
+
+module.exports = { createAddonStore, sampleUrl, MAX_ADDONS };

package/lib/panes.js

@@ -183,6 +183,19 @@ function createPaneStore({ load, save, onChange = () => {}, now = Date.now }) {
     return write(sessionId, layout);
   }
 
+  // Returns null when the session has no such pane.
+  function setDock(sessionId, paneId, on) {
+    reload();
+    const layout = bySession.get(sessionId);
+    const pane = layout?.panes.find((p) => p.id === paneId);
+    if (!pane) return null;
+    if (on && pane.kind !== 'url') throw httpError(400, 'Only a URL pane can go in the dock', 'bad_dock');
+    if (!!pane.dock === on) return get(sessionId);
+    if (on) pane.dock = true;
+    else delete pane.dock;
+    return write(sessionId, layout);
+  }
+
   // `order` is every pane id of the session, in the new tab order.
   function reorder(sessionId, order) {
     reload();
@@ -211,7 +224,7 @@ function createPaneStore({ load, save, onChange = () => {}, now = Date.now }) {
     return out;
   }
 
-  return { get, add, remove, removeShow, rename, reorder, prune, reload, fileTargets };
+  return { get, add, remove, removeShow, rename, setDock, reorder, prune, reload, fileTargets };
 }
 
 module.exports = { createPaneStore, isOwnOrigin, portOf, MAX_PANES, MAX_TITLE };

package/lib/parent-cache.js

@@ -24,6 +24,10 @@ function getParentVerdict(sessionId, meta) {
   return v.result;
 }
 
+// No staleness check, so no file access: for the session list's fork badge, where a stale
+// verdict costs a wrong icon until the next lookup.
+const peekParentVerdict = (sessionId) => verdicts.get(sessionId)?.result || null;
+
 // self: the child's stat from the lookup. parentIno: null when no parent was found.
 function setParentVerdict(sessionId, meta, self, parentIno, result) {
   verdicts.set(sessionId, {
@@ -55,4 +59,4 @@ function importParentVerdicts(entries) {
   }
 }
 
-module.exports = { getParentVerdict, setParentVerdict, parentVerdictsDirty, exportParentVerdicts, importParentVerdicts };
+module.exports = { getParentVerdict, setParentVerdict, peekParentVerdict, parentVerdictsDirty, exportParentVerdicts, importParentVerdicts };

package/lib/retention.js

@@ -43,6 +43,7 @@ const textOrNull = (v) => (typeof v === 'string' && v ? v : null);
 function dispatchedEntry(e) {
   return {
     parent: textOrNull(e.parent),
+    child: e.child === true,
     at: e.at,
     name: textOrNull(e.name),
     group: textOrNull(e.group),
@@ -55,7 +56,7 @@ function dispatchedEntry(e) {
  * Sessions started through `dispatch start`, kept after their terminal ends so the card
  * 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, name, group, cwd, worktree}}}` or null
+ * @param {() => object|null} o.load returns `{version: 1, sessions: {[id]: {parent, child, at, name, group, cwd, worktree}}}` or null
  * @param {(data: object) => void} o.save
  */
 function createDispatchedStore({ load, save, now = Date.now }) {

package/lib/terminal.js

@@ -288,6 +288,8 @@ function ptyEnv({ claudeDir, isDefaultDir, noFlicker, cckUrl, terminalId }) {
   if (noFlicker) env.CLAUDE_CODE_NO_FLICKER = '1';
   env.TERM = 'xterm-256color';
   env.COLORTERM = 'truecolor';
+  // Claude Code draws OSC 8 links only for terminals it knows; the frame's xterm.js opens them.
+  env.FORCE_HYPERLINK = '1';
   return env;
 }
 
@@ -663,7 +665,7 @@ function createTerminalService(o) {
     const s = {
       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, awaitingTrust: false, edit: !!spec?.edit,
-      forkOf: spec?.forkOf || null, resumeOf: spec?.resume || null, restore: spec?.restore !== false,
+      forkOf: spec?.forkOf || null, resumeOf: spec?.resume || null, restore: spec?.restore !== false, prompted: !!spec?.prompt,
     };
     if (s.edit) queueText(s, claudeCommand(shell, claudeArgs, spec.prompt), false);
     else if (spec?.prompt) queueText(s, spec.prompt, true);
@@ -893,7 +895,7 @@ function createTerminalService(o) {
   function list() {
     return [...sessions.values()].filter((s) => !s.ended).map((s) => ({
       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, claudeExited: !!s.claudeExitedAt, awaitingTrust: s.awaitingTrust,
+      name: s.name, worktree: s.worktree, edit: s.edit, forkOf: s.forkOf, prompted: s.prompted, claudeExited: !!s.claudeExitedAt, awaitingTrust: s.awaitingTrust,
     }));
   }
 
@@ -933,7 +935,7 @@ function createTerminalService(o) {
     if (reason) return { status: 403, error: reason };
     if (msg.id != null && !(typeof msg.id === 'string' && UUID_RE.test(msg.id))) return { status: 400, error: 'invalid session id' };
     const r = await start(msg.id || crypto.randomUUID(), 'new', msg, HEADLESS_COLS, HEADLESS_ROWS, extraEnv);
-    return r.error ? r : { id: r.session.id, cwd: r.session.cwd };
+    return r.error ? r : { id: r.session.id, cwd: r.session.cwd, name: r.session.name, prompted: r.session.prompted };
   }
 
   // Pastes into claude's input box and stops there: Enter would also submit whatever the

package/lib/write-json-atomic.js

@@ -0,0 +1,16 @@
+const path = require('node:path');
+const { mkdirSync, writeFileSync, renameSync, rmSync } = require('node:fs');
+
+function writeJsonAtomic(file, obj, mode) {
+  mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync(tmp, JSON.stringify(obj, null, 2), { encoding: 'utf8', mode });
+    renameSync(tmp, file);
+  } catch (e) {
+    rmSync(tmp, { force: true });
+    throw e;
+  }
+}
+
+module.exports = { writeJsonAtomic };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "7.20.0",
+  "version": "7.22.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,5 +1,5 @@
 {
   "name": "claude-code-kanban",
-  "version": "3.8.0",
+  "version": "3.10.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/skills/addon/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: addon
+description: Dock add-ons, pages on the rail beside cck's embedded terminal. Use to build a new add-on, or to add, list, set or remove one.
+argument-hint: '[add <url> | list | set <id> k=v | rm <id> | build <what>] [--global]'
+---
+
+# Dock add-ons
+
+An add-on is a page from a server the user runs. It stays on the dock rail of this session, or of every session with `--global`, until it is removed. For a view of this conversation only, post a show card instead.
+
+## Add, list, set, remove
+
+1. Read `claude-code-kanban help addon <verb>`. It names the URL placeholders the board fills per session and when `--global` applies.
+2. Run `claude-code-kanban addon <verb> ...` and report its output line to the user. The user opens the add-on from the rail.
+
+## Build a new add-on
+
+When the page does not exist yet, follow [references/build.md](references/build.md), then register it as above.

package/plugin/plugins/claude-code-kanban/skills/addon/references/build.md

@@ -0,0 +1,77 @@
+# Build an add-on
+
+An add-on is one HTML page and a small server that serves it. The board frames the page by its URL, so any stack works; this guide uses Node with no dependencies. The build is done when the server answers 200 and `addon add` printed an id.
+
+## 1. Write the server and the page
+
+Put them in a folder of their own, outside the project when the add-on serves more than one project:
+
+```js
+// server.js: node server.js [port]
+const http = require('node:http');
+const fs = require('node:fs');
+const path = require('node:path');
+const port = Number(process.env.PORT || process.argv[2]) || 4100;
+const page = fs.readFileSync(path.join(__dirname, 'index.html'));
+http.createServer((req, res) => {
+  const url = new URL(req.url, 'http://x');
+  if (url.pathname === '/') return res.writeHead(200, { 'Content-Type': 'text/html' }).end(page);
+  res.writeHead(404).end();
+}).listen(port, '127.0.0.1', () => console.log(`http://localhost:${port}/`));
+```
+
+The server binds to `127.0.0.1` and sends its pages with no `X-Frame-Options` or `frame-ancestors` header, so the board can frame them.
+
+## 2. Read the context from the URL
+
+The URL is the page's only input from the board. The page reads the values the board filled in, such as `?cwd={cwd}`, from `location.search`, and passes them to its server on each request.
+
+## 3. Take the board's theme
+
+Style the page with the variables of the HTML contract in [the show skill](../../show/SKILL.md#html-contract), in its flat style. Set fallback values for them in `:where(:root)`, and apply the board's values from its message, which it sends on each load and each theme change:
+
+```js
+addEventListener('message', (e) => {
+  if (e.source !== parent || e.data?.type !== 'cck-show:tokens') return;
+  for (const [k, v] of Object.entries(e.data.tokens)) document.documentElement.style.setProperty(k, v);
+});
+```
+
+## 4. Hand back the board's keys and focus
+
+While the page has focus, it gets every key press, so the board's keys (Alt+Enter to expand, Alt+W, Alt+↑/↓, the terminal and hub keys) stop working, and the board cannot tell that the dock has focus. Put this script in the page, as it is. The board sends the presses it wants (`hub:hostKeys`), the script hands only those back, and it reports focus so the dock lights up:
+
+```js
+let boardKeys = new Set();
+let board = null;
+const sigs = (e) => {
+  const mods = [e.ctrlKey && 'ctrl', e.altKey && 'alt', e.shiftKey && 'shift', e.metaKey && 'meta'].filter(Boolean).join('+');
+  return [e.code && `${mods}|c:${e.code}`, e.key && e.key !== 'Unidentified' && `${mods}|k:${e.key.toLowerCase()}`];
+};
+addEventListener('message', (e) => {
+  if (e.source !== parent || e.data?.type !== 'hub:hostKeys') return;
+  board = e.origin;
+  boardKeys = new Set(e.data.keys.map((k) => sigs(k).find(Boolean)));
+});
+addEventListener('keydown', (e) => {
+  if (!board || !sigs(e).some((s) => boardKeys.has(s))) return;
+  e.preventDefault();
+  parent.postMessage({ type: 'hub:hostKey', key: e.key, code: e.code, ctrl: e.ctrlKey, alt: e.altKey, shift: e.shiftKey, meta: e.metaKey }, board);
+}, true);
+for (const on of [true, false]) addEventListener(on ? 'focus' : 'blur', () => parent.postMessage({ type: 'cck-show:focus', on }, '*'));
+```
+
+## 5. Push updates
+
+When the content follows files, the server watches them (`fs.watch`) and pushes each change to the page over server-sent events (`text/event-stream`), and the page updates in place. A push costs nothing while nothing changes; the board unloads a page hidden for a minute.
+
+## 6. Fit the dock
+
+The dock is 360 to 900 px wide and the full height of the terminal. Lay the page out in normal flow that wraps at 360 px, and let the body scroll.
+
+## 7. Run and register
+
+1. Start the server where the user can see and stop it, such as a tmux window, or ask the user to start it.
+2. Check that it answers 200: `curl -s -o /dev/null -w '%{http_code}' http://localhost:4100/`.
+3. Register it with `claude-code-kanban addon add "<url>" --title <t>`. When the user asked for every session, add `--global --run "<start command>" --cwd <server folder>`, so the board starts the server when the add-on opens. The server reads its port from `PORT`.
+4. Tell the user it is on the rail. For a session add-on, also give the command that starts the server again after a restart.

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

@@ -1,7 +1,7 @@
 ---
 name: dispatch
 description: Dispatch tasks to new Claude Code sessions in the kanban board's terminal. Use when the user asks to dispatch or delegate a task to another session.
-argument-hint: '<task> [--handoff] [--group <name>] [--model haiku|sonnet|opus|fable] [--worktree [name]] [-- <claude args>]'
+argument-hint: '<task> [--handoff] [--child | --group <name>] [--model haiku|sonnet|opus|fable] [--worktree [name]] [-- <claude args>]'
 ---
 
 # Kanban dispatch

package/plugin/plugins/claude-code-kanban/skills/dispatch/references/orchestration-patterns.md

@@ -28,11 +28,11 @@ One worker, one reply. The reply can go to any peer. When another session owns t
 
 ## Handoff
 
-One worker, no reply line. The worker owns the task, and you save the turn a reply costs.
+One worker, no reply line, `--group`. The worker owns the task, and you save the turn a reply costs.
 
 ## Orchestrator-workers
 
-One worker per independent part, all started before you wait on any. They run at the same time, and each holds only its own part in context. Give each a unique `--name` and one shared `--group`, then combine the replies.
+One worker per independent part, all started before you wait on any. They run at the same time, and each holds only its own part in context. Give each a unique `--name` and `--child`, then combine the replies.
 
 ## Prompt chaining
 

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

@@ -21,6 +21,7 @@ This session id is `${CLAUDE_SESSION_ID}`. `--session` defaults to it through `$
 | `task` | `list` for a session, a project or the whole board |
 | `project` | `list` |
 | `dispatch` | `start`, `list`, `end` — run `/claude-code-kanban:dispatch` instead |
+| `addon` | `add`, `list`, `set`, `rm` a page on the dock rail — run `/claude-code-kanban:addon` instead |
 | `terminal` | `list` every terminal in cck, read-only |
 
 ## Run a command