Skip to content
Back to search

kaidoplan-plugin

KaidoPlan plugin for Claude Code — MCP server + slash commands + TaskCompleted write-back hook. Source of truth: cygnusyang/KaidoPlan Plugins/

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/cygnusyang--kaidoplan-plugin/badge.svg)](/listings/cygnusyang--kaidoplan-plugin)

HTML

<a href="/listings/cygnusyang--kaidoplan-plugin"><img src="/api/listings/cygnusyang--kaidoplan-plugin/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 450 lines
  1. # KaidoPlan for AI agents
  2. > **One entry for every MCP host** — the table and the merge script below serve Cursor, Gemini CLI, VS Code, WorkBuddy and any other stdio client; `tools/list` = 21.
  3. **English** · [简体中文](README.zh-CN.md)
  4. > **Source of truth:** the `Plugins/` directory of the main development repository (kept private) is the source; this repo is the standalone install target for the Claude Code plugin, so issues and PRs go here.
  5. > Two audiences: ① you want an AI to break down a WBS, produce a schedule and track progress; ② you want to wire KaidoPlan into an agent (Claude Code / Codex / Cursor / Gemini CLI / VS Code / CodeBuddy / WorkBuddy).
  6. > The walkthrough in this page was run against KaidoPlan v0.9.1 release binaries on macOS (2026-10-25); the MCP contract itself (`initialize` → `protocolVersion 2024-11-05`, `tools/list` → **21 tools**) was re-verified on 2026-11-16 against v3.11.x. Host-side configuration follows each vendor's documented format — see "Scope of verification" at the end.
  7. ## Compatibility: one MCP server, many hosts
  8. `kaidoplan-mcp` is a plain **stdio JSON-RPC MCP server** — no SDK, no framework, no host-specific dialect. Anything that speaks MCP over stdio can drive it. A plugin/hook is convenience layered on top, never extra capability:
  9. | Host | How to connect | Config drop | Extras in this repo |
  10. |---|---|---|---|
  11. | Claude Code | MCP, or the full plugin | `.mcp.json` | plugin: 3 slash commands + `TaskCompleted` write-back hook |
  12. | Codex CLI | MCP | `~/.codex/config.toml` | rules block in `AGENTS.md` |
  13. | Cursor | MCP | `~/.cursor/mcp.json` or `.cursor/mcp.json` | rules block in `AGENTS.md` / `.cursor/rules/` |
  14. | Gemini CLI | MCP | `~/.gemini/settings.json` or `.gemini/settings.json` | rules block in `GEMINI.md` / `AGENTS.md` |
  15. | VS Code (Copilot harness) | MCP | `.mcp.json` (workspace root) or `~/.copilot/mcp-config.json` | rules block in `AGENTS.md` / `.github/copilot-instructions.md` |
  16. | CodeBuddy | MCP | `.mcp.json` | rules block in `CODEBUDDY.md` |
  17. | WorkBuddy | MCP | `~/.workbuddy/mcp.json` | rules block in `CODEBUDDY.md` / `AGENTS.md` |
  18. | Anything else | MCP over stdio | your client's own file | — |
  19. Config file names and schemas belong to each vendor; the snippets below follow their current documentation. Two things are exercised by this repository itself: the stdio probe (§2) and the Claude Code plugin hook (its tests).
  20. ## 0. Division of labour, in one table
  21. | Role | Does | Does not |
  22. |---|---|---|
  23. | AI agent | Reads the requirement, breaks it down, estimates, writes code, writes status back | No long-term memory, does not keep the ledger |
  24. | KaidoPlan | Stores the WBS and dependencies, computes the schedule, lists violations and the critical path, aggregates progress | Does not write code, does not make technical calls for the AI |
  25. | Human | Sets the boundaries (dates, acceptance criteria), reviews the Gantt and violations, intervenes | Does not babysit individual tasks |
  26. KaidoPlan's three entry points share one write path (`KaidoPlanSession`): **21 MCP tools**, the **CLI**, and the **macOS app**. There is exactly one store: a single `.kaido` file (JSON). Agents use the first two, humans use the third.
  27. ## 1. Why only Claude Code gets a plugin
  28. A plugin is not a capability, it is a **bridge**. Three of the four pieces can be replaced by MCP/CLI; only the hook cannot:
  29. | Component | Replaceable by a generic interface? | Verdict |
  30. |---|---|---|
  31. | `.mcp.json` | Yes (project-level MCP config) | Saves one manual step |
  32. | Slash commands | Yes (a convention inside the rules file) | Convenient, not required |
  33. | `TaskCompleted` hook | **No** | The only part that is actually worth it |
  34. | Manifest / marketplace distribution | No | Only pays off when publishing externally |
  35. The hook exists to **bridge Claude Code's own task system** (TaskCreate / TaskCompleted) into KaidoPlan. Codex has no equivalent event; CodeBuddy's plugin format is a fork of Claude's (different manifest directory, different root variable names). Shipping a shell for each of them buys you "one less config step" and costs "chasing someone else's format forever".
  36. So this repository chooses:
  37. - **Claude Code**: full plugin kept (slash commands + automatic write-back hook), tested;
  38. - **Every other host** (Codex / Cursor / Gemini CLI / VS Code / CodeBuddy / WorkBuddy): no plugin — one MCP config plus a convention written into the rules file, zero maintenance.
  39. Of the three wirings, the first two steps (§2, §3) are shared; do those, then pick a host.
  40. ## 2. Shared prerequisites: build + create a project
  41. **Production install (recommended)** — one command puts both `kaidoplan` and `kaidoplan-mcp` on your PATH, no checkout needed:
  42. ```bash
  43. brew install cygnusyang/kaidoplan/kaidoplan-cli
  44. ```
  45. If you installed this way, read `"$KAIDOPLAN/.build/release/KaidoPlanCLI"` as `kaidoplan` and `"$KAIDOPLAN/.build/release/KaidoPlanMCP"` as `kaidoplan-mcp` throughout the rest of this page.
  46. > The CLI and MCP server are **KaidoPlan Pro** features: both require a valid license or subscription, otherwise they exit with code `3`.
  47. **Build from source** (Swift 5.9+, Xcode 16+):
  48. ```bash
  49. # 1) change this line: point at your KaidoPlan checkout
  50. export KAIDOPLAN="$HOME/path/to/KaidoPlan"
  51. # 2) build (MCP and CLI both come out of this one command)
  52. cd "$KAIDOPLAN" && swift build -c release
  53. # 3) create the working directory and the project file
  54. mkdir -p "$HOME/Projects/demo" && cd "$HOME/Projects/demo"
  55. "$KAIDOPLAN/.build/release/KaidoPlanCLI" project create "Demo Project" \
  56. --start 2026-11-02 --end 2026-11-20 --file demo.kaido
  57. ```
  58. The CLI picks its language from `--lang <bcp47>` → `KAIDOPLAN_LANG` → the system locale, falling back to Simplified Chinese when it cannot tell. The sample output in this page is English, so export the variable once before running along:
  59. ```bash
  60. export KAIDOPLAN_LANG=en # or append --lang en to any single command; --json is language-independent
  61. ```
  62. Successful output:
  63. ```
  64. project created: B2D0A3C3 "Demo Project"
  65. saved: /Users/you/Projects/demo/demo.kaido
  66. format version: v1
  67. ```
  68. > `--start` / `--end` are the scheduling engine's default boundaries; anything scheduled outside them is reported as a violation. Dates are always `YYYY-MM-DD`.
  69. Optional: verify the MCP server itself (two lines; you are through when you see serverInfo and tools):
  70. ```bash
  71. printf '%s\n%s\n' \
  72. '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"probe","version":"0"}}}' \
  73. '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}' \
  74. | "$KAIDOPLAN/.build/release/KaidoPlanMCP" | head -c 400
  75. ```
  76. ## 3. Shared convention: put this into the host's rules file
  77. Codex / Cursor read `AGENTS.md`, Gemini CLI reads `GEMINI.md` (or `AGENTS.md`), CodeBuddy reads `CODEBUDDY.md`, Claude Code reads `CLAUDE.md` — all at the **project root**. Replace the path with your real one:
  78. ```markdown
  79. ## KaidoPlan project management
  80. This project keeps its WBS and schedule in KaidoPlan. The project file is fixed at:
  81. /Users/you/Projects/demo/demo.kaido
  82. - Before starting, call task_list to read the current state; do not re-create tasks that already exist.
  83. - Breakdown order: milestone → group → leaf. Leaves must carry effortHours (estimate at 8 hours per person-day); groups and milestones carry no effort.
  84. - One leaf = one change that is deliverable and acceptable on its own; if it looks bigger than 3 person-days, break it further.
  85. - Right after breaking down: wbs_import, then schedule_compute. If violations_list returns anything, report it first — do not silently change deadlines or dependencies.
  86. - Whenever a task is finished, call status_update to set status to done (progress becomes 100% automatically). Do not just edit the progress number.
  87. - Task IDs accept a full UUID or a unique prefix of at least 4 characters; when a prefix is ambiguous, list the candidates and let the user choose. Never guess.
  88. - If you are only planning and not writing code, say so explicitly: "this turn only updates the KaidoPlan plan".
  89. ```
  90. This block is the **only** shared intelligence layer across the three hosts. If it must change, change it here and nowhere else — never keep a second copy.
  91. ## 4. Claude Code
  92. ### Option A: MCP only (simplest, 30 seconds)
  93. ```bash
  94. cd "$HOME/Projects/demo"
  95. cat > .mcp.json <<EOF
  96. {
  97. "mcpServers": {
  98. "kaidoplan": { "command": "$KAIDOPLAN/.build/release/KaidoPlanMCP" }
  99. }
  100. }
  101. EOF
  102. ```
  103. Then run `claude`; the first time it asks whether to trust this project's MCP server — accept. **This `.mcp.json` is shared with CodeBuddy** (§5): one config, two hosts.
  104. ### Option B: the full plugin (slash commands + automatic write-back)
  105. ```bash
  106. export KAIDOPLAN_PROJECT="$HOME/Projects/demo/demo.kaido"
  107. claude --plugin-dir "$KAIDOPLAN/Plugins/claude-code"
  108. ```
  109. | Command | What it does |
  110. |---|---|
  111. | `/kaidoplan plan <path to a requirements doc, or a description>` | read requirement → build WBS → schedule → list violations |
  112. | `/kaidoplan done <task ID or prefix>` | mark it done and report the group's progress |
  113. | `/kaidoplan status` | task table, critical path, violation summary |
  114. The plugin also registers a `TaskCompleted` hook: when a Claude Code task completes, it finds the KaidoPlan task with the **exact same title** and writes back `done`. Titles that take part in write-back must therefore be unique within the project, otherwise the hook skips (duplicate names) or marks the wrong one (same name across different work items). The hook writes the file directly, so it and the app will overwrite each other if both are open — close the app during write-back.
  115. ## 5. CodeBuddy
  116. **No plugin shell** (the format is a fork; the only gain would be skipping one config step). Two steps:
  117. ```bash
  118. # Option 1: project level (recommended, shares the file with Claude Code)
  119. cd "$HOME/Projects/demo"
  120. # skip if §4 already created .mcp.json
  121. cat > .mcp.json <<EOF
  122. { "mcpServers": { "kaidoplan": { "command": "$KAIDOPLAN/.build/release/KaidoPlanMCP" } } }
  123. EOF
  124. # Option 2: user level (visible in every project)
  125. codebuddy mcp add --scope user kaidoplan -- "$KAIDOPLAN/.build/release/KaidoPlanMCP"
  126. ```
  127. Put `CODEBUDDY.md` at the project root with the §3 block as its content. After starting `codebuddy`, the first connection to a project-level MCP server needs approval; in non-interactive mode add `--settings '{"enableAllProjectMcpServers": true}'`.
  128. Verify:
  129. ```bash
  130. codebuddy -p "use kaidoplan's task_list to list the tasks in demo.kaido, output titles and statuses only"
  131. ```
  132. ## 6. Codex
  133. Codex has no slash commands and no task-completed event to hook; it only has `config.toml` and `AGENTS.md`. So write-back relies on the **convention** (the last two bullets of §3), not on a hook.
  134. ```bash
  135. # 1) register MCP → ~/.codex/config.toml
  136. cat >> ~/.codex/config.toml <<EOF
  137. [mcp_servers.kaidoplan]
  138. command = "$KAIDOPLAN/.build/release/KaidoPlanMCP"
  139. args = []
  140. EOF
  141. # 2) put AGENTS.md at the project root with the §3 block as its content
  142. # 3) start in the project directory
  143. cd "$HOME/Projects/demo" && codex
  144. ```
  145. There is no `/kaidoplan plan` in Codex; one sentence triggers the same flow:
  146. ```
  147. Follow the KaidoPlan flow in AGENTS.md: break docs/requirements.md into a WBS, import it into
  148. demo.kaido, estimate the effort, then schedule and list violations. Update the plan only,
  149. do not write code.
  150. ```
  151. When a task is done, let it use the CLI (more controllable than MCP, and easier to double-check in a terminal):
  152. ```bash
  153. "$KAIDOPLAN/.build/release/KaidoPlanCLI" status update 3AE8 --status done \
  154. --file "$HOME/Projects/demo/demo.kaido"
  155. ```
  156. > The `codex` CLI is not on PATH on this machine (the desktop app is installed instead); the `config.toml` snippet above follows its existing `[mcp_servers.*]` structure. On first use, confirm that `codex` lists the kaidoplan tools.
  157. ## Any MCP host: one entry (Cursor · Gemini CLI · VS Code · WorkBuddy · anything else)
  158. All of them are MCP-only: same server, same 21 tools, same rules block. Nothing about the entry changes — only the file it goes into and the name of the top-level key:
  159. ```json
  160. { "mcpServers": { "kaidoplan": { "command": "kaidoplan-mcp", "args": [], "env": {} } } }
  161. ```
  162. | Host | File | Key | What to do after writing |
  163. |---|---|---|---|
  164. | Cursor | `~/.cursor/mcp.json` or `.cursor/mcp.json` | `mcpServers` | merge, never overwrite |
  165. | Gemini CLI | `~/.gemini/settings.json` or `.gemini/settings.json` | `mcpServers` | `/mcp` shows the server |
  166. | VS Code (Copilot harness) | `.mcp.json` at the workspace root, or `~/.copilot/mcp-config.json` | `mcpServers` | shares the file with Claude Code |
  167. | VS Code (Local harness, deprecated) | `.vscode/mcp.json` | `servers` | start it from the MCP view; harness removed 2027-02 |
  168. | WorkBuddy | `~/.workbuddy/mcp.json` | `mcpServers` | click **Trust** |
  169. | Anything else | your client's config | its own key | restart, then count 21 tools |
  170. One script covers every JSON host — it replaces only the `kaidoplan` key and keeps your other servers:
  171. ```bash
  172. python3 - "$HOME/.cursor/mcp.json" mcpServers <<'PY'
  173. import json, pathlib, shutil, sys
  174. path, key = pathlib.Path(sys.argv[1]).expanduser(), sys.argv[2]
  175. mcp_bin = shutil.which("kaidoplan-mcp") or "/opt/homebrew/bin/kaidoplan-mcp"
  176. path.parent.mkdir(parents=True, exist_ok=True)
  177. data = json.loads(path.read_text()) if path.exists() else {}
  178. data.setdefault(key, {})["kaidoplan"] = {"command": mcp_bin, "args": [], "env": {}}
  179. path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n")
  180. print("wrote", path)
  181. PY
  182. ```
  183. Swap the path for your host's row; pass `servers` instead of `mcpServers` only for the deprecated VS Code Local harness.
  184. Two things that trip people up:
  185. - **VS Code has two formats.** The current Copilot harness reads `mcpServers` — from the workspace-root `.mcp.json` (so VS Code, Claude Code and CodeBuddy can share one file) or from `~/.copilot/mcp-config.json`. The `servers` key in `.vscode/mcp.json` belongs to the older Local harness, deprecated and removed in February 2027.
  186. - **WorkBuddy does not auto-trust.** A newly added entry stays inert until you click **Trust** in its connector list.
  187. The table above plus the rule block in §3 is everything needed to connect; the Claude Code plugin in this repo only adds the slash commands and the write-back hook.
  188. ## 7. How to break down a WBS (the important part)
  189. ### 7.1 Three levels
  190. ```
  191. milestone (kind=milestone, zero duration, aligned to an external event: test hand-off / release / review)
  192. └── group (kind=group, holds children only, no effort)
  193. └── leaf (kind=task, must carry effortHours; the unit of scheduling and write-back)
  194. ```
  195. ### 7.2 Leaf criteria (a leaf only counts if all four hold)
  196. 1. **Acceptable on its own**: one sentence states "what done means"; nothing else has to be finished first to judge it;
  197. 2. **One owner, one responsibility**: a single person accountable, no parallel negotiation needed;
  198. 3. **0.5–3 person-days**: under half a day means you over-split (merge cost exceeds management cost); over 3 days means it is not broken down yet;
  199. 4. **A concrete output**: a file, an interface, a document, or an observable behaviour.
  200. ### 7.3 Effort and duration
  201. - Fill in `effortHours` only (person-hours); the engine converts at 8 hours per person-day;
  202. - Groups and milestones carry no effort; their progress is **effort-weighted** from their children;
  203. - No effort means the schedule cannot be trusted and violation checking degrades.
  204. ### 7.4 Dependencies
  205. Connect leaves only, in the form `predecessorID:type[:lag]`:
  206. | Type | Meaning | Where it is used |
  207. |---|---|---|
  208. | `fs` | successor starts after the predecessor finishes (default) | 95% of cases |
  209. | `ss` | both start together | two parallel development lines |
  210. | `ff` | both finish together | aligning wrap-up work |
  211. | `sf` | successor finishes only after the predecessor starts | rarely used |
  212. `lag` is a lead time in days, for real gaps like "integration starts 2 days after the API freezes".
  213. ### 7.5 Anti-patterns
  214. | What people write | Why it is wrong |
  215. |---|---|
  216. | "Build the payment module" as a leaf with 80 hours | Not acceptable, not parallelisable; split into API / server / client / integration |
  217. | Effort on a group | Progress gets counted twice |
  218. | A milestone with a 2-day duration | A milestone is a point in time, not work |
  219. | A dependency pointing at a group | The engine only honours leaves; group dependencies are ambiguous |
  220. | Two tasks with the same title | The Claude Code hook will skip or mis-mark |
  221. ## 8. One full walkthrough (copy as-is)
  222. ```bash
  223. cd "$HOME/Projects/demo"
  224. BIN="$KAIDOPLAN/.build/release/KaidoPlanCLI"
  225. export KAIDOPLAN_LANG=en # English output; omit it for the default language
  226. # ⓪ create the project if it is missing (skipped if present, never overwritten)
  227. [ -f demo.kaido ] || "$BIN" project create "Demo Project" \
  228. --start 2026-11-02 --end 2026-11-20 --file demo.kaido
  229. # ① write a WBS (nested JSON; omitting children on a leaf is legal)
  230. cat > wbs.json <<'EOF'
  231. [
  232. {"title": "Payment module", "kind": "group", "children": [
  233. {"title": "API design", "effortHours": 16},
  234. {"title": "Server implementation", "effortHours": 40},
  235. {"title": "Client integration", "effortHours": 24},
  236. {"title": "Integration sign-off", "kind": "milestone"}
  237. ]}
  238. ]
  239. EOF
  240. # ② import (the whole tree at once)
  241. "$BIN" wbs import wbs.json --file demo.kaido
  242. # ③ look at the list (optional; ④ resolves prefixes from titles)
  243. "$BIN" task list --file demo.kaido
  244. ```
  245. Output (prefixes are local to your project):
  246. ```
  247. imported 5 tasks
  248. 560E37A9 Payment module
  249. ```
  250. ```
  251. 560E37A9 Payment module [group] pending
  252. 8113CA26 API design pending · effort 16 h
  253. 6E47F1F3 Server implementation pending · effort 40 h
  254. F7507B0F Client integration pending · effort 24 h
  255. 3E82456D Integration sign-off [milestone] pending · effort 0 h · duration 0 days
  256. ```
  257. ```bash
  258. # ④ wire dependencies: resolve prefixes by title instead of copying IDs by hand
  259. id() { "$BIN" task list --file demo.kaido --json \
  260. | python3 -c "import json,sys;print([t['id'][:4] for t in json.load(sys.stdin) if t['title']=='$1'][0])"; }
  261. "$BIN" task update "$(id 'Server implementation')" --dep "$(id 'API design'):fs" --file demo.kaido
  262. "$BIN" task update "$(id 'Client integration')" --dep "$(id 'Server implementation'):fs" --file demo.kaido
  263. "$BIN" task update "$(id 'Integration sign-off')" --dep "$(id 'Client integration'):fs" --file demo.kaido
  264. # ⑤ schedule
  265. "$BIN" schedule compute --file demo.kaido
  266. # ⑥ critical path (the chain with zero slack)
  267. "$BIN" schedule path --file demo.kaido
  268. # ⑦ violations (cycles, out-of-bounds, deadline conflicts)
  269. "$BIN" violations --file demo.kaido
  270. # ⑧ write-back (the AI does this once per finished task)
  271. "$BIN" status update "$(id 'API design')" --status done --file demo.kaido
  272. ```
  273. What the real run printed:
  274. ```
  275. task updated: 6E47F1F3 Server implementation
  276. task updated: F7507B0F Client integration
  277. task updated: 3E82456D Integration sign-off
  278. ---
  279. schedule computed: 5 tasks
  280. 560E37A9 Payment module 2026-11-01T16:00:00Z → 2026-11-02T16:00:00Z (1 day, ASAP)
  281. 8113CA26 API design 2026-11-01T16:00:00Z → 2026-11-03T16:00:00Z (2 days, ASAP)
  282. 6E47F1F3 Server implementation 2026-11-03T16:00:00Z → 2026-11-08T16:00:00Z (5 days, ASAP)
  283. F7507B0F Client integration 2026-11-08T16:00:00Z → 2026-11-11T16:00:00Z (3 days, ASAP)
  284. 3E82456D Integration sign-off 2026-11-11T16:00:00Z → 2026-11-11T16:00:00Z (0 days, ASAP)
  285. ---
  286. critical path: 0 tasks (slack limit 0 days)
  287. 560E37A9 Payment module total slack 17 days / free slack 17 days
  288. 8113CA26 API design total slack 8 days / free slack 0 days
  289. 6E47F1F3 Server implementation total slack 8 days / free slack 0 days
  290. F7507B0F Client integration total slack 8 days / free slack 0 days
  291. 3E82456D Integration sign-off total slack 8 days / free slack 8 days
  292. ---
  293. no violations
  294. ---
  295. status written: 8113CA26 API design (done, progress 100%)
  296. completed at: 2026-10-25T03:23:58Z
  297. group progress: 100%
  298. ```
  299. > `group progress` aggregates the subtree the task belongs to — for a leaf that is the task itself, so 100% here means "this leaf is done", not "the whole group is done".
  300. > Schedule output is ISO8601 **UTC**: local midnight shows up as 16:00Z the previous day (UTC+8). Trust the macOS app or `--json` for calendar dates; do not read the terminal's UTC straight onto a calendar.
  301. ## 9. Collaboration loop
  302. ```
  303. Human: set boundaries (start/end dates, acceptance criteria)
  304. ↓
  305. AI: task_list to read the state → break down the WBS → wbs_import → schedule_compute → report violations
  306. ↓
  307. Human: review the Gantt and violations (macOS app), approve or change deadlines / dependencies
  308. ↓
  309. AI: implement task by task → status_update done → group progress aggregates automatically
  310. ↓
  311. Human: watch progress and drift, decide to insert work or cut scope
  312. ```
  313. Two collaboration rules:
  314. - **Read before writing**: the AI calls `task_list` before every change, otherwise it rebuilds the same tree;
  315. - **Write back on completion**: changing `progress` without `status` leaves group progress untouched, and the human then looks at a fake number.
  316. ## 10. Troubleshooting
  317. | Symptom | Cause | Fix |
  318. |---|---|---|
  319. | `command not found` / KaidoPlanMCP not found | Not built, or the path is wrong | `swift build -c release`, and use absolute paths in the config |
  320. | MCP connected but tools say "no project open" | Tools do not read environment variables; they need an explicit path | Call `project_open` first, or hard-code the path in the rules file |
  321. | `kaidoplan-mcp: KaidoPlanMCP not found` | Neither a build in the checkout nor `kaidoplan-mcp` on `PATH` | `brew install cygnusyang/kaidoplan/kaidoplan-cli`, build, or set `KAIDOPLAN_MCP_BIN` |
  322. | A Claude Code task completed but nothing was written back | Title not unique / `KAIDOPLAN_PROJECT` missing / CLI not found | Read the `kaidoplan-hook:` lines on stderr; set `KAIDOPLAN_CLI_BIN` |
  323. | App and AI editing the same `.kaido` | No automatic merge | The app offers to reload; close the app during write-back |
  324. | Scheduled dates off by one day | Output is UTC, the app shows local time | Trust the app or the local dates in `--json` |
  325. | CLI/MCP says "requires KaidoPlan Pro" (exit code 3) | No license file or subscription | Activate a license or subscribe; see https://kaidoplan.cygnusyang.top/#pricing |
  326. ## 11. Scope of verification
  327. - **Verified** (macOS, KaidoPlan v0.9.1 release binaries, 2026-10-25): §2 including the MCP probe, §8 end to end with English CLI output.
  328. - **Re-verified** (2026-11-16, v3.11.x): the MCP contract over stdio — `initialize` returns `protocolVersion 2024-11-05`, `tools/list` returns **21 tools** starting with `project_create`, `project_open`, `project_save`, `task_add`.
  329. - **Verified earlier** (KaidoPlan v0.8.0, 2026-10-23, re-checked against the current tree but not re-run): §4A / §4B / §5 KaidoPlan-side commands and the plugin hook write-back.
  330. - **Documented, not exercised**: the Cursor / Gemini CLI / VS Code / WorkBuddy entries — file names, top-level keys and field sets follow each vendor's documentation (checked 2026-11-16; note VS Code now carries two formats: the Copilot harness reads `mcpServers` from the workspace `.mcp.json` or `~/.copilot/mcp-config.json`, while `.vscode/mcp.json` with a `servers` key belongs to the deprecated Local harness), but were not run against those clients on this machine; whether Codex desktop exposes the `[mcp_servers.kaidoplan]` tools immediately (no `codex` CLI on PATH here); CodeBuddy's `TaskCompleted` event payload fields (its docs list the event name but not the fields, so no CodeBuddy hook exists).
  331. ## License
  332. This repository (plugin manifest, MCP configuration, hook scripts, slash commands, wrapper scripts) is released under the [MIT License](LICENSE) — fork it, tweak it, ship your own flavor; improvements welcome via PR in this repo.
  333. The KaidoPlan application and CLI binaries it orchestrates remain proprietary and require a valid license or subscription.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.