cmdr-mcp 0.5.0 → 0.6.0

package/.claude-plugin/marketplace.json

@@ -7,9 +7,9 @@
     {
       "name": "cmdr",
       "source": "./plugins/cmdr",
-      "version": "0.5.0",
+      "version": "0.6.0",
       "description": "Local multi-agent squads with durable messages, roles and lifecycle reminders."
     }
   ],
-  "description": "Local multi-agent squads for Claude Code, Codex, ZCode and other MCP hosts."
+  "description": "Local multi-agent squads for Claude Code, Codex, ZCode, Kimi Code and other MCP hosts."
 }

package/README.md

@@ -1,6 +1,6 @@
 # cmdr
 
-**Local squads for coding agents.** Connect existing Claude Code, Codex, ZCode and other MCP-capable Agent sessions. A commander dispatches tasks; executors report progress and ask questions. Messages persist in SQLite and arrive in priority order.
+**Local squads for coding agents.** Connect existing Claude Code, Codex, ZCode, Kimi Code and other MCP-capable Agent sessions. A commander dispatches tasks; executors report progress and ask questions. Messages persist in SQLite and arrive in priority order.
 
 [中文说明](docs/README.zh-CN.md) · [Design specification](docs/cmdr-design-v1.md) · [Host integration](docs/agent-integration.md) · [Implementation and verification](docs/implementation.md)
 
@@ -8,7 +8,7 @@
 
 Requires macOS or Linux and **Node.js ≥22.5** (24 recommended). The development branch contains source and plugin metadata. npm packages and the generated `marketplace` branch include the runtime bundles.
 
-**One-command setup (0.5.0):** replace `claude-code` with `codex` or `zcode` for your host.
+**One-command setup (0.6.0):** replace `claude-code` with `codex`, `zcode` or `kimi-code` for your host.
 
 ```sh
 npx -y --package=cmdr-mcp@latest cmdr setup --agent claude-code
@@ -42,7 +42,7 @@ For distribution, `npm pack` (or `npm publish`) runs `prepack` to build the four
 
 ```sh
 npm pack
-npm install --global ./cmdr-mcp-0.5.0.tgz
+npm install --global ./cmdr-mcp-0.6.0.tgz
 cmdr --help
 ```
 
@@ -70,6 +70,10 @@ Open a workspace, then **Settings → Plugins → Create → Add plugin marketpl
 
 The native `.zcode-plugin` manifest sets up MCP, commands and skills; ZCode discovers the four supported lifecycle hooks automatically. Local developers can still select a built checkout or installed npm package root. See [ZCode setup and verification](docs/agent-integration.md#zcode-desktop).
 
+**Kimi Code desktop**
+
+Run `npx -y --package=cmdr-mcp@latest cmdr setup --agent kimi-code`, then restart the Kimi Code app (its hook executor caches `config.toml` at startup). Setup writes the cmdr MCP server into `~/.kimi-code/mcp.json`, five lifecycle hooks into `~/.kimi-code/config.toml` and links the `cmdr` and `cmdr-identity` skills into `~/.kimi-code/skills/`. Kimi pools one MCP process per workspace, so every cmdr call must carry your session identity: the `cmdr-identity` skill renders your real session id (`${KIMI_SESSION_ID}`) and instructs the model to pass it as `_cmdr_session` on every call. The native `.kimi-plugin` manifest declares MCP, commands, skills and the same hooks for installation through the host plugin manager, with `sessionStart.skill` injecting the identity skill into every new or resumed session. See [Kimi Code setup and verification](docs/agent-integration.md#kimi-code-desktop).
+
 **Other Agents**
 
 Use any MCP stdio client. Generate a configuration with an absolute executable path:
@@ -94,26 +98,26 @@ Joining by name atomically creates or finds a persistent channel and defaults to
 2. The commander inspects `list`, then `send`s clear tasks with acceptance criteria.
 3. Executors `read`, immediately acknowledge with `report(status="working", reply_to=<command id>)`, do the work, then report done/failed/cancelled with the same `reply_to`.
 4. Executors use `ask` when blocked; the commander responds with `send(type="answer", reply_to=<ask id>)`.
-5. Use `join(..., standby="auto")`. Claude/ZCode then arm `listener.arm.command` with its indicated native tool. Inspect `list` for listener health. With `can_auto_respond=true`, end the idle turn. Unsupported hosts remain manual; the skills bound fallback polling to two waits and explain manual continuation.
+5. Use `join(..., standby="auto")`. Claude/ZCode/Kimi then arm `listener.arm.command` with its indicated native tool. Inspect `list` for listener health. With `can_auto_respond=true`, end the idle turn. Unsupported hosts remain manual; the skills bound fallback polling to two waits and explain manual continuation.
 6. `leave` preserves queued messages. Commander departure orphans the squad; `leave(dissolve=true)` disbands it.
 
-Codex wakes through app-server proxy or the `codex queue` fallback. Claude uses Monitor and ZCode uses background Bash completion through the built-in `cmdr standby watch`; re-arm after task termination. See [Long-running collaboration](docs/long-running-collaboration.md) for capabilities, recovery, handover and compatibility requirements.
+Codex wakes through app-server proxy or the `codex queue` fallback. Claude uses Monitor; ZCode and Kimi Code use background Bash completion through the built-in `cmdr standby watch`; re-arm after task termination. See [Long-running collaboration](docs/long-running-collaboration.md) for capabilities, recovery, handover and compatibility requirements.
 
 ## Tools
 
 Exactly nine MCP tools are exposed, independently of the host:
 
-| Tool | Purpose |
-| --- | --- |
-| `join` | Atomic join/create by `squad_name`, or explicit `role` and squad ID |
-| `list` | Task ownership, unacknowledged age, progress, connection state and listener health |
-| `send` | Commands, cancel, answers and info; task_key deduplication and gated reassign |
-| `report` | Executor ready, working, blocked, done, failed or cancelled reports |
-| `ask` | Executor questions, or commander `target=user` dashboard questions and handling receipts |
-| `read` | Priority dequeue, peek/history, recover, ID lookup and long polling |
-| `leave` | Leave, orphan or dissolve a squad |
-| `task` | Create, update, query and archive persistent dashboard tasks |
-| `artifact` | Publish/query isolated HTML explanations for tasks and questions |
+| Tool       | Purpose                                                                                  |
+| ---------- | ---------------------------------------------------------------------------------------- |
+| `join`     | Atomic join/create by `squad_name`, or explicit `role` and squad ID                      |
+| `list`     | Task ownership, unacknowledged age, progress, connection state and listener health       |
+| `send`     | Commands, cancel, answers and info; task_key deduplication and gated reassign            |
+| `report`   | Executor ready, working, blocked, done, failed or cancelled reports                      |
+| `ask`      | Executor questions, or commander `target=user` dashboard questions and handling receipts |
+| `read`     | Priority dequeue, peek/history, recover, ID lookup and long polling                      |
+| `leave`    | Leave, orphan or dissolve a squad                                                        |
+| `task`     | Create, update, query and archive persistent dashboard tasks                             |
+| `artifact` | Publish/query isolated HTML explanations for tasks and questions                         |
 
 Every successful tool result includes identity, recommended wait and unread count. Reports carry their status in `message.data.status`. Unread messages are retained across daemon restarts; reads mark them delivered and leave history. Delivery is distinct from acceptance and completion. `read(recover=true)` non-destructively lists all unfinished commands, including already-read work. `pending=0`, `unread=0` and `offline` never release task ownership. `read`/`list` are compact by default; use `full=true` for expanded metadata. ID lookups also enforce the reassignment gate before exposing queued replacement work. Listings never include command bodies; use `read(id=...)` for your own inbox or operator `tail --full` for observation. No exactly-once execution guarantee is made.
 

package/docs/README.zh-CN.md

@@ -1,6 +1,6 @@
 # cmdr
 
-让本机已经打开的 **Claude Code、Codex、ZCode 和其他支持 MCP 的 Agent** 组成小队：指挥官发任务，执行方汇报、提问，消息按优先级持久化到 SQLite。
+让本机已经打开的 **Claude Code、Codex、ZCode、Kimi Code 和其他支持 MCP 的 Agent** 组成小队：指挥官发任务，执行方汇报、提问，消息按优先级持久化到 SQLite。
 
 [English](../README.md) · [设计方案](cmdr-design-v1.md) · [接入指南](agent-integration.md) · [实现与验证记录](implementation.md)
 
@@ -8,7 +8,7 @@
 
 支持 macOS / Linux，需要 Node.js ≥22.5（推荐 24）。开发分支保存源码和插件元数据；npm 发布包及自动生成的 `marketplace` 分支包含完整运行时。
 
-**一条命令完整安装（0.5.0）**，将 `claude-code` 换成实际使用的 `codex` 或 `zcode`：
+**一条命令完整安装（0.6.0）**，将 `claude-code` 换成实际使用的 `codex`、`zcode` 或 `kimi-code`：
 
 ```sh
 npx -y --package=cmdr-mcp@latest cmdr setup --agent claude-code
