claude-code-kanban 5.3.0 → 6.0.0

package/lib/retention.js

@@ -3,7 +3,6 @@
 const fs = require('node:fs/promises');
 const path = require('node:path');
 const { readSettings } = require('./claude-settings');
-const { DISPATCH_OUTCOME } = require('./dispatch');
 
 const DAY_MS = 24 * 60 * 60 * 1000;
 const DEFAULT_CLEANUP_DAYS = 30;
@@ -11,7 +10,6 @@ const DEFAULT_CLEANUP_DAYS = 30;
 // read that gap as a deleted transcript.
 const GRACE_MS = 60 * 60 * 1000;
 const MAX_DISPATCHED = 500;
-const OUTCOMES = new Set(Object.keys(DISPATCH_OUTCOME));
 
 // Only the config dir's settings: retention is per config dir, not per project.
 function retentionMs(claudeDir) {
@@ -28,10 +26,10 @@ function isExpired(id, at, { known, maxAgeMs, now }) {
 }
 
 /**
- * Sessions started through `dispatch start`, kept after the dispatch settles so the card
+ * Sessions started through `dispatch start`, kept after their terminal ends so the card
  * keeps its marker.
  * @param {object} o
- * @param {() => object|null} o.load returns `{version: 1, sessions: {[id]: {parent, status, at}}}` or null
+ * @param {() => object|null} o.load returns `{version: 1, sessions: {[id]: {parent, at}}}` or null
  * @param {(data: object) => void} o.save
  */
 function createDispatchedStore({ load, save, now = Date.now }) {
@@ -41,10 +39,7 @@ 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;
-      // The dispatch registry is in memory: a dispatch that was running when the server
-      // stopped can never settle, so it reads as ended.
-      const status = OUTCOMES.has(e.status) ? e.status : 'exited';
-      entries.set(id, { parent: typeof e.parent === 'string' ? e.parent : null, status, at: e.at });
+      entries.set(id, { parent: typeof e.parent === 'string' ? e.parent : null, at: e.at });
     }
   }
 
