claude-code-kanban 7.16.0 → 7.18.0

package/README.md

@@ -8,58 +8,45 @@ Start, watch and answer Claude Code sessions from one live board, with a termina
 
 **[Documentation](https://nikiforovall.blog/claude-code-kanban/)**
 
-<a href="https://youtu.be/QbvDBFyfC7s">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="website/public/video/cck-dark.webp">
-    <img alt="Claude Code Kanban tour video (74 seconds). Opens on YouTube." src="website/public/video/cck-light.webp">
-  </picture>
-</a>
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="website/public/shots/themes/ember-01-board-session-log-dark.webp">
+  <img alt="The board with the session list, task columns, the agents log and the session log of tool calls." src="website/public/shots/themes/ember-01-board-session-log-light.webp">
+</picture>
 
-Watch the tour on YouTube: [light](https://youtu.be/QbvDBFyfC7s), [dark](https://youtu.be/bXZ4_QCmD7k).
+<table>
+  <tr>
+    <td width="33%"><picture><source media="(prefers-color-scheme: dark)" srcset="website/public/shots/themes/ember-terminal-dark.webp"><img alt="The embedded terminal with a show card checklist next to it." src="website/public/shots/themes/ember-terminal-light.webp"></picture></td>
+    <td width="33%"><picture><source media="(prefers-color-scheme: dark)" srcset="website/public/shots/themes/ember-13b-split-view-dark.webp"><img alt="The board split with an HTML preview pane." src="website/public/shots/themes/ember-13b-split-view-light.webp"></picture></td>
+    <td width="33%"><picture><source media="(prefers-color-scheme: dark)" srcset="website/public/shots/themes/ember-14b-show-chart-dark.webp"><img alt="A show card with a spend chart over the terminal." src="website/public/shots/themes/ember-14b-show-chart-light.webp"></picture></td>
+  </tr>
+  <tr>
+    <td align="center">Embedded terminal</td>
+    <td align="center">Panes and split view</td>
+    <td align="center">Show cards</td>
+  </tr>
+</table>
+
+Watch the 74-second tour on YouTube: [light](https://youtu.be/QbvDBFyfC7s), [dark](https://youtu.be/bXZ4_QCmD7k).
 
 ## Getting started
 
 You need Node.js 20 or later and the `claude` CLI.
 
-### 1. Install the command
-
-```bash
-npm install -g claude-code-kanban
-```
-
-To update, run the same command again.
-
-To try it without an install, run `npx claude-code-kanban --open`. npx keeps a copy of each version in its cache and can run an old copy, so use the global install to keep the board and to update it.
-
-### 2. Install the integration (one time)
-
-```bash
-claude-code-kanban --install
-```
-
-The installer adds a Claude Code plugin with hooks, skills and a mod for context use and cost (Claude Code 2.1.287 or later). It asks before it installs and keeps your other settings. Without the hooks, the board shows tasks only: no agent log, no live activity, no waiting prompts.
-
-To remove it, run `claude-code-kanban --uninstall`. For another Claude config dir, pass the same `--dir=<path>` (or set `CLAUDE_CONFIG_DIR`) to `--install`, `--uninstall` and the server. See [Getting started](https://nikiforovall.blog/claude-code-kanban/getting-started/) for each install step.
+### 1. Run it in Claude Code Hub
 
-### 3. Start the board
+[Claude Code Hub](https://nikiforovall.blog/claude-code-hub/) runs the board as a tab next to Cost, Marketplace and Memory, in one window with keyboard switching. The embedded terminal is on by default, and the board opens a session's cost, plugins and memory in the other tabs.
 
 ```bash
-claude-code-kanban --open
+npm install -g claude-code-hub
+claude-code-hub --install   # one time: installs this board's plugin
+claude-code-hub --open
 ```
 
-The board runs at `http://localhost:3541`.
+The hub runs at `http://localhost:3540`. See [Claude Code Hub](https://nikiforovall.blog/claude-code-kanban/guides/claude-code-hub/) for how the board works there. To run the board without the hub, see [Appendix: run the board standalone](#appendix-run-the-board-standalone).
 
-### 4. Use Claude Code as usual
+### 2. Use Claude Code as usual
 
-Run `claude` in any project. You do not configure anything per project. Claude Code writes task files and transcripts to the config dir, and the board watches them and sends each change to the browser.
-
-> **Empty board?** Claude Code ships the task tools off by default on some models, so Claude writes no tasks. Turn them on in the `env` block of Claude Code `settings.json`, then restart Claude Code:
->
-> ```json
-> { "env": { "CLAUDE_CODE_ENABLE_TODO_TOOLS": "true" } }
-> ```
->
-> You can also add a task by hand with **Add task** in the Pending column.
+Run `claude` in any project. You do not configure anything per project. Claude Code writes task files and transcripts to the config dir, and the board watches them and sends each change to the browser. If the board stays empty, see [Appendix: empty board](#appendix-empty-board).
 
 ## Features
 
@@ -133,7 +120,45 @@ EDITOR="code -w" claude-code-kanban        # Command for Open in editor (default
 
 See [Configuration](https://nikiforovall.blog/claude-code-kanban/reference/configuration/) for every setting, and [Troubleshooting](https://nikiforovall.blog/claude-code-kanban/troubleshooting/) for common problems.
 
-Claude Code Kanban also runs as a tab in [Claude Code Hub](https://nikiforovall.blog/claude-code-kanban/guides/claude-code-hub/), where the terminal is on by default.
+## Appendix: run the board standalone
+
+### 1. Install the command
+
+```bash
+npm install -g claude-code-kanban
+```
+
+To update, run the same command again.
+
+To try it without an install, run `npx claude-code-kanban --open`. npx keeps a copy of each version in its cache and can run an old copy, so use the global install to keep the board and to update it.
+
+### 2. Install the integration (one time)
+
+```bash
+claude-code-kanban --install
+```
+
+The installer adds a Claude Code plugin with hooks, skills and a mod for context use and cost (Claude Code 2.1.287 or later). It asks before it installs and keeps your other settings. Without the hooks, the board shows tasks only: no agent log, no live activity, no waiting prompts.
+
+To remove it, run `claude-code-kanban --uninstall`. For another Claude config dir, pass the same `--dir=<path>` (or set `CLAUDE_CONFIG_DIR`) to `--install`, `--uninstall` and the server. See [Getting started](https://nikiforovall.blog/claude-code-kanban/getting-started/) for each install step.
+
+### 3. Start the board
+
+```bash
+claude-code-kanban --open
+```
+
+The board runs at `http://localhost:3541`. Then use Claude Code as usual.
+
+## Appendix: empty board
+
+Claude Code ships the task tools off by default on some models, so Claude writes no tasks. Turn them on in the `env` block of Claude Code `settings.json`, then restart Claude Code:
+
+```json
+{ "env": { "CLAUDE_CODE_ENABLE_TODO_TOOLS": "true" } }
+```
+
+You can also add a task by hand with **Add task** in the Pending column.
 
 ## License
 

package/hub-app.json

@@ -5,6 +5,29 @@
   "icon": "columns",
   "run": { "entry": "server.js", "defaultPort": 3541 },
   "publishes": ["session.changed"],
+  "settings": [
+    {
+      "key": "zenCentered",
+      "type": "boolean",
+      "label": "Center zen mode",
+      "help": "In zen mode, centers the session card and its panel in the sidebar's height.",
+      "default": false
+    },
+    {
+      "key": "zenPattern",
+      "type": "choice",
+      "label": "Zen mode pattern",
+      "help": "In zen mode, fills the sidebar's free space with a pattern tinted by the session's state.",
+      "options": [
+        { "value": "none", "label": "None" },
+        { "value": "dots", "label": "Dots" },
+        { "value": "diagonal", "label": "Diagonal" },
+        { "value": "rings", "label": "Rings" },
+        { "value": "grid", "label": "Grid" }
+      ],
+      "default": "dots"
+    }
+  ],
   "keys": { "keeps": ["ctrl+alt+1", "ctrl+alt+2", "ctrl+alt+3", "ctrl+alt+4", "ctrl+alt+5", "ctrl+alt+6", "ctrl+alt+7", "ctrl+alt+8", "ctrl+alt+9", "ctrl+alt+n", "ctrl+alt+r", "ctrl+alt+s", "ctrl+shift+d", "ctrl+shift+k", "ctrl+shift+l", "ctrl+shift+m", "ctrl+shift+p", "ctrl+shift+z"] },
   "plugin": {
     "marketplace": "plugin",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "7.16.0",
+  "version": "7.18.0",
   "description": "A web-based Kanban board for viewing Claude Code tasks with agent teams support",
   "main": "server.js",
   "type": "commonjs",
@@ -39,6 +39,7 @@
     "@xterm/addon-fit": "0.11.0",
     "@xterm/addon-serialize": "0.14.0",
     "@xterm/addon-unicode11": "0.9.0",
+    "@xterm/addon-web-links": "0.12.0",
     "@xterm/addon-webgl": "0.19.0",
     "@xterm/headless": "6.0.0",
     "@xterm/xterm": "6.0.0",

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

@@ -1,5 +1,5 @@
 {
   "name": "claude-code-kanban",
-  "version": "3.7.11",
+  "version": "3.7.14",
   "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/hooks/activity.ts

@@ -150,14 +150,19 @@ async function markStopped($: EngineInterface) {
 
 // The name map lets TeammateIdle, which names the teammate, find its agent id. The prompt is on
 // the start line because a resume runs a new prompt, and the server's own lookup finds the first.
-async function agentStarted($: EngineInterface, e: AgentSpawnInput, agentId: string, model: string) {
+async function agentStarted(
+  $: EngineInterface,
+  e: Partial<Pick<AgentSpawnInput, 'subagentType' | 'prompt' | 'description' | 'name'>>,
+  agentId: string,
+  model?: string,
+) {
   const dir = await sessionDir($)
   const ts = new Date().toISOString()
   await Promise.all([
     appendLine($, `${dir}/${agentId}.jsonl`, {
       agentId,
       type: e.subagentType,
-      model,
+      ...(model && { model }),
       event: 'start',
       status: 'active',
       ...(e.prompt && { prompt: e.prompt }),
@@ -169,6 +174,27 @@ async function agentStarted($: EngineInterface, e: AgentSpawnInput, agentId: str
   ])
 }
 
+// A forked skill fires no agent.spawn, but $.agent.list() names it; internal loops (compaction,
+// memory) and workflow agents it does not. A spawned agent's turn.start runs inside its spawn's
+// next(), and a second start line would reset the server's fold, so turn.start leaves the agents
+// of a spawn in flight to the spawn; turn.complete catches a fork that started in that window.
+const tracked = new Map<string, Promise<void>>()
+let spawning = 0
+
+function trackAgent($: EngineInterface, agentId: string, prompt?: string) {
+  const found = tracked.get(agentId) ?? startUnspawned($, agentId, prompt).catch(() => {})
+  tracked.set(agentId, found)
+  return found
+}
+
+async function startUnspawned($: EngineInterface, agentId: string, prompt?: string) {
+  if (await $.fs.exists(`${await sessionDir($)}/${agentId}.jsonl`)) return
+  const agent = (await $.agent.list()).find(a => a.id === agentId)
+  if (!agent) return
+  const { type: subagentType, description, name } = agent
+  await agentStarted($, { subagentType, description, name, prompt }, 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()
@@ -251,13 +277,26 @@ export const register: Register = on => {
     return next(e)
   })
   on('agent.spawn', async ($, e, next) => {
-    const result = await next(e)
-    if (result.agentId) await agentStarted($, e, result.agentId, result.model)
-    return result
+    spawning++
+    try {
+      const result = await next(e)
+      if (result.agentId) await agentStarted($, e, result.agentId, result.model)
+      return result
+    } finally {
+      spawning--
+    }
+  })
+  on('turn.start', async ($, e, next) => {
+    if (e.agentId && !spawning) await trackAgent($, e.agentId, e.text || undefined)
+    return next(e)
   })
   // 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)
+    if (e.agentId) {
+      await trackAgent($, e.agentId)
+      tracked.delete(e.agentId)
+      await agentStopped($, e.agentId, e.answer)
+    }
     else if (!e.isAborted) await markStopped($)
     return next(e)
   })

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

@@ -1,8 +1,8 @@
 import type { EngineInterface, Register } from 'claude-code'
 import { cckRoot } from './context'
+import { boardUrl } from './doorbell'
 
 export const TOOL = 'mcp__claude-code-kanban__show'
-export const SKILL_LINE = /^\s*-\s*claude-code-kanban:show(?=:|\s*$)/
 
 type ShowInput = { title: string; key?: string; kind?: 'markdown' | 'html'; file?: string; base?: string }
 type Shown = { title: string; key?: string | null; index: number; count: number; path?: string | null }
@@ -16,13 +16,6 @@ export function shownText({ title, key, index, count, path }: Shown, claim = fal
   return claim ? `Card ${at} is ready. Write it to ${path}; the card refreshes on each save.` : `Shown ${at}`
 }
 
-export function dropSkillLine(listing: string) {
-  return listing
-    .split('\n')
-    .filter(l => !SKILL_LINE.test(l))
-    .join('\n')
-}
-
 let cck: Promise<string> | undefined
 
 function cckDir($: EngineInterface) {
@@ -62,64 +55,111 @@ function errorText(status: number, text: string) {
   return `cck answered HTTP ${status}`
 }
 
-async function post($: EngineInterface, input: ShowInput) {
-  const t = await terminal($)
-  if (!t) return { deny: 'The overlay needs a Claude Code session started in the cck terminal.' }
-  const token = await terminalToken($, t.url)
-  if (!token) return { deny: `No terminal token for the cck server at ${t.url}. It must run with the terminal enabled.` }
-  const { title, key, kind, file, base } = input
-  const body = JSON.stringify({ sessionId: await $.session.id(), title, key, kind, file, base })
-  let res: Awaited<ReturnType<EngineInterface['http']['fetch']>>
+async function send(
+  $: EngineInterface,
+  url: string,
+  path: string,
+  headers: Record<string, string>,
+  body: unknown,
+): Promise<{ text: string } | { deny: string }> {
   try {
-    res = await $.http.fetch(`${t.url}/api/terminals/${encodeURIComponent(t.terminalId)}/show`, {
+    const res = await $.http.fetch(`${url}${path}`, {
       method: 'POST',
-      headers: { 'content-type': 'application/json', 'x-terminal-token': token },
-      body,
+      headers: { 'content-type': 'application/json', ...headers },
+      body: JSON.stringify(body),
     })
+    return res.ok ? { text: res.text } : { deny: errorText(res.status, res.text) }
   } catch (err) {
-    return { deny: `Cannot reach cck at ${t.url}: ${err instanceof Error ? err.message : String(err)}` }
+    return { deny: `Cannot reach cck at ${url}: ${err instanceof Error ? err.message : String(err)}` }
   }
-  if (!res.ok) return { deny: errorText(res.status, res.text) }
+}
+
+async function post($: EngineInterface, t: { url: string; terminalId: string }, input: ShowInput) {
+  const token = await terminalToken($, t.url)
+  if (!token) return { deny: `No terminal token for the cck server at ${t.url}. It must run with the terminal enabled.` }
+  const { title, key, kind, file, base } = input
+  const body = { sessionId: await $.session.id(), title, key, kind, file, base }
+  const res = await send($, t.url, `/api/terminals/${encodeURIComponent(t.terminalId)}/show`, { 'x-terminal-token': token }, body)
+  if ('deny' in res) return res
   return { result: shownText(JSON.parse(res.text) as Shown, file == null) }
 }
 
+// Read on every post, as the doorbell does, so a board that restarted on another port is found.
+async function findBoard($: EngineInterface) {
+  try {
+    return boardUrl(undefined, await $.fs.read(`${await cckDir($)}/server.json`))
+  } catch {
+    return undefined
+  }
+}
+
+export const CLAIM_OFF_TERMINAL =
+  'No overlay here: write the card to a markdown or HTML file in your scratchpad directory, then call show again with file.'
+
+export function paneText(title: string, added: boolean) {
+  return added
+    ? `Added "${title}" as a tab of this session on the cck board, in the background. Tell the user it waits there; the tab refreshes on each save.`
+    : `The board already has a tab for this file; it refreshes on each save.`
+}
+
+async function postPane($: EngineInterface, { title, file }: ShowInput) {
+  if (file == null) return { result: CLAIM_OFF_TERMINAL }
+  const [url, sessionId] = await Promise.all([findBoard($), $.session.id()])
+  if (!url) return { deny: 'The cck board is not running. Ask the user to start it, or give them the file path.' }
+  const res = await send($, url, `/api/panes/${encodeURIComponent(sessionId)}`, {}, { target: file, title, show: true })
+  if ('deny' in res) return res
+  const { added } = JSON.parse(res.text) as { added: boolean }
+  return { result: paneText(title, added) }
+}
+
+const WHEN =
+  'Post one when the user asks you to show, draw or visualize something, or when your answer is a comparison of 4 or more rows, a flow, or numbers over time. Pick the form that makes the point best: a table, chart, diagram, mockup, small widget or a mix.'
+
+const FILE = { type: 'string', description: 'Absolute path of an existing markdown, HTML, image or text file' }
+
+const PANE_TOOL = {
+  description: `Show a card as a tab of this session on the cck board. ${WHEN} Write the card to a markdown or HTML file in your scratchpad directory, then pass it as file; post again after a new file, and edit the same file to update its tab, which refreshes on each save. For an HTML card, load the claude-code-kanban:show skill first for the HTML contract. The tab opens in the background: in your reply, say what the card shows and that it waits on the board.`,
+  inputSchema: {
+    type: 'object',
+    properties: { title: { type: 'string', description: 'Tab title' }, file: FILE },
+    required: ['title', 'file'],
+  },
+}
+
+const OVERLAY_TOOL = {
+  description: `Show a card in the cck overlay above this terminal. ${WHEN} Give each card a key that names what it shows (for example latency-chart), and post again with that key to update the card in place instead of adding a new one. Without file, the tool answers with a path: write the card there with Write, and change it with Edit; the card refreshes on each save. Pass file to show a file that already exists. To explain code with a call stack or a tree, load the claude-code-kanban:show skill first for the notation. The user sees the rendered card and knows you do not; in your reply, say what the card shows, and take the render as given.`,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      title: { type: 'string', description: 'Card title' },
+      kind: {
+        type: 'string',
+        enum: ['markdown', 'html'],
+        description:
+          'markdown (default): mermaid, diff and code fences render. html: a body fragment; load the claude-code-kanban:show skill first for the HTML contract',
+      },
+      file: FILE,
+      key: { type: 'string', description: 'Card name: the same key replaces the card in place and keeps its file' },
+      base: {
+        type: 'string',
+        description:
+          "Absolute path of the folder that the card's path:line links resolve against, usually the repo root. Always pass it with a call stack. Without it, links resolve against the session cwd, which is wrong for a worktree or another repo",
+      },
+    },
+    required: ['title'],
+  },
+}
+
 // A -p run is detached from the terminal, so only an interactive session gets the tool.
 export const register: Register = on => {
   on('session.start', { isInteractive: true }, async ($, e, next) => {
-    if (await terminal($)) {
-      await $.tool.register({
-        name: 'show',
-        description:
-          'Show a card in the cck overlay above this terminal. Post one when the user asks you to show, draw or visualize something, or when your answer is a comparison of 4 or more rows, a flow, or numbers over time. Pick the form that makes the point best: a table, chart, diagram, mockup, small widget or a mix. Give each card a key that names what it shows (for example latency-chart), and post again with that key to update the card in place instead of adding a new one. Without file, the tool answers with a path: write the card there with Write, and change it with Edit; the card refreshes on each save. Pass file to show a file that already exists. To explain code with a call stack or a tree, load the claude-code-kanban:show skill first for the notation. The user sees the rendered card and knows you do not; in your reply, say what the card shows, and take the render as given.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            title: { type: 'string', description: 'Card title' },
-            kind: {
-              type: 'string',
-              enum: ['markdown', 'html'],
-              description:
-                'markdown (default): mermaid, diff and code fences render. html: a body fragment; load the claude-code-kanban:show skill first for the HTML contract',
-            },
-            file: { type: 'string', description: 'Absolute path of an existing markdown, HTML, image or text file' },
-            key: { type: 'string', description: 'Card name: the same key replaces the card in place and keeps its file' },
-            base: {
-              type: 'string',
-              description:
-                "Absolute path of the folder that the card's path:line links resolve against, usually the repo root. Always pass it with a call stack. Without it, links resolve against the session cwd, which is wrong for a worktree or another repo",
-            },
-          },
-          required: ['title'],
-        },
-      })
-    }
+    await $.tool.register({ name: 'show', ...((await terminal($)) ? OVERLAY_TOOL : PANE_TOOL) })
     return next(e)
   })
 
-  on('tool.call', { tool: TOOL }, async ($, e) => post($, e as unknown as ShowInput))
-
-  on('prompt.attachment', { type: 'skill_listing' }, async ($, e, next) => {
-    if (await terminal($)) return next(e)
-    return next({ ...e, text: dropSkillLine(e.text) })
+  on('tool.call', { tool: TOOL }, async ($, e) => {
+    const input = e as unknown as ShowInput
+    const t = await terminal($)
+    return t ? post($, t, input) : postPane($, input)
   })
 }

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

@@ -46,6 +46,7 @@ Every exhibit, ready or new, keeps these:
 - Colors come from the tokens on every draw, in canvas too, so a theme change needs no extra code.
 - Nothing runs while the reader does nothing, except a running model that is on screen.
 - Numbers from a model are marked as model numbers.
+- When the reader's choice should come back to the session, such as quiz answers or a pick, wrap the inputs in `<form data-cck-submit="<name>">`, or put `data-cck-action="<name>"` on one button. It works in a board pane: the session gets the fields as its next prompt. The board sends only on a real click. Give `type="button"` to buttons that must not send, and call `preventDefault` on the submit so the page also works outside cck.
 - The script goes at the end of `<body>`; its CSS goes in the second `<style>`.
 
 ## Blocks

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

@@ -1,4 +1,4 @@
-import type { On, ToolCallArgs, ToolCheckDecision } from 'claude-code'
+import type { AgentInfo, On, ToolCallArgs, ToolCheckDecision } from 'claude-code'
 import { type Engine, expect, type MockClock, mock, test } from 'claude-code/testing'
 import { BOARD_ALLOWED, CLEARED } from '../hooks/activity'
 
@@ -7,11 +7,20 @@ const SESSION = `${ROOT}/sid-1`
 const MARKER = `${SESSION}/_waiting.json`
 const CONFIG = 'C:/cfg/.cck/config.json'
 
-type EngineOptions = { decision?: ToolCheckDecision; rule?: string; env?: Record<string, string> }
+type EngineOptions = {
+  decision?: ToolCheckDecision
+  rule?: string
+  env?: Record<string, string>
+  agents?: AgentInfo[]
+}
 
-// A test hook cannot raise tool.check, so the test raises it (askFor), and the engine's tool.call
-// holds the first call until the test answers the terminal prompt.
-function engine(on: On, files: Record<string, string>, { decision = 'allow', rule, env = {} }: EngineOptions = {}) {
+// The engine raises tool.check inside the call, and its ask waits in classic.PermissionRequest
+// until the test answers the terminal prompt.
+function engine(
+  on: On,
+  files: Record<string, string>,
+  { decision = 'allow', rule, env = {}, agents = [] }: EngineOptions = {},
+) {
   const writes: { path: string; text: string }[] = []
   const runs: unknown[] = []
   const status: (string | undefined)[] = []
@@ -38,29 +47,28 @@ function engine(on: On, files: Record<string, string>, { decision = 'allow', rul
     return { value: undefined }
   })
   on('tool.check', () => ({ decision, rule }))
-  let held = decision === 'ask'
   on('tool.call', async (_$, e) => {
     const { tool, tool_use_id, agentId, ...input } = e
-    if (held) {
-      held = false
-      await terminal
-    }
     runs.push(input)
     return { result: { stdout: 'ok' } }
   })
   on('session.start', (_$, e) => ({ cwd: e.cwd }))
   on('agent.spawn', () => ({ model: 'haiku', agentId: 'a1' }))
+  on('agent.list', () => ({ value: agents }))
+  on('fs.exists', (_$, e) => ({ value: norm(e.path) in files }))
+  on('turn.start', (_$, e) => ({ turnId: e.turnId }))
   on('turn.complete', (_$, e) => ({ text: e.answer }))
+  on('classic.PermissionRequest', async () => {
+    await terminal
+    return { decision: { behavior: 'allow' as const } }
+  })
   on('classic.*', () => ({}))
   return { writes, runs, status, answer }
 }
 
 async function askFor($: Engine, clock: MockClock, args: { tool: string } & Record<string, unknown>) {
-  const { tool, ...input } = args
   const call = $.tool.call(args as ToolCallArgs)
   await clock.settle()
-  await $.tool.check({ tool, input })
-  await clock.settle()
   return { call }
 }
 
@@ -305,6 +313,64 @@ test('a finished loop that was never spawned writes nothing', async ($, on) => {
   expect(writes).toEqual([])
 })
 
+const forked: AgentInfo = {
+  id: 'f1',
+  type: 'general-purpose',
+  description: '/code-review high',
+  status: 'running',
+  name: 'code-review',
+}
+
+test('a forked skill is recorded at its turn start and stopped at its end', async ($, on) => {
+  const files: Record<string, string> = {}
+  engine(on, files, { agents: [forked] })
+
+  await $.turn.start({ text: 'review the MR', turnId: 't', agentId: 'f1' })
+  await $.turn.complete(turn({ agentId: 'f1', answer: 'review done' }))
+
+  const all = lines(files[`${SESSION}/f1.jsonl`])
+  expect(all.map(l => l.event)).toEqual(['start', 'stop'])
+  expect(all[0]).toMatchObject({
+    agentId: 'f1',
+    type: 'general-purpose',
+    description: '/code-review high',
+    prompt: 'review the MR',
+  })
+  expect('model' in all[0]).toBe(false)
+  expect(all[1]).toMatchObject({ status: 'stopped', lastMessage: 'review done' })
+  expect(files[`${SESSION}/_name-code-review.id`]).toBe('f1')
+})
+
+test('a forked skill whose start no hook heard is recorded at its end', async ($, on) => {
+  const files: Record<string, string> = {}
+  engine(on, files, { agents: [{ ...forked, id: 'f2' }] })
+
+  await $.turn.complete(turn({ agentId: 'f2' }))
+
+  expect(lines(files[`${SESSION}/f2.jsonl`]).map(l => l.event)).toEqual(['start', 'stop'])
+})
+
+test('a spawned subagent turn start adds no second start line', async ($, on) => {
+  const files: Record<string, string> = {}
+  engine(on, files, { agents: [{ ...forked, id: 'a1' }] })
+
+  await $.agent.spawn(spawn('general-purpose'))
+  await $.turn.start({ text: 'p', turnId: 't', agentId: 'a1' })
+
+  expect(lines(files[`${SESSION}/a1.jsonl`]).map(l => l.event)).toEqual(['start'])
+})
+
+test('a turn start inside its spawn leaves the start line to the spawn', async ($, on) => {
+  const files: Record<string, string> = {}
+  engine(on, files, { agents: [{ ...forked, id: 'a1' }] })
+
+  await Promise.all([$.agent.spawn(spawn('general-purpose')), $.turn.start({ text: 'p', turnId: 't', agentId: 'a1' })])
+
+  const all = lines(files[`${SESSION}/a1.jsonl`])
+  expect(all.map(l => l.event)).toEqual(['start'])
+  expect(all[0]).toMatchObject({ model: 'haiku' })
+})
+
 test('a named spawn maps the name, and TeammateIdle finds the agent by it', async ($, on) => {
   const files: Record<string, string> = {}
   engine(on, files)

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

@@ -23,6 +23,7 @@ function engine(on: On, replies: (() => Reply)[], submit?: () => Promise<unknown
   on('env.get', (_$, e) => ({ value: { CLAUDE_CONFIG_DIR: 'C:/cfg' }[e.name] }))
   on('session.id', () => ({ value: sessionId }))
   on('session.start', (_$, e) => ({ cwd: e.cwd }))
+  on('tool.register', (_$, e) => ({ value: { tool: `mcp__claude-code-kanban__${e.name}` } }))
   on('http.fetch', async (_$, e) => {
     urls.push(e.url)
     const reply = replies.shift()