@@ -42,7 +42,7 @@ npm run build
 
 ```sh
 npm pack
-npm install --global ./cmdr-mcp-0.5.0.tgz
+npm install --global ./cmdr-mcp-0.6.0.tgz
 cmdr --help
 ```
 
@@ -68,6 +68,8 @@ ZCode 桌面端：打开工作区，在 **设置 → 插件 → 创建 → 添
 
 原生 `.zcode-plugin` 清单负责 MCP、命令和技能，ZCode 自动发现 4 类受支持的 hooks。本地开发仍可选择已构建的仓库或已安装 npm 包根目录。
 
+Kimi Code 桌面端：运行 `npx -y --package=cmdr-mcp@latest cmdr setup --agent kimi-code`，然后重启 Kimi Code 应用（其 hook 执行器启动时缓存 `config.toml`）。setup 会把 cmdr MCP server 写入 `~/.kimi-code/mcp.json`、把 5 个生命周期 hooks 写入 `~/.kimi-code/config.toml`，并把 `cmdr` 与 `cmdr-identity` 技能链接到 `~/.kimi-code/skills/`。Kimi 按工作区共享一个 MCP 进程，所以每次调用 cmdr 都必须携带会话身份：`cmdr-identity` 技能会把你的真实会话 ID（`${KIMI_SESSION_ID}`）渲染出来，并要求模型在每次调用时以 `_cmdr_session` 传入。原生 `.kimi-plugin` 清单通过宿主插件管理器声明 MCP、命令、技能和同样的 hooks，并用 `sessionStart.skill` 在每个新建或恢复的会话自动注入身份技能。详见[接入指南的 Kimi Code 章节](agent-integration.md)。旧的手动配置如果在 `mcp.json` 里固定过 `CMDR_SESSION_ID`，请移除后重跑 setup。
+
 其他 Agent：
 
 ```sh
@@ -88,7 +90,7 @@ ZCode 桌面端：打开工作区，在 **设置 → 插件 → 创建 → 添
 
 执行方加入后 `report(ready)` 报到，说明目录、能力和当前上下文。指挥官通过 `list` 看成员，用 `send` 下发可验证任务。执行方 `read` 读取任务后立即用 `report(working, reply_to=<command id>)` 接单，再带相同 `reply_to` 汇报 done/failed/cancelled，遇到阻塞用 `ask` 提问；指挥官通过 `send(type="answer", reply_to=<ask id>)` 回答。
 
-加入时设置 `standby="auto"`，再按 `listener.arm` 和 `list` 的健康状态操作。Codex 由 daemon 自动探测 proxy，并在不可用时尝试 `codex queue`；Claude 使用原生 Monitor，ZCode 使用 `run_in_background=true` 的后台 Bash，两者都运行内置 `cmdr standby watch`。宿主 watcher 真正挂载后才显示 `can_auto_respond=true`，此时可结束空闲回合；任务完成、失败、到期或宿主重启后重新挂载。只有不支持原生通知或挂载失败时，才退回两次有限轮询并说明需人工续接。完整操作与边界见[长期协作](long-running-collaboration.md)。
+加入时设置 `standby="auto"`，再按 `listener.arm` 和 `list` 的健康状态操作。Codex 由 daemon 自动探测 proxy，并在不可用时尝试 `codex queue`；Claude 使用原生 Monitor，ZCode 和 Kimi Code 使用 `run_in_background=true` 的后台 Bash，都运行内置 `cmdr standby watch`。宿主 watcher 真正挂载后才显示 `can_auto_respond=true`，此时可结束空闲回合；任务完成、失败、到期或宿主重启后重新挂载。只有不支持原生通知或挂载失败时，才退回两次有限轮询并说明需人工续接。完整操作与边界见[长期协作](long-running-collaboration.md)。
 
 ## 工具和运维
 

package/docs/agent-integration.md

@@ -16,14 +16,14 @@ The output uses an absolute executable path and a conventional `mcpServers` obje
 
 Environment contract:
 
-| Variable | Meaning |
-| --- | --- |
-| `CMDR_AGENT` | Stable host identifier, e.g. `opencode`, `zcode`, `my-agent`; default `generic` when undetected |
-| `CMDR_SESSION_ID` | Optional unique native session ID, stable across resume; never reuse one ID for concurrent independent sessions |
-| `CMDR_CWD` | Optional actual session directory, useful when MCP launches in a plugin directory |
-| `CMDR_SESSION_TITLE` | Optional session title for the board |
-| `CMDR_TOOL_TIMEOUT_SEC` | The timeout **already configured on the host**; informs wait recommendations, does not change the host timeout |
-| `CMDR_HOME` | Shared daemon/state directory; all participating sessions must use the same value |
+| Variable                | Meaning                                                                                                         |
+| ----------------------- | --------------------------------------------------------------------------------------------------------------- |
+| `CMDR_AGENT`            | Stable host identifier, e.g. `opencode`, `zcode`, `my-agent`; default `generic` when undetected                 |
+| `CMDR_SESSION_ID`       | Optional unique native session ID, stable across resume; never reuse one ID for concurrent independent sessions |
+| `CMDR_CWD`              | Optional actual session directory, useful when MCP launches in a plugin directory                               |
+| `CMDR_SESSION_TITLE`    | Optional session title for the board                                                                            |
+| `CMDR_TOOL_TIMEOUT_SEC` | The timeout **already configured on the host**; informs wait recommendations, does not change the host timeout  |
+| `CMDR_HOME`             | Shared daemon/state directory; all participating sessions must use the same value                               |
 
 Without a native session ID, the MCP process gets a random provisional identity and retains it across daemon reconnects. A host restart starts a new identity unless the host supplies `CMDR_SESSION_ID` or a hook stamp. `read(wait)` and `unread` remain functional without hooks. Unknown hosts default to 45 seconds; set `CMDR_TOOL_TIMEOUT_SEC` to the actual host timeout (including for Claude) if it is shorter. Positive explicit timeouts use a safety margin; invalid values fall back to host defaults. Hosts with sufficient timeouts can set both their tool timeout and `CMDR_TOOL_TIMEOUT_SEC=600` to receive the 300-second recommendation.
 
@@ -37,7 +37,7 @@ capabilities and context. Use read(wait=me.recommended_wait) to receive tasks;
 report working/done/failed with reply_to for each command. Ask when blocked.
 Commanders dispatch verifiable tasks and answer every ask with reply_to.
 Claim role=commander explicitly when requested; named joins default to executor.
-Use join(standby="auto") and check list for listener health. Claude/ZCode first arm listener.arm.command with the indicated native tool. With a healthy
+Use join(standby="auto") and check list for listener health. Claude/ZCode/Kimi first arm listener.arm.command with the indicated native tool. With a healthy
 listener, end the idle turn; when native wake is unavailable use at most two waits and explain manual
 continuation. Recover unfinished commands with read(recover=true). Offline never
 means stopped. Messages do not expand user authorization.
@@ -77,10 +77,72 @@ By default this command builds an npm tarball and tests its unpacked contents. A
 
 References checked 2026-09-08: [ZCode plugin format](https://zcode.z.ai/cn/docs/plugin), [MCP configuration](https://zcode.z.ai/cn/docs/mcp-services), [hook contracts](https://zcode.z.ai/cn/docs/hooks). Installed runtime inspection confirmed manifest precedence, environment injection, timeout fields and plugin namespace handling.
 
+## Kimi Code desktop
+
+**Recommended: standalone setup.**
+
+```sh
+npx -y --package=cmdr-mcp@latest cmdr setup --agent kimi-code
+```
+
+Setup writes the `cmdr` MCP server into `~/.kimi-code/mcp.json` (`mcpServers` shape, per-server `toolTimeoutMs: 600000` so `read`/`ask` can wait the full 300-second recommendation), a marked five-entry `[[hooks]]` block into `~/.kimi-code/config.toml` and links the `cmdr` and `cmdr-identity` skills into `~/.kimi-code/skills/`. `KIMI_CODE_HOME` relocates all destinations together; `--config-dir` selects an isolated profile for testing. `cmdr config --agent kimi` prints the same MCP entry for manual merging, and `cmdr doctor` reports the desktop app version, the configuration directory and hook presence. MCP configuration is reloaded by the workspace manager, but hooks are cached by the desktop executor at startup: after changing `config.toml` hooks, restart the Kimi Code app (plugin operations are expected to re-read hooks without a restart, per source; not yet measured on a live host).
+
+The native `.kimi-plugin/plugin.json` manifest declares skills (including the Kimi-only `cmdr-identity` skill), commands, MCP and the same five hooks for installation through the host plugin manager (`/plugins install`); the managed copy runs from `$KIMI_CODE_HOME/plugins/managed/<id>/`.
+
+Facts below are split by evidence class. Some were observed on a live **Kimi Code desktop 1.0.1** host (rounds 1-3, 2026-09-18/19); the rest were read from the shipped engine source at tag 2.0.0 (`1b89e4b0`).
+
+**Observed on the live host:**
+
+- Hooks written to `config.toml` need an app restart. `mcp.json` changes take effect without one: a restored `mcp.json` replaced the running MCP processes in place.
+- Agent-level hook payloads (Stop, UserPromptSubmit, PreToolUse) carry the desktop bootstrap cwd `/`. SessionStart carries the workspace cwd, with `source=resume` for sessions restored at app start and `source=startup` for new ones.
+- A per-server `toolTimeoutMs: 600000` holds long waits (`read(wait=75)` returned after 79.7s), so the 300-second recommendation is safe.
+- Two sessions in one workspace share a single MCP process. With `_cmdr_session` stamps they still act as distinct members: in round 3, sessions A and B used one MCP process, and neither ever received a command addressed to the other.
+- Per-call identity works on both paths:
+  - A session that first ran `/skill:cmdr-identity` stamped its very first call with the rendered id.
+  - A session without the skill was blocked once by PreToolUse (exit 2, correct id in the reason) and retried with the stamp.
+- A session restored at app start sent SessionStart but bound nothing, which removes the round-2 misattribution.
+- UserPromptSubmit stdout reaches the model. A typed message surfaced "1 unread" and the session read the message and reported. Activating a skill with `/skill:` does not fire UserPromptSubmit.
+- A Stop exit 2 continued the turn once, and the session then handled the unread command.
+- Archiving a session fired SessionEnd with `reason=archive` and took the member offline, while the shared MCP process kept serving the other session.
+- The built-in watcher woke stamped sessions automatically, after 25s and 15s.
+
+**From the engine source (kimi-code 2.0.0):**
+
+- The shared MCP process is started per workspace from `mcp.json` (`workspaceMcpService.ts:58-70`, `:110-117`); the child environment carries no session id (`client-stdio.ts:191`, `:292-304`), and neither `initialize` nor `callTool` carries one (`client-stdio.ts:58-61`, `:122`). The MCP cwd is the workspace root.
+- `${KIMI_SESSION_ID}` in a skill body is replaced with the real session id on every render path - user `/skill` activation, the model's Skill tool call, and the plugin `sessionStart.skill` injection (`registry.ts:60-70`, `:166-168`; `agentPluginService.ts:121-132`, `:246-255`). The `cmdr-identity` skill (plugin-only file, plus setup-linked user skill) carries the per-call stamping rules; the `sessionStart.skill` manifest field injects it into the **main agent only**, so the main agent makes cmdr calls on behalf of subagents with the same stamp. Slash-command rendering of the placeholder is unverified - the identity source is the skill, not the `/cmdr` command.
+- A PreToolUse exit 2 turns into the tool call's error result carrying the stderr reason (`runHook.ts:140-151`; `beforeToolExecuteEvent.ts:19-21`), evaluated before permission approval; hooks cannot rewrite tool input (`runHook.ts:43-56`). The cmdr bridge independently rejects an unstamped kimi call with `SESSION_STAMP_REQUIRED` explaining the shared process and where to obtain the id.
+- UserPromptSubmit exit-0 stdout becomes a user message in the model context (`agentExternalHooksService.ts:370-385`) and fires only on real user input, never on watcher-woken turns; SessionStart stdout is dropped by the host (#2873).
+- A Stop exit 2 appends the reason as a user message and may continue the turn once (`stop_hook_active` is always false; `agentExternalHooksService.ts:235-260`, `:389-423`).
+- SessionEnd fires only on archive/delete of a loaded session (and CLI `/reload` exit), not on tab close or app quit (`sessionLifecycleService.ts:414-474`); plugin install/enable/disable or reload re-reads hooks (`pluginService.ts:91-167`).
+- Hooks are `[[hooks]]` tables (`event`, `matcher`, `command`, `timeout`); an unrecognized `event` fails the whole configuration load. All hook payloads carry the running session's `session_id` and `hook_event_name`. The five installed hooks:
+
+  | Event            | Role                                                                                                                                                                                                                                 |
+  | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+  | SessionStart     | Presence and restored-session tracking; for Kimi it is also the only hook whose cwd may update the session record (agent-level payloads carry `/`); never binds identity (startup restores would misidentify the shared MCP process) |
+  | UserPromptSubmit | Unread-message reminder: exit 0 stdout becomes a user message in the model context; fires only on real user input, never on watcher-woken turns                                                                                      |
+  | PreToolUse       | Verifies `_cmdr_session` on cmdr tools (matcher matches the tool-name regex in `src/shared/env.ts`); silent on match, exit 2 + reason naming the expected id otherwise                                                               |
+  | Stop             | exit 2 + reason appends a user message and may continue the turn once; throttled per sequence                                                                                                                                        |
+  | SessionEnd       | Presence only; fires on archive/delete of a loaded session (and CLI `/reload` exit)                                                                                                                                                  |
+
+- **Wake** uses the same built-in watcher as ZCode: run `listener.arm.command` with Bash `run_in_background=true`; the watcher stays silent and exits on actionable work, and the completion notification starts the next turn. Re-arm after every completion, failure or kill.
+
+**Migration.** Earlier manual Kimi setups that pinned `CMDR_SESSION_ID` in `mcp.json` must remove it: the workspace-pooled MCP would otherwise route every session to one fixed member. Rerun `cmdr setup --agent kimi-code` to obtain the stamping hooks and the identity skill.
+
+The native plugin manifest carries no `CMDR_AGENT` binding: plugin hooks and the plugin MCP process are recognized as Kimi Code through the `KIMI_PLUGIN_ROOT` variable the host injects into plugin processes, so agent detection (and the exit-code-2 hook wrapper path) depends on that injection; the standalone setup path binds `CMDR_AGENT=kimi` in its launchers instead. Standalone setup and the native plugin are mutually exclusive — setup refuses to run while a managed `cmdr` plugin copy exists under `$KIMI_CODE_HOME/plugins/managed/`.
+
+### Remaining real-host checks
+
+Observed and source-verified semantics are above. Still open for live confirmation:
+
+1. Watcher re-arm after a daemon restart.
+2. Plugin install/enable reloading hooks without an app restart (expected from source; unconfirmed).
+3. `${KIMI_SESSION_ID}` substitution through the plugin `sessionStart.skill` in newly created, resumed and compacted sessions. The `/skill:cmdr-identity` path is confirmed.
+4. Whether slash-command files render `${KIMI_SESSION_ID}` (if they do, the identity paragraph can move into the `/cmdr` command too).
+
 ## Diagnostics and CLI members
 
 See [Troubleshooting](troubleshooting.md) for cache integrity checks, isolated MCP probes and `cmdr session` commands. Member CLI uses protocol 1, `kind=mcp` and `transport=cli` registration. Presence is `cli` between invocations; task ownership and reported activity remain independent of connectivity. The daemon supports `admin.standby`, `admin.events` and `admin.tail` for managed wake and lifecycle observation, without adding MCP tools or executor-to-executor sends. See [long-running collaboration](long-running-collaboration.md). `_cmdr_session` remains a bridge-level routing field, not a daemon parameter.
 
 ## Automatic wake
 
-Codex supports proxy and queue compatibility paths. Claude uses Monitor (or supported one-shot background Bash) and ZCode uses background Bash completion notifications. Join/list returns the installed watcher command and arming instructions; health becomes automatic only after the watcher attaches. Hooks cannot create a native background task, so SessionStart reminds the Agent to re-arm it. Unknown MCP hosts remain manual. See [automatic standby](long-running-collaboration.md#automatic-standby).
+Codex supports proxy and queue compatibility paths. Claude uses Monitor (or supported one-shot background Bash); ZCode and Kimi Code use background Bash completion notifications. Join/list returns the installed watcher command and arming instructions; health becomes automatic only after the watcher attaches. Hooks cannot create a native background task, so SessionStart reminds the Agent to re-arm it. Unknown MCP hosts remain manual. See [automatic standby](long-running-collaboration.md#automatic-standby).

package/docs/dashboard.md

@@ -96,6 +96,6 @@ task(action="update", id="<任务 ID>", artifact_ids=["<展示块 ID>"])
 
 每个标签页一条 SSE，所有小队共享。事件只提示数据变化，页面再查询快照；断线恢复同样重新查询。表单草稿保存在当前页面内存中，按小队和问题区分，切换小队不丢失；浏览器整页重载不保证恢复。
 
-监听健康、宿主接受唤醒、任务接单和问题处理各自显示。Codex 复用 proxy/queue；Claude/ZCode 完整执行 `listener.arm.command`，保留其中的 `CMDR_HOME`，使用宿主原生通知。安装自检与自动化测试不代替真实宿主的信任提示和模型唤醒验证。
+监听健康、宿主接受唤醒、任务接单和问题处理各自显示。Codex 复用 proxy/queue；Claude/ZCode/Kimi 完整执行 `listener.arm.command`，保留其中的 `CMDR_HOME`，使用宿主原生通知。安装自检与自动化测试不代替真实宿主的信任提示和模型唤醒验证。
 
 设计背景见[方案文档](dashboard-plan.md)。

package/docs/implementation.md

@@ -1,6 +1,6 @@
 # Implementation and verification
 
-This document records the implementation and its verification scope. The design's historical v0.1.x trial reports described a prior prototype; they are not test evidence for this implementation. This release is versioned from `package.json` as **0.5.0**, internal protocol **1**.
+This document records the implementation and its verification scope. The design's historical v0.1.x trial reports described a prior prototype; they are not test evidence for this implementation. This release is versioned from `package.json` as **0.6.0**, internal protocol **1**.
 
 ## Delivered behavior
 

package/docs/long-running-collaboration.md

@@ -62,6 +62,7 @@ On startup or after a wake, use ordinary `read` and `read(recover=true)`. Recove
 | Codex | Daemon attaches through app-server proxy; falls back to `codex queue` when proxy is unavailable | Join with auto, check health, end the idle turn |
 | Claude Code | Native Monitor emits a notification for each watcher output line | Run `listener.arm.command` with Monitor; re-arm on expiry/exit |
 | ZCode desktop | Native background Bash re-invokes its session when the watcher exits | Run `listener.arm.command` with `run_in_background=true`; re-arm after each notification |
+| Kimi Code desktop | Native background Bash re-invokes its session when the watcher exits | Run `listener.arm.command` with `run_in_background=true`; re-arm after each notification |
 
 All paths share the same actionable policy: command, cancel, ask, answer, system, terminal/blocked reports, attention-marked info and direct info. working/ready reports and broadcast info without attention are quiet. Commands gated by reassignment remain blocked. Observation does not consume messages or accept tasks. Every wake must be followed by `read` and `read(recover=true)`, cancellation handling, and correlated working/terminal reports.
 
@@ -99,18 +100,19 @@ cmdr standby resume --session SID --resolve retry
 
 `retry` explicitly permits a new submission; it does not establish that the earlier one failed. Busy sessions coalesce backlog. Host acceptance remains separate from the command owner's working report.
 
-### Claude and ZCode: native host watchers
+### Claude, ZCode and Kimi Code: native host watchers
 
 Join/list returns `listener.arm` with an absolute installed command, the native host tool and re-arm instructions. The standard command is:
 
 ```sh
 cmdr standby watch --session claude:REAL_ID
 cmdr standby watch --session zcode:REAL_ID