@@ -52,18 +47,11 @@ function createDispatchedStore({ load, save, now = Date.now }) {
 
   function record(id, parent) {
     entries.delete(id);
-    entries.set(id, { parent: parent || null, status: 'running', at: now() });
+    entries.set(id, { parent: parent || null, at: now() });
     if (entries.size > MAX_DISPATCHED) entries.delete(entries.keys().next().value);
     persist();
   }
 
-  function settle(id, status) {
-    const e = entries.get(id);
-    if (!e || e.status !== 'running' || !OUTCOMES.has(status)) return;
-    e.status = status;
-    persist();
-  }
-
   // Returns how many entries went; writes only when one did.
   function prune({ known, maxAgeMs }) {
     const t = now();
@@ -78,7 +66,7 @@ function createDispatchedStore({ load, save, now = Date.now }) {
     return removed;
   }
 
-  return { record, settle, prune, get: (id) => entries.get(id) || null };
+  return { record, prune, get: (id) => entries.get(id) || null };
 }
 
 // Names only, no stat or parse: the sweep needs which transcripts exist, not what they hold.

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 = 2;
+const VERSION = 3;
 // 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

@@ -79,8 +79,9 @@ function clampWait(sec) {
   return Math.min(Math.max(Number(sec) || 0, 0), MAX_WAIT_SEC);
 }
 
-// Each topic rides its own bucket, so the dispatch postman never prints task moves
-// the user did not grant with the follow skill. No topic is the task-move bucket.
+// Each topic rides its own bucket, so a postman on a topic never prints task moves the
+// user did not grant with the follow skill. No topic is the task-move bucket. Plugins
+// before 2.22.0 run a `--topic dispatch` postman, which must keep getting nothing.
 function topicKey(topic, sessionId) {
   return topic ? `${topic}:${sessionId}` : sessionId;
 }

package/lib/terminal.js

@@ -26,6 +26,17 @@ const PICK_START_SLACK_MS = 2000;
 const NAME_RE = /^[A-Za-z0-9][A-Za-z0-9 ._-]{0,79}$/;
 const WORKTREE_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 const MODELS = new Set(['fable', 'opus', 'sonnet', 'haiku']);
+// Extra claude args reach the command line inside plain quotes (quoteArg), so a character
+// that ends or expands those quotes in any of the shells is refused.
+// biome-ignore lint/suspicious/noControlCharactersInRegex: refuses control characters on purpose
+const EXTRA_ARG_RE = /^[^\x00-\x1f\x7f'"%]*$/;
+const MAX_EXTRA_ARGS = 64;
+const MAX_EXTRA_ARG = 4096;
+// cck sets these itself, or they would start something other than a new session.
+const OWNED_FLAGS = new Set([
+  '--session-id', '-n', '--name', '--model', '-w', '--worktree',
+  '-r', '--resume', '-c', '--continue', '--fork-session', '-p', '--print',
+]);
 const MAX_PROMPT = 32 * 1024;
 const PROMPT_QUIET_MS = 400;
 // Watermarks from https://xtermjs.org/docs/guides/flowcontrol/ — pause the PTY while a
@@ -118,8 +129,8 @@ function resolveShell(value, which, platform = process.platform, env = process.e
 }
 
 // claudeArgs is null for a plain shell. Its items are fixed flags, a validated UUID, or
-// values that passed NAME_RE / WORKTREE_RE, so plain quoting is enough to keep a space
-// from splitting an argument and nothing can break out of the quotes.
+// values that passed NAME_RE / WORKTREE_RE / EXTRA_ARG_RE, so plain quoting is enough to
+// keep a space from splitting an argument and nothing can break out of the quotes.
 function quoteArg(arg, family) {
   if (/^[A-Za-z0-9._-]+$/.test(arg)) return arg;
   return family === 'cmd' ? `"${arg}"` : `'${arg}'`;
@@ -142,7 +153,7 @@ function claudeArgsFor(mode, id, spec) {
   if (mode === 'fork') return ['--resume', id, '--fork-session'];
   if (mode === 'pick') return ['--resume'];
   if (mode === 'new') {
-    const args = ['--session-id', id];
+    const args = ['--session-id', id, ...(spec.extraArgs || [])];
     if (spec.name) args.push('--name', spec.name);
     if (spec.model) args.push('--model', spec.model);
     // Last, because its value is optional and a following flag must not be taken for it.
@@ -153,6 +164,16 @@ function claudeArgsFor(mode, id, spec) {
   return ['--resume', id];
 }
 
+function extraArgsError(args) {
+  if (!Array.isArray(args) || args.length > MAX_EXTRA_ARGS) return `claude args (at most ${MAX_EXTRA_ARGS})`;
+  for (const a of args) {
+    if (typeof a !== 'string' || a.length > MAX_EXTRA_ARG || !EXTRA_ARG_RE.test(a)) return 'claude arg: no quotes, % or control characters';
+    const flag = a.split('=')[0];
+    if (OWNED_FLAGS.has(flag)) return `claude arg: cck sets ${flag}`;
+  }
+  return null;
+}
+
 // Returns the new-session options from a hello, or a string naming the bad field.
 function parseNewSpec(msg) {
   if (typeof msg.cwd !== 'string' || !msg.cwd) return 'folder';
@@ -165,7 +186,10 @@ function parseNewSpec(msg) {
   // biome-ignore lint/suspicious/noControlCharactersInRegex: strips ESC so a prompt cannot carry terminal sequences
   const prompt = typeof msg.prompt === 'string' ? msg.prompt.replace(/\x1b/g, '').trim() : '';
   if (prompt.length > MAX_PROMPT) return 'prompt';
-  return { cwd: msg.cwd, name: name || null, worktree, model, prompt: prompt || null };
+  const extraArgs = msg.extraArgs ?? [];
+  const bad = extraArgsError(extraArgs);
+  if (bad) return bad;
+  return { cwd: msg.cwd, name: name || null, worktree, model, prompt: prompt || null, extraArgs };
 }
 
 function samePath(a, b) {
@@ -552,8 +576,9 @@ function createTerminalService(o) {
     const cols = clampDim(msg.cols, 80);
     const rows = clampDim(msg.rows, 24);
 
+    // An ended PTY stays in the map until its process exits; a hello for its id starts a new one.
     const existing = sessions.get(id);
-    if (existing) return attach(ws, existing, true);
+    if (existing && !existing.ended) return attach(ws, existing, true);
 
     if (mode === 'auto' && o.isLiveElsewhere(id)) {
       send(ws, { t: 'live' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "5.3.0",
+  "version": "6.0.0",
   "description": "A web-based Kanban board for viewing Claude Code tasks with agent teams support",
   "main": "server.js",
   "type": "commonjs",
@@ -11,7 +11,6 @@
     "start": "node server.js",
     "dev": "node --watch server.js",
     "test": "node --test test/*.test.js",
-    "test:hooks": "bash tests/test-agent-spy.sh && bash tests/test-approval-gate.sh",
     "validate:schemas": "node test/validate-live-schemas.js",
     "prepare": "husky"
   },

package/plugin/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
     {
       "name": "claude-code-kanban",
       "source": "./plugins/claude-code-kanban",
-      "description": "claude-code-kanban dashboard integration: agent activity tracking, context statusline, and a skill to drive the board from a session"
+      "description": "claude-code-kanban dashboard integration: agent activity tracking, context and cost tracking, and a skill to drive the board from a session"
     }
   ]
 }

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

@@ -1,7 +1,7 @@
 {
   "name": "claude-code-kanban",
-  "version": "2.17.2",
-  "description": "claude-code-kanban dashboard integration: agent activity tracking, context statusline, skills to drive the board from a session and to follow it",
+  "version": "2.22.0",
+  "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

@@ -0,0 +1,266 @@
+import type { EngineInterface, Register, ToolCallArgs } from 'claude-code'
+import { cckRoot } from './context'
+
+// Mods cannot delete files. The server reads any status but "waiting" as no ask.
+export const CLEARED = JSON.stringify({ status: 'cleared' })
+
+export const BOARD_ALLOWED = 'Approved from the board — running'
+
+const POLL_MS = 500
+
+type Kind = 'permission' | 'question' | 'plan'
+type Ask = { id: string; kind: Kind; dir: string; waitMs?: number }
+type Decision = {
+  behavior?: 'allow' | 'deny'
+  message?: string
+  updatedInput?: Record<string, unknown>
+  answers?: Record<string, unknown>
+}
+
+// tool.check carries the call's id on a real call only, so a call without one is found by its input.
+const pending = new Set<{ id?: string; tool: string; args: Record<string, unknown>; asked: (ask: Ask) => void }>()
+// The board's allow runs the tool again through $.tool.call, and its tool.check must not ask twice.
+const allowOnce = new Set<string>()
+const callKey = (tool: string, input: unknown) => `${tool}\0${JSON.stringify(input)}`
+
+let cck: Promise<string> | undefined
+
+// The engine does not follow $ into an imported function, so only the path rule is shared.
+function cckDir($: EngineInterface) {
+  cck ??= Promise.all([$.env.get('CLAUDE_CONFIG_DIR'), $.env.get('HOME'), $.env.get('USERPROFILE')]).then(
+    ([configDir, home, userProfile]) => cckRoot(configDir, home, userProfile),
+  )
+  return cck
+}
+
+async function readText($: EngineInterface, path: string) {
+  try {
+    return await $.fs.read(path)
+  } catch {
+    return undefined
+  }
+}
+
+async function readJson<T>($: EngineInterface, path: string): Promise<T | undefined> {
+  try {
+    return JSON.parse((await readText($, path)) ?? '')
+  } catch {
+    return undefined
+  }
+}
+
+// The server folds an agent's lines last-key-wins, so a line leaves out a field it does not know.
+async function appendLine($: EngineInterface, path: string, record: object, { onlyIfExists = false } = {}) {
+  const text = await readText($, path)
+  if (text === undefined && onlyIfExists) return
+  await $.fs.write(path, `${text ?? ''}${JSON.stringify(record)}\n`)
+}
+
+async function sessionDir($: EngineInterface) {
+  const [dir, id] = await Promise.all([cckDir($), $.session.id()])
+  return `${dir}/agent-activity/${id}`
+}
+
+const kindOf = (tool: string): Kind =>
+  tool === 'AskUserQuestion' ? 'question' : tool === 'ExitPlanMode' ? 'plan' : 'permission'
+
+// Mirrors approvalsFrom and isKindGated in lib/approvals.js: the gate is on unless config.json
+// says enabled: false, and a missing or broken file means the defaults.
+async function boardWaitMs($: EngineInterface, kind: Kind) {
+  type Approvals = { enabled?: unknown; mode?: unknown; waitSeconds?: unknown }
+  const a = (await readJson<{ approvals?: Approvals }>($, `${await cckDir($)}/config.json`))?.approvals ?? {}
+  if (a.enabled === false) return undefined
+  if (kind === 'question' && a.mode === 'permission') return undefined
+  const seconds = Number.isInteger(a.waitSeconds) && (a.waitSeconds as number) >= 0 ? (a.waitSeconds as number) : 1800
+  return Math.min(seconds, 1800) * 1000
+}
+
+// The marker shows the ask on the board whether or not the board may answer it.
+async function openAsk($: EngineInterface, tool: string, input: unknown, rule?: string): Promise<Ask> {
+  const kind = kindOf(tool)
+  const id = crypto.randomUUID()
+  const [dir, cwd, waitMs] = await Promise.all([sessionDir($), $.session.cwd(), boardWaitMs($, kind)])
+  await $.fs.write(
+    `${dir}/_waiting.json`,
+    JSON.stringify({
+      status: 'waiting',
+      kind,
+      id,
+      toolName: tool,
+      toolInput: JSON.stringify(input),
+      cwd,
+      rule,
+      timestamp: new Date().toISOString(),
+    }),
+  )
+  return { id, kind, dir, waitMs }
+}
+
+// A newer ask (a parallel call) may own the marker by now.
+async function closeAsk($: EngineInterface, ask: Ask) {
+  const marker = `${ask.dir}/_waiting.json`
+  if ((await readJson<{ id?: string }>($, marker))?.id === ask.id) await $.fs.write(marker, CLEARED)
+}
+
+async function boardDecision($: EngineInterface, ask: Ask, signal: AbortSignal) {
+  const file = `${ask.dir}/_decision-${ask.id}.json`
+  for (let waited = 0; waited < (ask.waitMs ?? 0); waited += POLL_MS) {
+    try {
+      await $.clock.sleep(POLL_MS, { signal })
+    } catch {
+      return undefined
+    }
+    const d = await readJson<Decision>($, file)
+    if (d) return d
+  }
+  return undefined
+}
+
+// Only returning ends the terminal prompt, so an allow runs the tool again from here. A terminal
+// "Yes" in the moment before the hook returns runs it twice (docs/ui-approvals.md).
+async function answerFromBoard($: EngineInterface, tool: string, args: Record<string, unknown>, ask: Ask, d: Decision) {
+  if (ask.kind === 'question') {
+    return d.answers ? { result: { questions: args.questions, answers: d.answers } } : undefined
+  }
+  if (d.behavior !== 'allow') return { deny: d.message ?? 'Denied from the board' }
+  $.ui.status(BOARD_ALLOWED)
+  const input = { ...args, ...d.updatedInput }
+  const key = callKey(tool, input)
+  allowOnce.add(key)
+  try {
+    return await $.tool.call({ ...input, tool } as ToolCallArgs)
+  } finally {
+    allowOnce.delete(key)
+    $.ui.status(undefined)
+  }
+}
+
+async function mapTaskList($: EngineInterface, cwd: string) {
+  const taskListId = await $.env.get('CLAUDE_CODE_TASK_LIST_ID')
+  if (!taskListId) return
+  const path = `${await cckDir($)}/agent-activity/_task-maps/${taskListId}.json`
+  const maps = (await readJson<Record<string, unknown>>($, path)) ?? {}
+  maps[await $.session.id()] = { project: cwd, updatedAt: new Date().toISOString() }
+  await $.fs.write(path, JSON.stringify(maps))
+}
+
+async function markStopped($: EngineInterface) {
+  await $.fs.write(`${await sessionDir($)}/_stop.json`, '')
+}
+
+// The name map lets TeammateIdle, which names the teammate, find its agent id.
+async function agentStarted($: EngineInterface, agentId: string, type: string, name?: string) {
+  const dir = await sessionDir($)
+  const ts = new Date().toISOString()
+  await Promise.all([
+    appendLine($, `${dir}/${agentId}.jsonl`, {
+      agentId,
+      type,
+      event: 'start',
+      status: 'active',
+      startedAt: ts,
+      updatedAt: ts,
+    }),
+    $.fs.write(`${dir}/_name-${name ?? type}.id`, agentId),
+  ])
+}
+
+// turn.complete also ends loops agent.spawn never started (internal agents): those have no file.
+async function agentStopped($: EngineInterface, agentId: string, lastMessage: string) {
+  const ts = new Date().toISOString()
+  await appendLine(
+    $,
+    `${await sessionDir($)}/${agentId}.jsonl`,
+    {
+      agentId,
+      event: 'stop',
+      status: 'stopped',
+      ...(lastMessage && { lastMessage }),
+      stoppedAt: ts,
+      updatedAt: ts,
+    },
+    { onlyIfExists: true },
+  )
+}
+
+// TeammateIdle names the teammate but carries no agent_id outside the teammate's own loop.
+async function teammateIdle($: EngineInterface, name: string, agentId?: string, agentType?: string) {
+  const dir = await sessionDir($)
+  const id = agentId || (await readText($, `${dir}/_name-${name}.id`))
+  if (!id) return
+  const type = agentId ? agentType : name
+  await appendLine(
+    $,
+    `${dir}/${id}.jsonl`,
+    {
+      agentId: id,
+      ...(type && { type }),
+      event: 'idle',
+      status: 'idle',
+      updatedAt: new Date().toISOString(),
+    },
+    { onlyIfExists: !type },
+  )
+}
+
+export const register: Register = on => {
+  on('tool.check', async ($, e, next) => {
+    if (allowOnce.delete(callKey(e.tool, e.input))) return { decision: 'allow' }
+    const result = await next(e)
+    if (result.decision !== 'ask') return result
+    const input = e.tool_use_id ? undefined : JSON.stringify(e.input)
+    const call = [...pending].find(p =>
+      e.tool_use_id ? p.id === e.tool_use_id : p.tool === e.tool && JSON.stringify(p.args) === input,
+    )
+    call?.asked(await openAsk($, e.tool, e.input, result.rule))
+    return result
+  })
+  on('tool.call', async ($, e, next) => {
+    const { tool, tool_use_id, agentId: _agentId, consent: _consent, ...args } = e as typeof e & { consent?: unknown }
+    let asked: (ask: Ask) => void = () => {}
+    const ask = new Promise<Ask>(resolve => {
+      asked = resolve
+    })
+    const call = { id: tool_use_id, tool, args, asked }
+    pending.add(call)
+    const run = next(e)
+    const settled = new AbortController()
+    const done = run.then(() => undefined).finally(() => settled.abort())
+    try {
+      const opened = await Promise.race([done, ask])
+      if (!opened) return await run
+      try {
+        const d = await Promise.race([
+          done,
+          boardDecision($, opened, AbortSignal.any([next.signal, settled.signal])),
+        ])
+        return (d && (await answerFromBoard($, tool, args, opened, d))) ?? (await run)
+      } finally {
+        await closeAsk($, opened)
+      }
+    } finally {
+      pending.delete(call)
+    }
+  })
+  on('session.start', async ($, e, next) => {
+    await mapTaskList($, e.cwd)
+    return next(e)
+  })
+  on('agent.spawn', async ($, e, next) => {
+    const result = await next(e)
+    if (result.agentId) await agentStarted($, result.agentId, e.subagentType, e.name)
+    return result
+  })
+  // An interrupted turn fires no Stop hook, so it does not mark the session unread either.
+  on('turn.complete', async ($, e, next) => {
+    if (e.agentId) await agentStopped($, e.agentId, e.answer)
+    else if (!e.isAborted) await markStopped($)
+    return next(e)
+  })
+  // Managed settings bypass user-tier mods on classic.* (cc-plugin-sec-default), so this one
+  // has no effect there; there is no native teammate-idle event to use instead.
+  on('classic.TeammateIdle', async ($, e, next) => {
+    await teammateIdle($, e.teammate_name, e.agent_id, e.agent_type)
+    return next(e)
+  })
+}

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

@@ -0,0 +1,77 @@
+import type { EngineInterface, ModelUsage, Register, SessionMeasureInput } from 'claude-code'
+
+type Measure = Pick<SessionMeasureInput, 'context' | 'rateLimits' | 'cost'>
+
+export function displayName(model: string) {
+  const m = /^claude-([a-z]+)-(\d+)(?:-(\d{1,2})(?!\d))?/.exec(model)
+  if (!m?.[1]) return model
+  const family = m[1][0]!.toUpperCase() + m[1].slice(1)
+  return `${family} ${m[3] ? `${m[2]}.${m[3]}` : m[2]}`
+}
+
+const toEpochSeconds = (iso?: string) => (iso ? Math.floor(Date.parse(iso) / 1000) : undefined)
+
+// The board reads the statusLine's JSON shape, so the file keeps its field names.
+export function toStatus(model: string, m: Measure, usage: ModelUsage | undefined) {
+  const { context } = m
+  return {
+    model: { id: model, display_name: displayName(model) },
+    cost: { total_cost_usd: m.cost?.usd ?? 0 },
+    context_window: {
+      total_input_tokens: context.tokens ?? 0,
+      context_window_size: context.window,
+      current_usage: usage ?? null,
+      used_percentage: context.percent ?? null,
+    },
+    rate_limits: Object.fromEntries(
+      m.rateLimits.map(r => [r.kind, { used_percentage: r.percentUsed, resets_at: toEpochSeconds(r.resetsAt) }]),
+    ),
+  }
+}
+
+export const cckRoot = (configDir?: string, home?: string, userProfile?: string) =>
+  configDir ? `${configDir}/.cck` : `${home ?? userProfile}/.claude/.cck`
+
+let cck: Promise<string> | undefined
+
+function cckDir($: EngineInterface) {
+  cck ??= Promise.all([$.env.get('CLAUDE_CONFIG_DIR'), $.env.get('HOME'), $.env.get('USERPROFILE')]).then(
+    ([configDir, home, userProfile]) => cckRoot(configDir, home, userProfile),
+  )
+  return cck
+}
+
+let lastUsage: ModelUsage | undefined
+let lastModel: string | undefined
+const lastWritten = new Map<string, 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))
+  const file = `${dir}/context-status/${sessionId}.json`
+  if (lastWritten.get(file) === text) return
+  await $.fs.write(file, text)
+  lastWritten.set(file, text)
+}
+
+export const register: Register = on => {
+  on('turn.step', async function* ($, e, next) {
+    const result = yield* next(e)
+    if (e.agentId === undefined && result.usage) {
+      const { model, ...usage } = result.usage
+      lastUsage = usage
+      lastModel = model
+      await write($, await $.session.usage())
+    }
+    return result
+  })
+
+  on('session.measure', async ($, e, next) => {
+    await write($, e)
+    return next(e)
+  })
+}

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

@@ -1,95 +1,3 @@
 {
-  "hooks": {
-    "SessionStart": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "\"${CLAUDE_PLUGIN_ROOT}/scripts/agent-spy.sh\"",
-            "shell": "bash",
-            "timeout": 5
-          }
-        ]
-      }
-    ],
-    "SubagentStart": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "\"${CLAUDE_PLUGIN_ROOT}/scripts/agent-spy.sh\"",
-            "shell": "bash",
-            "timeout": 5
-          }
-        ]
-      }
-    ],
-    "SubagentStop": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "\"${CLAUDE_PLUGIN_ROOT}/scripts/agent-spy.sh\"",
-            "shell": "bash",
-            "timeout": 30
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "\"${CLAUDE_PLUGIN_ROOT}/scripts/agent-spy.sh\"",
-            "shell": "bash",
-            "timeout": 5
-          }
-        ]
-      }
-    ],
-    "TeammateIdle": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "\"${CLAUDE_PLUGIN_ROOT}/scripts/agent-spy.sh\"",
-            "shell": "bash",
-            "timeout": 5
-          }
-        ]
-      }
-    ],
-    "PermissionRequest": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "\"${CLAUDE_PLUGIN_ROOT}/scripts/approval-gate.sh\"",
-            "shell": "bash",
-            "timeout": 86400
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "\"${CLAUDE_PLUGIN_ROOT}/scripts/agent-spy.sh\"",
-            "shell": "bash",
-            "timeout": 5
-          }
-        ]
-      }
-    ]
-  }
+  "modules": ["./index.ts"]
 }

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

@@ -0,0 +1,8 @@
+import type { Register } from 'claude-code'
+import { register as activity } from './activity'
+import { register as context } from './context'
+
+export const register: Register = (on, options) => {
+  context(on, options)
+  activity(on, options)
+}

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

@@ -4,11 +4,5 @@
     "description": "Notifies this session when its tasks are moved on the kanban board or the user sends it review comments.",
     "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/postman.js\"",
     "when": "on-skill-invoke:claude-code-kanban:follow"
-  },
-  {
-    "name": "kanban-dispatch-inbox",
-    "description": "Notifies this session when a session it dispatched through cck reports or exits.",
-    "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/postman.js\" --topic dispatch --keep-backlog",
-    "when": "on-skill-invoke:claude-code-kanban:dispatch"
   }
 ]