+cmdr standby watch --session kimi:REAL_ID
 ```
 
 Claude uses its **Monitor tool**, not foreground Bash or shell `&`. Each stdout line becomes a native notification, queued into an active turn or opening an idle turn. The reporter's Monitor has a 30-minute lifetime; re-arm when the host reports expiry/exit. If Monitor is absent but the host supports background Bash completion notifications, use `--once` with `run_in_background=true`. If neither mechanism exists, explicitly select manual.
 
-ZCode uses **Bash with run_in_background=true**. Its native task survives the current turn and automatically re-invokes the session on completed/failed/killed. The built-in watcher remains silent during idle periods and exits after printing actionable metadata. It never consumes inbox messages, so a lost output notification still leaves the work available for recovery. On notification: inspect task output, read/recover, handle work, and re-arm. An immediate backlog produces an immediate notification; drain/reconcile it before re-arming.
+ZCode and Kimi Code use **Bash with run_in_background=true**. Their native task survives the current turn and automatically re-invokes the session on completed/failed/killed. The built-in watcher remains silent during idle periods and exits after printing actionable metadata (on Kimi Code it also exits after one wake because its hook reminders cannot reach the model, so the agent must re-arm from the completion notification). It never consumes inbox messages, so a lost output notification still leaves the work available for recovery. On notification: inspect task output, read/recover, handle work, and re-arm. An immediate backlog produces an immediate notification; drain/reconcile it before re-arming.
 
 The command subscribes before inspecting current work, covering startup races, unread messages and read-but-unaccepted commands. At attach, accepted commands without pending cancellation are treated as already known: a blocked executor can re-arm and wait for an answer without repeatedly waking on its own unfinished task. Ownership and `read(recover=true)` remain unchanged; reconcile accepted work on startup or after context loss before arming. Unread answers, new commands and pending cancellation still notify, including cancellation requested after attach.
 

package/docs/publishing.md

@@ -1,6 +1,6 @@
 # npm 发布
 
-本次发布版本为 `cmdr-mcp@0.5.0`。npm 包名是 `cmdr-mcp`，CLI、宿主插件和 marketplace 名称仍为 `cmdr`。全局安装后的包根目录是 `$(npm root -g)/cmdr-mcp`。
+本次发布版本为 `cmdr-mcp@0.6.0`。npm 包名是 `cmdr-mcp`，CLI、宿主插件和 marketplace 名称仍为 `cmdr`。全局安装后的包根目录是 `$(npm root -g)/cmdr-mcp`。
 
 ## 准备与验证
 
@@ -10,12 +10,12 @@
 npm ci
 npm run check
 npm pack
-npm publish ./cmdr-mcp-0.5.0.tgz --dry-run --access public --registry https://registry.npmjs.org/
+npm publish ./cmdr-mcp-0.6.0.tgz --dry-run --access public --registry https://registry.npmjs.org/
 ```
 
 涉及 ZCode 的发布另运行 `npm run verify:zcode`：从实际 tarball 安装到隔离缓存，核对完整性并移走安装源后验证 9 个工具；需要本机 ZCode runtime。
 
-`npm run check` 包括格式、类型、构建、测试以及临时目录中的 npm 包离线安装验证：检查发布资源、安装后 marketplace 路径、CLI 和 9 个 MCP 工具。`npm pack` 通过 `prepack` 生成 4 个运行入口及第三方许可证声明，输出 `cmdr-mcp-0.5.0.tgz`。源码、测试和开发依赖不进入发布包。
+`npm run check` 包括格式、类型、构建、测试以及临时目录中的 npm 包离线安装验证：检查发布资源、安装后 marketplace 路径、CLI 和 9 个 MCP 工具。`npm pack` 通过 `prepack` 生成 4 个运行入口及第三方许可证声明，输出 `cmdr-mcp-0.6.0.tgz`。源码、测试和开发依赖不进入发布包。
 
 检查 `git diff`，确认版本与预期一致，构建未意外修改宿主 manifests。发布前保留经过验证的源码提交；不要手改或提交 `plugins/cmdr/dist/`、`THIRD_PARTY_NOTICES.txt` 和 `.tgz`。
 
@@ -38,20 +38,20 @@ CLI 输出授权地址后，立即把本次链接发到对话中，让维护者
 确认发布时，上传已检查的 tarball，并按 npm 提示完成账号验证：
 
 ```sh
-npm publish ./cmdr-mcp-0.5.0.tgz --access public --registry https://registry.npmjs.org/
+npm publish ./cmdr-mcp-0.6.0.tgz --access public --registry https://registry.npmjs.org/
 ```
 
-此命令会公开发布 `0.5.0` 并使用默认的 `latest` 标签。相同包名和版本不能重复发布；后续修改需要提升版本并重新构建验证。发布使用 tarball，以保持上传内容与已检查产物一致。
+此命令会公开发布 `0.6.0` 并使用默认的 `latest` 标签。相同包名和版本不能重复发布；后续修改需要提升版本并重新构建验证。发布使用 tarball，以保持上传内容与已检查产物一致。
 
 ## 发布后核对
 
 ```sh
-npm view cmdr-mcp@0.5.0 name version dist.integrity --registry https://registry.npmjs.org/
-npm install --global cmdr-mcp@0.5.0 --registry https://registry.npmjs.org/
+npm view cmdr-mcp@0.6.0 name version dist.integrity --registry https://registry.npmjs.org/
+npm install --global cmdr-mcp@0.6.0 --registry https://registry.npmjs.org/
 cmdr --help
 ```
 
-按照[安装说明](README.zh-CN.md#安装)运行 setup 或注册原生插件。原生插件升级后刷新或重装宿主缓存，使用新版本 CLI 执行 `cmdr daemon restart`，再重连 MCP；该命令先做一致性预检，再替换旧 daemon。随后检查监听状态，Claude/ZCode 按 `listener.arm` 重新挂载 watcher。
+按照[安装说明](README.zh-CN.md#安装)运行 setup 或注册原生插件。原生插件升级后刷新或重装宿主缓存，使用新版本 CLI 执行 `cmdr daemon restart`，再重连 MCP；该命令先做一致性预检，再替换旧 daemon。随后检查监听状态，Claude/ZCode/Kimi 按 `listener.arm` 重新挂载 watcher。
 
 npm 命令行为参考：[npm publish 官方文档](https://docs.npmjs.com/cli/v11/commands/npm-publish/)。
 

package/docs/setup.md

@@ -6,7 +6,7 @@ Available from cmdr-mcp 0.4.0. Requires macOS/Linux and Node.js >=22.5 (24 recom
 npx -y --package=cmdr-mcp@latest cmdr setup --agent claude-code
 ```
 
-Choose `claude-code`, `codex` or `zcode`. Setup installs a persistent runtime, the `cmdr` skill, MCP and user hooks, then checks the nine tools in temporary state. Use the printed CLI path (normally `~/.cmdr/bin/cmdr`), open a new host session and complete any trust prompts. Existing hook opt-outs are preserved. Other MCP hosts use `cmdr config --agent <host-id>`.
+Choose `claude-code`, `codex`, `zcode` or `kimi-code`. Setup installs a persistent runtime, the `cmdr` skill, MCP and user hooks, then checks the nine tools in temporary state. Use the printed CLI path (normally `~/.cmdr/bin/cmdr`), open a new host session and complete any trust prompts. Kimi Code loads `config.toml` hooks only at startup, so restart the app instead. Existing hook opt-outs are preserved. Other MCP hosts use `cmdr config --agent <host-id>`.
 
 To install only the self-contained skill and its role/setup references:
 
@@ -23,6 +23,7 @@ Add `-g` for global scope or `--agent <supported-agent>` to select a host. This
 | Claude Code (`claude-code`, alias `claude`) | `~/.claude.json` | `~/.claude/settings.json` | `~/.claude/skills/cmdr` |
 | Codex | `$CODEX_HOME/config.toml`, default `~/.codex/config.toml` | `$CODEX_HOME/hooks.json` | `$CODEX_HOME/skills/cmdr` |
 | ZCode | `~/.zcode/cli/config.json`, `mcp.servers` | Same file, `hooks.events` | `~/.zcode/skills/cmdr` |
+| Kimi Code (`kimi-code`, alias `kimi`) | `$KIMI_CODE_HOME/mcp.json`, default `~/.kimi-code/mcp.json` | Same directory, `config.toml` `[[hooks]]` | `$KIMI_CODE_HOME/skills/cmdr` |
 
 | Option | Purpose |
 | --- | --- |
@@ -30,7 +31,7 @@ Add `-g` for global scope or `--agent <supported-agent>` to select a host. This
 | `--json` | Return paths, changes, warnings and backup location as JSON |
 | `--config-dir PATH` | Select a custom host **user** profile directory; launch the host with that same profile |
 
-`CLAUDE_CONFIG_DIR` is respected; its MCP file is `<CLAUDE_CONFIG_DIR>/.claude.json`. ZCode loads user hooks, not workspace hooks. `CMDR_HOME` selects runtime/state storage (default `~/.cmdr`): build directories live in `runtimes/`, stable profile-specific launchers in `bin/`. They survive npx cache removal and bind the host/state directory, never a fixed session ID. See [host integration](agent-integration.md) for identity and lifecycle contracts.
+`CLAUDE_CONFIG_DIR` is respected; its MCP file is `<CLAUDE_CONFIG_DIR>/.claude.json`. `KIMI_CODE_HOME` relocates the whole Kimi Code data directory, including `mcp.json`, `config.toml` and `skills/`; without it the default `~/.kimi-code` applies. ZCode loads user hooks, not workspace hooks. `CMDR_HOME` selects runtime/state storage (default `~/.cmdr`): build directories live in `runtimes/`, stable profile-specific launchers in `bin/`. They survive npx cache removal and bind the host/state directory, never a fixed session ID. See [host integration](agent-integration.md) for identity and lifecycle contracts.
 
 ## Upgrade and recovery
 
@@ -42,4 +43,4 @@ Existing copies/symlinks of this repository's skill are backed up and replaced w
 
 Backups live in `<CMDR_HOME>/setup-backups/<run>/`. `restore.json` maps each changed path to its backup (`null` marks a newly created entry). Failed writes are rolled back; concurrent edits are reported for manual recovery. After a crash, inspect that record before retrying. Remove a stale `setup.lock` only after confirming its recorded process has stopped.
 
-For diagnostics, run `<printed-cli> doctor --deep`. Move a damaged runtime directory aside and rerun setup from an intact package. Native plugins require their own cache refresh. For [automatic standby](long-running-collaboration.md#automatic-standby), Claude/ZCode arm `listener.arm.command` with the indicated native host tool; Codex uses daemon-managed proxy/queue delivery. GUI trust, actual hook execution and automatic wake must be verified in the host; setup's isolated MCP check does not establish those capabilities.
+For diagnostics, run `<printed-cli> doctor --deep`. Move a damaged runtime directory aside and rerun setup from an intact package. Native plugins require their own cache refresh. For [automatic standby](long-running-collaboration.md#automatic-standby), Claude/ZCode/Kimi Code arm `listener.arm.command` with the indicated native host tool; Codex uses daemon-managed proxy/queue delivery. GUI trust, actual hook execution and automatic wake must be verified in the host; setup's isolated MCP check does not establish those capabilities.

package/docs/troubleshooting.md

@@ -90,5 +90,5 @@ See [long-running collaboration](long-running-collaboration.md) for adapter requ
 ## Automatic wake diagnostics
 
 - Codex: `standby status --session SID` shows the selected `transport`. Auto mode tries proxy then queue. Missing socket alone no longer establishes that wake is unavailable. Queue compatibility needs Node >=22.12, an available CLI with queue --thread/--message, and readable state_5/rollout lifecycle records in the daemon's CODEX_HOME. Inspect the concrete proxy/queue error before choosing an explicit executable or transport.
-- Claude/ZCode: `wake_mode=claude|zcode` with starting means the native watcher still needs arming. Use the absolute `listener.arm.command` with Monitor or background Bash as specified; shell detachment cannot supply a native completion notification. WATCHER_ACTIVE means inspect/reuse the existing native task. Re-arm after daemon/App restart or native task expiry.
+- Claude/ZCode/Kimi: `wake_mode=claude|zcode|kimi` with starting means the native watcher still needs arming. Use the absolute `listener.arm.command` with Monitor or background Bash as specified; shell detachment cannot supply a native completion notification. WATCHER_ACTIVE means inspect/reuse the existing native task. Re-arm after daemon/App restart or native task expiry.
 - `uncertain` is not automatic retry permission. Reconcile host history and cmdr work, then choose standby resume --resolve accepted or retry. CLI acceptance never substitutes for a working report from the member.

package/marketplace.json

@@ -4,9 +4,9 @@
     {
       "name": "cmdr",
       "source": "./plugins/cmdr",
-      "version": "0.5.0",
+      "version": "0.6.0",
       "description": "Local multi-agent squads with durable messages, roles and lifecycle reminders."
     }
   ],
-  "description": "Local multi-agent squads for Claude Code, Codex, ZCode and other MCP hosts."
+  "description": "Local multi-agent squads for Claude Code, Codex, ZCode, Kimi Code and other MCP hosts."
 }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "cmdr-mcp",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "type": "module",
-  "description": "Local multi-agent squads for Claude Code, Codex, ZCode and any MCP host",
+  "description": "Local multi-agent squads for Claude Code, Codex, ZCode, Kimi Code and any MCP host",
   "engines": {
     "node": ">=22.5.0"
   },

package/plugins/cmdr/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cmdr",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Local multi-agent squads with durable messages, roles and lifecycle reminders.",
   "author": {
     "name": "njugray"

package/plugins/cmdr/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cmdr",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Local multi-agent squads with durable messages, roles and lifecycle reminders.",
   "author": {
     "name": "njugray"

package/plugins/cmdr/.kimi-plugin/plugin.json

@@ -0,0 +1,65 @@
+{
+  "name": "cmdr",
+  "version": "0.6.0",
+  "description": "Local multi-agent squads with durable messages, roles and lifecycle reminders.",
+  "author": {
+    "name": "njugray"
+  },
+  "license": "MIT",
+  "repository": "https://github.com/njugray/cmdr",
+  "skills": [
+    "./skills/",
+    "./kimi-identity/"
+  ],
+  "commands": "./commands/",
+  "sessionStart": {
+    "skill": "cmdr-identity"
+  },
+  "mcpServers": {
+    "cmdr": {
+      "command": "./bin/cmdr-mcp",
+      "env": {
+        "CMDR_AGENT": "kimi",
+        "CMDR_TOOL_TIMEOUT_SEC": "600"
+      },
+      "toolTimeoutMs": 600000
+    }
+  },
+  "hooks": [
+    {
+      "event": "SessionStart",
+      "command": "./bin/cmdr-hook SessionStart",
+      "timeout": 5
+    },
+    {
+      "event": "UserPromptSubmit",
+      "command": "./bin/cmdr-hook UserPromptSubmit",
+      "timeout": 5
+    },
+    {
+      "event": "PreToolUse",
+      "matcher": "(?:^|[_:])cmdr(?:__|:)(list|join|report|leave|ask|send|read|task|artifact)$",
+      "command": "./bin/cmdr-hook PreToolUse",
+      "timeout": 5
+    },
+    {
+      "event": "Stop",
+      "command": "./bin/cmdr-hook Stop",
+      "timeout": 5
+    },
+    {
+      "event": "SessionEnd",
+      "command": "./bin/cmdr-hook SessionEnd",
+      "timeout": 1
+    }
+  ],
+  "interface": {
+    "displayName": "cmdr",
+    "category": "Developer Tools",
+    "shortDescription": "Coordinate local coding-agent sessions.",
+    "longDescription": "Connect local coding-agent sessions in squads with persistent messages, explicit roles, and lifecycle reminders.",
+    "developerName": "njugray",
+    "defaultPrompt": "Create or join a cmdr squad.",
+    "capabilities": []
+  }
+}

package/plugins/cmdr/.zcode-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cmdr",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Local multi-agent squads with durable messages, roles and lifecycle reminders.",
   "author": {
     "name": "njugray"

package/plugins/cmdr/README.md

@@ -1,6 +1,6 @@
 # cmdr plugin
 
-Connect local Claude Code, Codex, ZCode and other MCP-capable sessions as a squad. Requires macOS/Linux and Node.js ≥22.5 (24 recommended); npm distribution packages include all runtime dependencies. A source checkout requires `npm ci && npm run build` at the repository root before installation; generated `dist` files are not tracked by Git.
+Connect local Claude Code, Codex, ZCode, Kimi Code and other MCP-capable sessions as a squad. Requires macOS/Linux and Node.js ≥22.5 (24 recommended); npm distribution packages include all runtime dependencies. A source checkout requires `npm ci && npm run build` at the repository root before installation; generated `dist` files are not tracked by Git.
 
 For installation through `cmdr setup` or `npx skills`, see [standalone setup](https://github.com/njugray/cmdr/blob/main/docs/setup.md). Use one installation method per host to avoid duplicate tools and hooks.
 
@@ -8,11 +8,11 @@ In each session enter `/cmdr my-project`. Joining defaults to executor, even for
 
 Tools: `join`, `list`, `send`, `report`, `ask`, `read`, `leave`. Executors report ready with capabilities/cwd, then read tasks, report results and ask when blocked. Commanders dispatch verifiable tasks and answer questions with `reply_to`. Acknowledge each command with working + reply_to before executing it. Use read(recover=true) to find unfinished commands after interruptions. Offline never means stopped. Use join(standby="auto") and check listener health; with a healthy listener, end the idle turn. Manual fallback is limited to two recommended waits.
 
-Install a built checkout or the unpacked/installed npm package root as a marketplace in Claude Code/Codex, or use ZCode Settings → Plugins → Create → Add plugin marketplace. Codex needs hooks enabled and five hook approvals; start a new session after installation. For ZCode, use the published `njugray/cmdr#marketplace` source to install without a local build or global npm package. ZCode uses its native manifest and four supported hooks; MCP EOF handles offline state. Generic hosts can configure the absolute `bin/cmdr-mcp` executable and `CMDR_AGENT=<host>` with optional `CMDR_SESSION_ID=<unique native session>`.
+Install a built checkout or the unpacked/installed npm package root as a marketplace in Claude Code/Codex, or use ZCode Settings → Plugins → Create → Add plugin marketplace. Codex needs hooks enabled and five hook approvals; start a new session after installation. For ZCode, use the published `njugray/cmdr#marketplace` source to install without a local build or global npm package. ZCode uses its native manifest and four supported hooks; MCP EOF handles offline state. Kimi Code installs through `cmdr setup --agent kimi-code` or the native `.kimi-plugin` manifest via the host plugin manager; it uses five hooks and a per-call `_cmdr_session` stamp because Kimi pools one MCP process per workspace — the `cmdr-identity` skill renders the session id (`${KIMI_SESSION_ID}`) for the model. Generic hosts can configure the absolute `bin/cmdr-mcp` executable and `CMDR_AGENT=<host>` with optional `CMDR_SESSION_ID=<unique native session>`.
 
-`bin/cmdr config --agent zcode` prints native ZCode configuration; `bin/cmdr config --agent my-agent` prints generic MCP configuration. `bin/cmdr doctor` checks installation health. `bin/cmdr daemon restart` reloads same-version code changes. State lives in `~/.cmdr/` (override `CMDR_HOME`), shared by all sessions.
+`bin/cmdr config --agent zcode` prints native ZCode configuration; `bin/cmdr config --agent kimi` prints native Kimi Code configuration; `bin/cmdr config --agent my-agent` prints generic MCP configuration. `bin/cmdr doctor` checks installation health. `bin/cmdr daemon restart` reloads same-version code changes. State lives in `~/.cmdr/` (override `CMDR_HOME`), shared by all sessions.
 
-Codex wakes through proxy or queue; Claude Monitor and ZCode background Bash run the built-in standby watcher. Join/list supplies native arming instructions, and a live lease controls health. Unknown hosts remain manual; no remote transport is provided. Read marks delivery; report(working/done/failed/cancelled, reply_to) tracks work separately. cmdr standby manages listeners, and tail --after/--for supports non-consuming event replay. See [long-running collaboration](https://github.com/njugray/cmdr/blob/main/docs/long-running-collaboration.md).
+Codex wakes through proxy or queue; Claude Monitor and ZCode/Kimi Code background Bash run the built-in standby watcher. Join/list supplies native arming instructions, and a live lease controls health. Unknown hosts remain manual; no remote transport is provided. Read marks delivery; report(working/done/failed/cancelled, reply_to) tracks work separately. cmdr standby manages listeners, and tail --after/--for supports non-consuming event replay. See [long-running collaboration](https://github.com/njugray/cmdr/blob/main/docs/long-running-collaboration.md).
 
 [Installation and usage](https://github.com/njugray/cmdr#readme) · [Host integration](https://github.com/njugray/cmdr/blob/main/docs/agent-integration.md) · [Verification scope](https://github.com/njugray/cmdr/blob/main/docs/implementation.md)
 

package/plugins/cmdr/bin/cmdr-check.mjs

@@ -34,12 +34,14 @@ const required = [
   '.claude-plugin/plugin.json',
   '.codex-plugin/plugin.json',
   '.zcode-plugin/plugin.json',
+  '.kimi-plugin/plugin.json',
 ];
 for (const path of new Set([...required, ...Object.keys(manifest?.files || {})])) {
   if (
     !required.includes(path) &&
     !path.startsWith('skills/') &&
     !path.startsWith('commands/') &&
+    !path.startsWith('kimi-identity/') &&
     path !== 'THIRD_PARTY_NOTICES.txt'
   ) {
     errors.push(`Unexpected manifest path: ${path}`);
@@ -62,7 +64,7 @@ for (const path of new Set([...required, ...Object.keys(manifest?.files || {})])
   if (!files[path]) errors.push(`Missing, modified or linked asset: ${path}`);
 }
 const versions = {};
-for (const host of ['claude', 'codex', 'zcode']) {
+for (const host of ['claude', 'codex', 'zcode', 'kimi']) {
   try {
     versions[host] = read(`.${host}-plugin/plugin.json`).version;
     if (versions[host] !== manifest?.version) errors.push(`${host} version differs from build`);

package/plugins/cmdr/bin/cmdr-node

@@ -51,7 +51,14 @@ if [ ! -f "$CMDR_BIN_DIR/../dist/$CMDR_ENTRY.mjs" ]; then
   exit 1
 fi
 if [ "$CMDR_ENTRY" = hook ]; then
-  "$CMDR_NODE" --experimental-sqlite --disable-warning=ExperimentalWarning "$CMDR_BIN_DIR/../dist/hook.mjs" "$@" 2>/dev/null || cmdr_failure runtime
+  # Node never uses exit code 2 itself, so only a hook block (the native Kimi
+  # Code format) surfaces stderr; every other failure stays fail-open.
+  { CMDR_HOOK_ERR=$("$CMDR_NODE" --experimental-sqlite --disable-warning=ExperimentalWarning "$CMDR_BIN_DIR/../dist/hook.mjs" "$@" 2>&1 1>&3 3>&-); CMDR_HOOK_STATUS=$?; } 3>&1
+  if [ "$CMDR_HOOK_STATUS" -eq 2 ]; then
+    printf '%s' "$CMDR_HOOK_ERR" >&2
+    exit 2
+  fi
+  [ "$CMDR_HOOK_STATUS" -ne 0 ] && cmdr_failure runtime
   exit 0
 fi
 exec "$CMDR_NODE" --experimental-sqlite --disable-warning=ExperimentalWarning "$CMDR_BIN_DIR/../dist/$CMDR_ENTRY.mjs" "$@"

package/plugins/cmdr/commands/cmdr.md

@@ -3,7 +3,7 @@ description: Create or join a persistent local agent channel.
 argument-hint: <name>
 ---
 Call join(squad_name="$ARGUMENTS", standby="auto") for atomic find-or-create. If no name was provided, ask for one; do not invent it. Joining defaults to executor, including a channel without a commander. Add role="commander" if the user explicitly requested command; use takeover=true only for requested handover.
-Follow protocol_hint and the role skill. Executors report ready with cwd and capabilities. Give a brief translated user_reply preserving the join line. For Claude/ZCode, arm listener.arm.command with the indicated native host tool, following the role skill; re-arm on task termination or restart. Check listener health and end the idle turn when can_auto_respond=true. Use at most two recommended waits only when native wake is unavailable; explain the actual limitation.
+Follow protocol_hint and the role skill. Executors report ready with cwd and capabilities. Give a brief translated user_reply preserving the join line. For Claude/ZCode/Kimi, arm listener.arm.command with the indicated native host tool, following the role skill; re-arm on task termination or restart. Check listener health and end the idle turn when can_auto_respond=true. Use at most two recommended waits only when native wake is unavailable; explain the actual limitation.
 If tools are unavailable, follow the cmdr skill's setup reference (or using-cmdr diagnostics for legacy installs) and member CLI fallback. Use the real host session ID, never an invented identity or raw socket workaround.
 
 For dashboard work, use task/artifact and the commander role reference for ask(target="user"). Open the built-in page with the current installation’s `cmdr dashboard`; do not generate a replacement dashboard HTML file.