kimi-plugin-cc 2.4.4 → 2.5.1

package/.claude-plugin/marketplace.json

@@ -5,7 +5,7 @@
   },
   "metadata": {
     "description": "Kimi for Claude Code: code questions, reviews, fixes, parallel tasks, and MCP tasks through the local Kimi Code CLI.",
-    "version": "2.4.4"
+    "version": "2.5.1"
   },
   "plugins": [
     {

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "kimi",
   "description": "Kimi for Claude Code: code questions, independent reviews, bounded fixes, autonomous goals, parallel tasks, and MCP tasks through the local Kimi Code CLI, with PreToolUse safety hooks.",
-  "version": "2.4.4",
+  "version": "2.5.1",
   "homepage": "https://github.com/linxule/kimi-plugin-cc",
   "repository": "https://github.com/linxule/kimi-plugin-cc",
   "license": "Apache-2.0",

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 > **Post-1.0 release history (v1.0.1 -> present) lives in [ROADMAP-TO-GA.md § Post-GA audit log](./ROADMAP-TO-GA.md#post-ga-audit-log)** and the "Version" / "Upstream compat" lines of [AGENTS.md](./AGENTS.md). Docs-only kimi-code compat checkups that don't bump the plugin version (e.g. the 0.14.2 / 0.14.3 patches) are recorded there, not here. Notable releases are summarized below; the GA entry and full pre-GA detail follow.
 
+## 2.5.1 — 2026-11-01
+
+- Consolidate DSH distribution into the existing `kimi-plugin-cc` npm package and its established OIDC publication path. DSH users install the same root artifact with `dsh plugin --profile <name> add kimi-plugin-cc`; no second npm package or Trusted Publishing binding is required.
+- Declare the root DSH bundle entry, runtime dependencies, and peer compatibility directly in `package.json`, and validate root-tarball installation, seven-tool composition, and Web boot in an isolated DSH profile.
+- Pin safe transitive `zod` and `undici` versions, remove the unnecessary full DSH CLI development dependency, install pnpm explicitly in CI, and exclude dependency directories from installed-script fixtures.
+
+## 2.5.0 — 2026-11-01
+
+- Add DeepSeek Harness as a third host with native `kimi_ask`, `kimi_review`, `kimi_challenge`, `kimi_rescue`, `kimi_pursue`, `kimi_swarm`, and `kimi_swarm_write` providers. Reuse the existing companion and `kimi -p` transport, managed hooks, exact-version certification, SQLite jobs, budgets, artifacts, and process lifecycle; no ACP transport.
+- Add DSH-owned setup, model inventory, host-scoped uninstall, and job controls, plus profile-level model, thinking, budget, review-base, data-root, environment, output, and teardown settings. Preserve read-only denials, real-workspace rescue/pursue writes, and patch-only swarm-write.
+- Package `dsh-kimi-plugin-cc` as an independently installable npm bundle with its own pack/install/composition/Web-boot gate. Publish root and DSH tarballs together through the existing OIDC workflow, with Node 24 CI and verified composition on DSH 0.2.1-rc.5 and 0.2.2-alpha.2.
+- Verify live DSH delegation: `kimi_ask` returns `4`, a managed-hook write denial creates no file, rescue writes only `DSH_OK`, and a two-target swarm-write returns a valid patch without applying it or touching the real workspace.
+- Update installation, safety, model, registry, contributor, and multilingual README guidance. Reduce `AGENTS.md` from 32,704 to 21,291 bytes by keeping detailed mechanics in owning references, and enforce a 24 KB ceiling.
+
+## 2.4.5 — 2026-10-31
+
+- Certify exact kimi-code 2.4.1 for all eight native-v2 operations after exact-source review, plan and swarm controls, and candidate/production smoke. See [evidence](docs/upstream-2.4.1-certification.md).
+- Add only the reviewed 2.4.1 activation and hook-schema entries. Preserve no-plan enforcement, workspace confinement, concurrency, bounded cleanup, durable recovery, and the legacy-v1 0.41.x boundary.
+- Strengthen certification smoke to require same-call managed denials and real multi-turn journal evidence, and expand negative version coverage across every operation. Include the current certification record in the npm package.
+- Review Read output/token limiting and goal/plan prompt changes without changing the tool execution, session provenance, or swarm activation contracts. Update the manual smoke default and current compatibility documentation; installed hosts remain unchanged.
+
 ## 2.4.4 — 2026-10-29
 
 - Certify exact kimi-code 2.4.0 for all eight native-v2 operations after exact-source review, revised plan and swarm controls, and candidate/production smoke. See [evidence](docs/upstream-2.4.0-certification.md).

package/README.md

@@ -1,8 +1,8 @@
-# Kimi for Claude Code and Codex
+# Kimi for Claude Code, Codex, and DeepSeek Harness
 
 [![Latest release](https://img.shields.io/github/v/release/linxule/kimi-plugin-cc)](https://github.com/linxule/kimi-plugin-cc/releases/latest) [![CI](https://github.com/linxule/kimi-plugin-cc/actions/workflows/ci.yml/badge.svg)](https://github.com/linxule/kimi-plugin-cc/actions/workflows/ci.yml) [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](./LICENSE)
 
-Use Kimi to explain code, review changes, challenge a design, or work toward a goal — an independent second opinion from a different model family, inside the Claude Code or Codex session you're already in.
+Use Kimi to explain code, review changes, challenge a design, or work toward a goal — an independent second opinion from a different model family, inside the Claude Code, Codex, or DeepSeek Harness session you're already in.
 
 [![Kimi Ambassador — academia](./assets/kimi-ambassador-academia.webp)](https://www.kimi.ai/lp/kimi-ambassador)
 
@@ -27,20 +27,20 @@ Choose a language below. Each guide opens on this page.
 
 ## Use Kimi in your coding tasks
 
-Ask Kimi to explain code, review changes, challenge a design, or make a focused fix. You can use this plugin in Claude Code or Codex.
+Ask Kimi to explain code, review changes, challenge a design, or make a focused fix. You can use this plugin in Claude Code, Codex, or DeepSeek Harness (DSH).
 
-The plugin runs the Kimi Code CLI on your computer. It uses your Kimi subscription or a provider you configure in Kimi. Calls count against that subscription or API account. Your Claude Code or Codex login stays unchanged. The selected provider receives the prompts and code needed for your task.
+The plugin runs the Kimi Code CLI on your computer. It uses your Kimi subscription or a provider you configure in Kimi. Calls count against that subscription or API account. Your host application's login stays unchanged. The selected provider receives the prompts and code needed for your task.
 
-Start with a question or a review. Their tool rules allow reading files and deny file writes and shell commands. Other modes can change files. Read the [safety limits](./docs/safety.md) before asking Kimi to make changes.
+Start with a question or a review. Their tool rules allow reading files and deny file writes and shell commands. Other modes can change files. DSH provides the same seven operations with the same write boundaries. Read the [safety limits](./docs/safety.md) before asking Kimi to make changes.
 
 ## Before you install
 
 You need:
 
 - macOS or Linux
-- Claude Code or Codex with plugin support
-- Node.js 22.5 or newer
-- Kimi Code CLI 2.4.0 (certified; 2.3.3, 2.3.2, 2.3.1 and 2.3.0 are also certified)
+- Claude Code, Codex, or DSH with plugin support
+- Node.js 22.5 or newer (24.9 or newer for DSH)
+- Kimi Code CLI 2.4.1 (certified; 2.4.0, 2.3.3, 2.3.2, 2.3.1 and 2.3.0 are also certified)
 
 Windows is not currently supported. Contributors can help with the [no-model Windows diagnostics checks](./docs/windows-validation.md). Check your versions in a terminal:
 
@@ -95,20 +95,36 @@ The hook checks Kimi's tool calls against the plugin's rules. The `Probe:` line
 Use $kimi-ask to explain how this project's main entry point works.
 ```
 
-If you use both Claude Code and Codex, run setup in each. Each app has its own hook in the shared Kimi configuration.
+If you use multiple hosts, run setup in each. Each app has its own hook in the shared Kimi configuration.
+
+## Install in DeepSeek Harness
+
+The DSH bundle provides the same seven operations as the other hosts: `kimi_ask`, `kimi_review`, `kimi_challenge`, `kimi_rescue`, `kimi_pursue`, `kimi_swarm`, and `kimi_swarm_write`. They use the same companion runtime, safety hooks, jobs, budgets, and artifacts. Rescue and pursue edit the selected workspace; swarm-write returns a patch without applying or committing it.
+
+From this repository checkout, run:
+
+```sh
+dsh plugin --profile web add ./plugins/kimi-dsh
+```
+
+For the published npm bundle, run `dsh plugin --profile web add kimi-plugin-cc` instead.
+
+Restart DSH when requested, then run `/kimi-setup` and `/kimi-setup --check`. Ask DSH to use one of the seven tools with a self-contained task. Job controls are `/kimi-status`, `/kimi-result`, and `/kimi-cancel`. `/kimi-setup --models` lists configured models, and `/kimi-setup --uninstall` removes only the DSH hook.
+
+DSH requires Node.js 24.9 or newer and DSH `>=0.2.1-rc.5 <0.3.0`. See the [DSH bundle guide](./plugins/kimi-dsh/README.md) for profile-level model, thinking, budget, review-base, and other configuration.
 
 ## npm distribution (optional)
 
 The existing marketplace commands above remain the default for Claude Code and
 Codex. Published releases are also available as
 [`kimi-plugin-cc` on npm](https://www.npmjs.com/package/kimi-plugin-cc), including
-both compiled plugin distributions. No Bun, TypeScript, or install scripts are
+all three compiled plugin distributions. No Bun, TypeScript, or install scripts are
 needed to use the package. Kimi Code CLI and Node are still prerequisites.
 
-For an explicitly versioned local Claude Code plugin, this example pins the 2.4.4 package:
+For an explicitly versioned local Claude Code plugin, this example pins the 2.5.1 package:
 
 ```sh
-npm install --prefix ~/.local/share/kimi-plugin-cc kimi-plugin-cc@2.4.4
+npm install --prefix ~/.local/share/kimi-plugin-cc kimi-plugin-cc@2.5.1
 claude --plugin-dir ~/.local/share/kimi-plugin-cc/node_modules/kimi-plugin-cc
 ```
 
@@ -228,7 +244,7 @@ All refusal codes and their remedies are listed in the [refusal-code catalog](./
 
 The tool rules for ask, review, challenge, and read-only swarm deny file writes and shell commands. Rescue and pursue can write files in your workspace. Swarm with `--write` works in a temporary Git worktree. It starts from your latest commit, so it does not include uncommitted changes. It returns a patch without applying it to your project.
 
-For swarm on CLI 2.3.2, 2.3.3 and 2.4.0, the plugin briefly starts an authenticated loopback `kimi web` process to activate a session and another to deactivate swarm mode afterward; one ordinary `kimi -p -r` process still performs the task. Activation counts against the time limit, the access token stays in memory and out of logs, and cleanup failure prevents success. Older certified versions use `kimi -p` directly.
+For swarm on CLI 2.3.2, 2.3.3, 2.4.0 and 2.4.1, the plugin briefly starts an authenticated loopback `kimi web` process to activate a session and another to deactivate swarm mode afterward; one ordinary `kimi -p -r` process still performs the task. Activation counts against the time limit, the access token stays in memory and out of logs, and cleanup failure prevents success. Older certified versions use `kimi -p` directly.
 
 The plugin does not commit changes. Review changes before you keep or apply them.
 
@@ -251,20 +267,20 @@ Contributors need Bun to run `bun run check`. The detailed engineering documents
 
 ## 用 Kimi 辅助编程
 
-你可以让 Kimi 解释代码、审查修改、指出设计中的问题，或完成一项范围明确的修复。本插件支持 Claude Code 和 Codex。
+你可以让 Kimi 解释代码、审查修改、指出设计中的问题，或完成一项范围明确的修复。本插件支持 Claude Code、Codex 和 DeepSeek Harness（DSH）。
 
-插件在你的电脑上调用 Kimi Code CLI，使用你的 Kimi 订阅或在 Kimi 中配置的服务商。调用会消耗相应的订阅额度或产生 API 费用。Claude Code 和 Codex 的登录状态不变。任务所需的提示词和代码会发送给所选服务商。
+插件在你的电脑上调用 Kimi Code CLI，使用你的 Kimi 订阅或在 Kimi 中配置的服务商。调用会消耗相应的订阅额度或产生 API 费用。宿主应用的登录状态不变。任务所需的提示词和代码会发送给所选服务商。
 
-建议先尝试提问或代码审查。这两类任务允许读取文件，禁止写入文件和执行 shell 命令。其他模式可以修改文件。让 Kimi 动手修改前，请先了解[安全限制](./docs/safety.md)。
+建议先尝试提问或代码审查。这两类任务允许读取文件，禁止写入文件和执行 shell 命令。其他模式可以修改文件；DSH 同样提供七类操作，并遵循相同的写入边界。让 Kimi 动手修改前，请先了解[安全限制](./docs/safety.md)。DSH 的安装方法见[英文说明](#install-in-deepseek-harness)。
 
 ## 安装前准备
 
 你需要：
 
 - macOS 或 Linux
-- 支持插件的 Claude Code 或 Codex
-- Node.js 22.5 或更高版本
-- Kimi Code CLI 2.4.0（已认证；2.3.3、2.3.2、2.3.1 和 2.3.0 也已认证）
+- 支持插件的 Claude Code、Codex 或 DSH
+- Node.js 22.5 或更高版本（DSH 需要 24.9 或更高版本）
+- Kimi Code CLI 2.4.1（已认证；2.4.0、2.3.3、2.3.2、2.3.1 和 2.3.0 也已认证）
 
 目前不支持 Windows。在终端检查版本：
 
@@ -427,7 +443,7 @@ codex plugin add kimi@kimi-marketplace
 
 Ask、review、challenge 和只读 swarm 的工具规则禁止写入文件和执行 shell 命令。Rescue 和 pursue 可以修改工作区内的文件。带 `--write` 的 swarm 在临时 Git 工作树中操作。它从最新提交开始，不包含尚未提交的修改。任务结束后返回补丁，不会自动应用到项目。
 
-在 CLI 2.3.2、2.3.3 和 2.4.0 上运行 swarm 时，插件会短暂启动需要认证的本地回环 `kimi web` 进程来激活会话，并在结束后再次启动以停用 swarm 模式；任务本身仍由一个普通的 `kimi -p -r` 进程执行。激活计入任务时限，访问令牌只保存在内存且不会写入日志；无法确认清理完成时，任务不会报告成功。较早的已认证版本仍直接通过 `kimi -p` 运行。
+在 CLI 2.3.2、2.3.3、2.4.0 和 2.4.1 上运行 swarm 时，插件会短暂启动需要认证的本地回环 `kimi web` 进程来激活会话，并在结束后再次启动以停用 swarm 模式；任务本身仍由一个普通的 `kimi -p -r` 进程执行。激活计入任务时限，访问令牌只保存在内存且不会写入日志；无法确认清理完成时，任务不会报告成功。较早的已认证版本仍直接通过 `kimi -p` 运行。
 
 插件不会提交修改。保留或应用修改前，请先审查。
 
@@ -450,20 +466,20 @@ Ask、review、challenge 和只读 swarm 的工具规则禁止写入文件和执
 
 ## Utiliser Kimi pour vos tâches de développement
 
-Demandez à Kimi d'expliquer du code, de faire une revue de code, de remettre en question une approche ou de corriger un problème précis. Ce plugin fonctionne dans Claude Code et Codex.
+Demandez à Kimi d'expliquer du code, de faire une revue de code, de remettre en question une approche ou de corriger un problème précis. Ce plugin fonctionne dans Claude Code, Codex et DeepSeek Harness (DSH).
 
-Le plugin exécute Kimi Code CLI sur votre ordinateur. Il utilise votre abonnement Kimi ou un fournisseur configuré dans Kimi. Les appels consomment votre quota d'abonnement ou sont facturés sur votre compte API. Votre connexion à Claude Code ou à Codex ne change pas. Le fournisseur choisi reçoit les prompts et le code nécessaires à la tâche.
+Le plugin exécute Kimi Code CLI sur votre ordinateur. Il utilise votre abonnement Kimi ou un fournisseur configuré dans Kimi. Les appels consomment votre quota d'abonnement ou sont facturés sur votre compte API. La connexion à l'application hôte ne change pas. Le fournisseur choisi reçoit les prompts et le code nécessaires à la tâche.
 
-Commencez par une question ou une revue de code. Ces modes autorisent la lecture des fichiers, mais interdisent leur modification et l'exécution de commandes shell. D'autres modes peuvent modifier des fichiers. Consultez les [limites de sécurité](./docs/safety.md) avant de demander des modifications à Kimi.
+Commencez par une question ou une revue de code. Ces modes autorisent la lecture des fichiers, mais interdisent leur modification et l'exécution de commandes shell. D'autres modes peuvent modifier des fichiers ; DSH propose les sept mêmes opérations avec les mêmes limites d'écriture. Consultez les [limites de sécurité](./docs/safety.md) avant de demander des modifications à Kimi. Voir le [guide DSH en anglais](#install-in-deepseek-harness) pour l'installation.
 
 ## Préparer l'installation
 
 Il vous faut :
 
 - macOS ou Linux
-- une version de Claude Code ou de Codex prenant en charge les plugins
-- Node.js 22.5 ou une version ultérieure
-- Kimi Code CLI 2.4.0 (certifiée ; les versions 2.3.3, 2.3.2, 2.3.1 et 2.3.0 sont également certifiées)
+- une version de Claude Code, Codex ou DSH prenant en charge les plugins
+- Node.js 22.5 ou une version ultérieure (24.9 ou ultérieure pour DSH)
+- Kimi Code CLI 2.4.1 (certifiée ; les versions 2.4.0, 2.3.3, 2.3.2, 2.3.1 et 2.3.0 sont également certifiées)
 
 Windows n'est pas pris en charge actuellement. Vérifiez les versions dans un terminal :
 
@@ -626,7 +642,7 @@ Tous les codes de refus et leurs remèdes sont répertoriés dans le [catalogue
 
 Les règles des modes ask, review, challenge et swarm en lecture seule interdisent les écritures et les commandes shell. Rescue et pursue peuvent modifier les fichiers de votre espace de travail. Swarm avec `--write` travaille dans un worktree Git temporaire. Il part du dernier commit et n'inclut donc pas les modifications non commitées. Il renvoie un patch sans l'appliquer à votre projet.
 
-Avec le CLI 2.3.2, 2.3.3 et 2.4.0, les tâches swarm lancent brièvement un processus `kimi web` authentifié sur l'interface de boucle locale pour activer la session, puis un second pour désactiver le mode swarm ; un seul processus `kimi -p -r` ordinaire exécute toujours la tâche. L'activation est comptée dans la limite de temps, le jeton reste en mémoire et hors des journaux, et l'échec du nettoyage empêche de déclarer la réussite. Les versions certifiées antérieures utilisent directement `kimi -p`.
+Avec le CLI 2.3.2, 2.3.3, 2.4.0 et 2.4.1, les tâches swarm lancent brièvement un processus `kimi web` authentifié sur l'interface de boucle locale pour activer la session, puis un second pour désactiver le mode swarm ; un seul processus `kimi -p -r` ordinaire exécute toujours la tâche. L'activation est comptée dans la limite de temps, le jeton reste en mémoire et hors des journaux, et l'échec du nettoyage empêche de déclarer la réussite. Les versions certifiées antérieures utilisent directement `kimi -p`.
 
 Le plugin ne crée aucun commit. Examinez les modifications avant de les conserver ou de les appliquer.
 
@@ -649,20 +665,20 @@ Les contributeurs ont besoin de Bun pour exécuter `bun run check`. La documenta
 
 ## Kimi を開発に使う
 
-コードの説明、変更のレビュー、設計の問題点の指摘、範囲を絞った修正を Kimi に依頼できます。このプラグインは Claude Code と Codex で使えます。
+コードの説明、変更のレビュー、設計の問題点の指摘、範囲を絞った修正を Kimi に依頼できます。このプラグインは Claude Code、Codex、DeepSeek Harness（DSH）で使えます。
 
-プラグインは、お使いのコンピューターで Kimi Code CLI を実行します。Kimi のサブスクリプション、または Kimi に設定したプロバイダーを利用します。呼び出しは、そのサブスクリプションの利用枠を消費するか、API アカウントに課金されます。Claude Code や Codex のログイン状態は変わりません。タスクに必要なプロンプトとコードは、選択したプロバイダーに送信されます。
+プラグインは、お使いのコンピューターで Kimi Code CLI を実行します。Kimi のサブスクリプション、または Kimi に設定したプロバイダーを利用します。呼び出しは、そのサブスクリプションの利用枠を消費するか、API アカウントに課金されます。ホストアプリのログイン状態は変わりません。タスクに必要なプロンプトとコードは、選択したプロバイダーに送信されます。
 
-まずは質問かコードレビューを試してください。これらのモードではファイルの読み取りを許可し、書き込みとシェルコマンドの実行を禁止しています。ほかのモードではファイルを変更できます。変更を依頼する前に、[安全上の制限](./docs/safety.md)を確認してください。
+まずは質問かコードレビューを試してください。これらのモードではファイルの読み取りを許可し、書き込みとシェルコマンドの実行を禁止しています。ほかのモードではファイルを変更できます。DSH でも同じ 7 種類の操作を同じ書き込み範囲で提供します。変更を依頼する前に、[安全上の制限](./docs/safety.md)を確認してください。DSH のインストール方法は[英語の案内](#install-in-deepseek-harness)を参照してください。
 
 ## インストール前の準備
 
 次の環境が必要です。
 
 - macOS または Linux
-- プラグインに対応した Claude Code または Codex
-- Node.js 22.5 以降
-- Kimi Code CLI 2.4.0（認証済み。2.3.3、2.3.2、2.3.1 と 2.3.0 も認証済み）
+- プラグインに対応した Claude Code、Codex、または DSH
+- Node.js 22.5 以降（DSH では 24.9 以降）
+- Kimi Code CLI 2.4.1（認証済み。2.4.0、2.3.3、2.3.2、2.3.1 と 2.3.0 も認証済み）
 
 現在、Windows には対応していません。ターミナルでバージョンを確認します。
 
@@ -825,7 +841,7 @@ codex plugin add kimi@kimi-marketplace
 
 Ask、review、challenge、読み取り専用 swarm のツールルールでは、ファイルへの書き込みとシェルコマンドを禁止しています。Rescue と pursue はワークスペース内のファイルを変更できます。`--write` を指定した swarm は、一時的な Git ワークツリーで作業します。最新のコミットから開始するため、未コミットの変更は含まれません。パッチを返すだけで、プロジェクトには自動適用しません。
 
-CLI 2.3.2 / 2.3.3 / 2.4.0 の swarm では、セッションを有効化するため、そして終了後に swarm モードを無効化するため、認証付きのローカルループバック `kimi web` プロセスをそれぞれ短時間だけ起動します。タスク自体は従来どおり 1 つの `kimi -p -r` プロセスが実行します。有効化も制限時間に含まれ、トークンはメモリー内にのみ保持されてログには出ません。後処理を確認できない場合、タスクは成功と報告されません。以前の認証済みバージョンでは、引き続き `kimi -p` を直接使います。
+CLI 2.3.2 / 2.3.3 / 2.4.0 / 2.4.1 の swarm では、セッションを有効化するため、そして終了後に swarm モードを無効化するため、認証付きのローカルループバック `kimi web` プロセスをそれぞれ短時間だけ起動します。タスク自体は従来どおり 1 つの `kimi -p -r` プロセスが実行します。有効化も制限時間に含まれ、トークンはメモリー内にのみ保持されてログには出ません。後処理を確認できない場合、タスクは成功と報告されません。以前の認証済みバージョンでは、引き続き `kimi -p` を直接使います。
 
 プラグインは変更をコミットしません。変更を残す、または適用する前に内容を確認してください。
 

package/dist/commands/swarm.js

@@ -28,7 +28,7 @@ import { buildKimiSessionTitle, syncKimiSessionTitle } from "../session-title.js
 // only the wall-clock hard bound. Read/write modes reuse review/rescue lineage,
 // and the mandatory PreToolUse hook enforces read-only policy or trusted-worktree
 // write confinement on the coordinator and every subagent. Write mode requires
-// kimi-code 0.18.0+. Exact 2.3.2, 2.3.3 and 2.4.0 additionally activate a same-job
+// kimi-code 0.18.0+. Exact 2.3.2, 2.3.3, 2.4.0 and 2.4.1 additionally activate a same-job
 // session through a bounded loopback web lifecycle, then resume it through the normal print path.
 const SWARM_SUMMARY_MAX = 120;
 const SWARM_AGENT_PROFILE = "<swarm>";

package/dist/dsh/companion.js

@@ -0,0 +1,174 @@
+import { randomUUID } from "node:crypto";
+import { brandString } from "@deepseek-ai/dsh-brand";
+import { assertUsableCwd, settleRunResult, subprocessRunHandle, } from "@deepseek-ai/dsh-subagent";
+export const DSH_COMPANION_OPERATIONS = [
+    "ask",
+    "review",
+    "challenge",
+    "rescue",
+    "pursue",
+    "swarm",
+    "swarm-write",
+];
+export function companionTextTask(prompt) {
+    if (prompt.length === 0 || prompt.some((block) => block.type !== "text")) {
+        throw new Error("kimi-plugin-cc: a delegation must contain only text blocks");
+    }
+    const text = prompt.map((block) => block.type === "text" ? block.text : "").join("\n\n");
+    if (text.trim().length === 0) {
+        throw new Error("kimi-plugin-cc: a delegation must not be empty");
+    }
+    return text;
+}
+export function companionArgv(operation, prompt, companionPath, nodeBin = process.execPath, options = {}) {
+    const command = operation === "ask" || operation === "review"
+        ? [operation]
+        : operation === "swarm-write"
+            ? ["task", "swarm", "--write"]
+            : ["task", operation];
+    return [
+        nodeBin,
+        companionPath,
+        ...command,
+        ...(operation === "ask" || operation === "rescue" ? ["--fresh"] : []),
+        ...(options.model === undefined ? [] : ["-m", options.model]),
+        ...(options.thinkingEffort === undefined ? [] : ["--thinking", options.thinkingEffort]),
+        ...(options.budget === undefined ? [] : ["--budget", options.budget]),
+        ...((operation === "review" || operation === "challenge") && options.reviewBase !== undefined
+            ? ["--base", options.reviewBase]
+            : []),
+        "--",
+        prompt,
+    ];
+}
+export function companionEnvironment(dataRoot, cwd, env, nodeBin = process.execPath) {
+    return {
+        ...env,
+        KIMI_PLUGIN_CC_DATA: dataRoot,
+        KIMI_PLUGIN_CC_HOST_ID: "dsh",
+        KIMI_PLUGIN_CC_NODE_BIN: nodeBin,
+        KIMI_PLUGIN_CC_WORKSPACE_CWD: cwd,
+        CLAUDE_PLUGIN_DATA: undefined,
+        PLUGIN_DATA: undefined,
+        CLAUDE_PLUGIN_ROOT: undefined,
+        PLUGIN_ROOT: undefined,
+        KIMI_PLUGIN_CC_SHELL_LAUNCH: undefined,
+        KIMI_PLUGIN_CC_MCP_WORKSPACE: undefined,
+        KIMI_PLUGIN_CC_WORKSPACE_ROOT: undefined,
+        KIMI_PLUGIN_CC_HOOK_SCRIPT: undefined,
+        KIMI_PLUGIN_CC_SKIP_HOOK_CHECK: undefined,
+        KIMI_PLUGIN_CC_SKIP_VERSION_PROBE: undefined,
+        KIMI_CODE_TRUST_WORKSPACE: undefined,
+    };
+}
+export async function startCompanionRun(request, operation, spec) {
+    const prompt = companionTextTask(request.prompt);
+    if (request.signal.aborted) {
+        throw new Error("kimi-plugin-cc: delegation was aborted before companion startup");
+    }
+    const cwd = assertUsableCwd("kimi-plugin-cc", "child cwd", request.cwd ?? process.cwd());
+    const termination = new AbortController();
+    let cancelled = false;
+    const requestCancel = () => {
+        cancelled = true;
+        if (!termination.signal.aborted) {
+            termination.abort(new Error("kimi-plugin-cc: delegation cancelled"));
+        }
+    };
+    const onAbort = () => requestCancel();
+    request.signal.addEventListener("abort", onAbort, { once: true });
+    let child;
+    try {
+        child = spec.spawn({
+            argv: companionArgv(operation, prompt, spec.companionPath, process.execPath, spec),
+            cwd,
+            stdio: {
+                stdin: "ignore",
+                stdout: { maxBytes: spec.maxOutputBytes },
+                stderr: "inherit",
+            },
+            graceMs: spec.disposeGraceMs,
+            signal: termination.signal,
+            env: companionEnvironment(spec.dataRoot, cwd, spec.env),
+        });
+    }
+    catch (error) {
+        request.signal.removeEventListener("abort", onAbort);
+        throw error;
+    }
+    let diagnostic;
+    const result = settleRunResult({
+        attempt: async () => {
+            let outcome;
+            try {
+                outcome = await child.done;
+            }
+            catch (error) {
+                diagnostic = `Kimi ${operation} companion failed before producing a terminal exit`;
+                throw error;
+            }
+            const collected = child.collected.stdout?.readFrom(0);
+            const text = collected?.text.trimEnd() ?? "";
+            if (!cancelled && outcome.exitCode === 0 && collected && !collected.lossy && text.trim().length > 0) {
+                return { output: [{ type: "text", text }], stopReason: "completed" };
+            }
+            const facts = [
+                `exit code: ${outcome.exitCode ?? "none"}`,
+                `signal: ${outcome.signal ?? "none"}`,
+                ...(collected?.lossy ? ["stdout truncated"] : []),
+                ...(text.trim().length === 0 ? ["stdout empty"] : []),
+            ];
+            diagnostic = `Kimi ${operation} companion failed (${facts.join("; ")})`;
+            return { output: [], diagnostic, stopReason: cancelled ? "aborted" : "error" };
+        },
+        collectOutput: () => [],
+        collectDiagnostic: () => diagnostic,
+        cancelled: () => cancelled,
+        signal: request.signal,
+        onAbort,
+    });
+    return subprocessRunHandle({
+        id: brandString(randomUUID()),
+        result,
+        signal: request.signal,
+        onAbort,
+        requestCancel,
+        teardown: async () => {
+            child.terminate();
+            await child.waitForExit();
+            await child.done.catch(() => { });
+        },
+    });
+}
+export async function runCompanionCommand(argv, cwd, spec, signal) {
+    const child = spec.spawn({
+        argv: [process.execPath, spec.companionPath, ...argv],
+        cwd,
+        stdio: {
+            stdin: "ignore",
+            stdout: { maxBytes: spec.maxOutputBytes },
+            stderr: { maxBytes: spec.maxOutputBytes },
+        },
+        graceMs: spec.disposeGraceMs,
+        signal,
+        env: companionEnvironment(spec.dataRoot, cwd, spec.env),
+    });
+    try {
+        const outcome = await child.done;
+        await child.waitForExit();
+        const stdout = child.collected.stdout?.readFrom(0);
+        const stderr = child.collected.stderr?.readFrom(0);
+        return {
+            exitCode: outcome.exitCode,
+            signal: outcome.signal,
+            stdout: stdout?.text ?? "",
+            stderr: stderr?.text ?? "",
+            truncated: Boolean(stdout?.lossy || stderr?.lossy),
+        };
+    }
+    catch (error) {
+        child.terminate();
+        await child.waitForExit().catch(() => false);
+        throw error;
+    }
+}

package/dist/dsh/index.js

@@ -0,0 +1,156 @@
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { CommandDefinitionId } from "@deepseek-ai/dsh-commands/brand";
+import z from "@deepseek-ai/schemastery";
+import { NO_START_CAPABILITIES, } from "@deepseek-ai/dsh-subagent";
+import { DSH_COMPANION_OPERATIONS, runCompanionCommand, startCompanionRun, } from "./companion.js";
+import { parseDurationMs } from "../parsing.js";
+export const name = "kimi-plugin-cc";
+export const inject = ["subagents", "subprocess"];
+const DEFAULT_DISPOSE_GRACE_MS = 6_000;
+const DEFAULT_MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+const COMPANION_PATH = fileURLToPath(new URL("../../dist/companion.js", import.meta.url));
+export const Config = z.object({
+    dataRoot: z.string().min(1),
+    env: z.dict(z.string()).default({}),
+    disposeGraceMs: z.number().default(DEFAULT_DISPOSE_GRACE_MS),
+    maxOutputBytes: z.number().default(DEFAULT_MAX_OUTPUT_BYTES),
+    model: z.string().min(1),
+    thinkingEffort: z.string().min(1),
+    budget: z.string().min(1),
+    reviewBase: z.string().min(1),
+});
+export function defaultDshDataRoot(env = process.env) {
+    const explicit = env.KIMI_PLUGIN_CC_DATA;
+    if (explicit !== undefined) {
+        if (!path.isAbsolute(explicit)) {
+            throw new Error("kimi-plugin-cc: KIMI_PLUGIN_CC_DATA must be absolute");
+        }
+        return path.normalize(explicit);
+    }
+    const dshHome = env.DSH_HOME ?? path.join(env.HOME || homedir(), ".dsh");
+    if (!path.isAbsolute(dshHome)) {
+        throw new Error("kimi-plugin-cc: DSH_HOME must be absolute");
+    }
+    return path.join(dshHome, "plugin-data", "kimi-plugin-cc");
+}
+function resolveConfig(config) {
+    const resolved = {
+        dataRoot: config.dataRoot ?? defaultDshDataRoot(),
+        env: config.env ?? {},
+        disposeGraceMs: config.disposeGraceMs ?? DEFAULT_DISPOSE_GRACE_MS,
+        maxOutputBytes: config.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES,
+        model: config.model,
+        thinkingEffort: config.thinkingEffort,
+        budget: config.budget,
+        reviewBase: config.reviewBase,
+    };
+    if (!path.isAbsolute(resolved.dataRoot)) {
+        throw new Error("kimi-plugin-cc: dataRoot must be absolute");
+    }
+    if (!Number.isFinite(resolved.disposeGraceMs) || resolved.disposeGraceMs <= 0 || resolved.disposeGraceMs > MAX_TIMER_DELAY_MS) {
+        throw new Error(`kimi-plugin-cc: disposeGraceMs must be positive, finite, and no greater than ${MAX_TIMER_DELAY_MS}`);
+    }
+    if (!Number.isSafeInteger(resolved.maxOutputBytes) || resolved.maxOutputBytes <= 0) {
+        throw new Error("kimi-plugin-cc: maxOutputBytes must be a positive safe integer");
+    }
+    for (const [field, value] of [["model", resolved.model], ["thinkingEffort", resolved.thinkingEffort], ["reviewBase", resolved.reviewBase]]) {
+        if (value?.startsWith("-"))
+            throw new Error(`kimi-plugin-cc: ${field} must not start with '-'`);
+    }
+    if (resolved.budget !== undefined)
+        parseDurationMs(resolved.budget, "--budget", "dsh.config", "safety");
+    return resolved;
+}
+class KimiCompanionProvider {
+    name;
+    operation;
+    spec;
+    capabilities = NO_START_CAPABILITIES;
+    inheritsParentContext = false;
+    constructor(name, operation, spec) {
+        this.name = name;
+        this.operation = operation;
+        this.spec = spec;
+    }
+    start(request) {
+        return startCompanionRun(request, this.operation, this.spec);
+    }
+}
+function commandArguments(rawInput) {
+    const trimmed = rawInput.trim();
+    return trimmed.length === 0 ? [] : trimmed.split(/\s+/);
+}
+function commandText(result) {
+    return [result.stdout.trimEnd(), result.stderr.trimEnd()]
+        .filter((text) => text.length > 0)
+        .join("\n");
+}
+export function apply(ctx, config) {
+    const resolved = resolveConfig(config);
+    const spec = {
+        companionPath: COMPANION_PATH,
+        dataRoot: resolved.dataRoot,
+        env: resolved.env,
+        disposeGraceMs: resolved.disposeGraceMs,
+        maxOutputBytes: resolved.maxOutputBytes,
+        model: resolved.model,
+        thinkingEffort: resolved.thinkingEffort,
+        budget: resolved.budget,
+        reviewBase: resolved.reviewBase,
+        spawn: (spawnSpec) => ctx.subprocess.spawn(spawnSpec),
+    };
+    for (const operation of DSH_COMPANION_OPERATIONS) {
+        ctx.subagents.registerProvider(new KimiCompanionProvider(`kimi-${operation}`, operation, spec));
+    }
+    ctx.inject(["commands"], (commandCtx) => {
+        const execute = async (invocation, argv) => {
+            const directories = commandCtx.get("workingDirectory");
+            if (directories === undefined) {
+                return { kind: "error", text: "Kimi commands require the DSH working-directory service." };
+            }
+            const cwd = await directories.ensure(invocation.agent, invocation.signal);
+            const result = await runCompanionCommand(argv, cwd, spec, invocation.signal);
+            const text = commandText(result);
+            if (result.truncated) {
+                return { kind: "error", text: `${text}\nKimi command output exceeded the configured byte limit.`.trim() };
+            }
+            if (result.exitCode !== 0) {
+                return {
+                    kind: "error",
+                    text: `${text}\nKimi command failed (exit code: ${result.exitCode ?? "none"}; signal: ${result.signal ?? "none"}).`.trim(),
+                };
+            }
+            return { kind: "success", text: text.length > 0 ? text : "Kimi command completed." };
+        };
+        commandCtx.commands.register({
+            definitionId: CommandDefinitionId("kimi-plugin-cc/dsh/setup"),
+            name: "kimi-setup",
+            description: "Install, check, or remove the DSH-owned Kimi PreToolUse hook; list configured models",
+            input: { hint: "[--check|--uninstall|--models [--json]]" },
+            recordInput: false,
+            handler: (invocation) => {
+                const args = commandArguments(invocation.rawInput);
+                const valid = args.length === 0
+                    || (args.length === 1 && ["--check", "--uninstall", "--models"].includes(args[0]))
+                    || (args.length === 2 && args[0] === "--models" && args[1] === "--json");
+                if (!valid) {
+                    return { kind: "error", text: "Usage: /kimi-setup [--check|--uninstall|--models [--json]]" };
+                }
+                return execute(invocation, ["setup", ...args]);
+            },
+        });
+        for (const command of ["status", "result", "cancel"]) {
+            commandCtx.commands.register({
+                definitionId: CommandDefinitionId(`kimi-plugin-cc/dsh/${command}`),
+                name: `kimi-${command}`,
+                description: `${command === "cancel" ? "Cancel" : command === "status" ? "Inspect" : "Return"} a companion Kimi job`,
+                input: { hint: "[job-id]" },
+                recordInput: false,
+                handler: (invocation) => execute(invocation, [command, ...commandArguments(invocation.rawInput)]),
+            });
+        }
+    });
+}

package/dist/hooks/config-safety.js

@@ -595,7 +595,7 @@ function validateVersionSensitiveEvents(events, version) {
     // Exact schemas reviewed at 2.0.0 (1b89e4b0), 2.0.1 (caf7d4e2),
     // 2.0.2 (9d07f634), 2.1.0 (52437299), 2.1.1 (f67e6398), 2.2.0 (472192c3),
     // 2.3.0 (b5e28fd6), 2.3.1 (684bae9e), 2.3.2 (b8dd3a13), 2.3.3 (ec495f0c),
-    // and 2.4.0 (f26e4d91): the additive events and HookDefSchema are unchanged.
+    // 2.4.0 (f26e4d91), and 2.4.1 (2c73f3f5): the additive events and HookDefSchema are unchanged.
     // Require the full version string AND matching components; no inferred 2.x compatibility.
     if (version.major === 2 && ((version.minor === 0 && ((version.version === "2.0.0" && version.patch === 0) ||
         (version.version === "2.0.1" && version.patch === 1) ||
@@ -607,7 +607,8 @@ function validateVersionSensitiveEvents(events, version) {
             (version.version === "2.3.1" && version.patch === 1) ||
             (version.version === "2.3.2" && version.patch === 2) ||
             (version.version === "2.3.3" && version.patch === 3))) ||
-        (version.minor === 4 && ((version.version === "2.4.0" && version.patch === 0))))) {
+        (version.minor === 4 && ((version.version === "2.4.0" && version.patch === 0) ||
+            (version.version === "2.4.1" && version.patch === 1))))) {
         return { valid: true };
     }
     if (version.major !== 0) {

package/dist/hooks/install-paths.js

@@ -410,7 +410,7 @@ export function hostIdFromHookCommand(command) {
 }
 /**
  * True only for a canonical two-single-quoted-token command whose script is
- * `approval-hook.js` under a kimi-plugin-cc/kimi-marketplace install tree.
+ * `approval-hook.js` under a kimi-plugin-cc/dsh-kimi-plugin-cc/kimi-marketplace install tree.
  * This strict ownership test protects hand-rolled and non-canonical user hooks
  * from orphan pruning.
  */
@@ -424,5 +424,5 @@ export function isOurApprovalHookCommand(decodedCommand) {
     const normalized = parsed.hookScript.replace(/\\/g, "/");
     // Require a real path segment, not an arbitrary substring, so a user hook in
     // a similarly named wrapper directory is never misclassified and pruned.
-    return normalized.includes("/kimi-plugin-cc/") || normalized.includes("/kimi-marketplace/");
+    return normalized.includes("/kimi-plugin-cc/") || normalized.includes("/dsh-kimi-plugin-cc/") || normalized.includes("/kimi-marketplace/");
 }

package/dist/kimi-engine.js

@@ -44,6 +44,7 @@ export const NATIVE_V2_CERTIFIED_VERSIONS = Object.freeze([
     "2.3.2",
     "2.3.3",
     "2.4.0",
+    "2.4.1",
 ]);
 /** Per-operation native-v2 certification. One green operation never certifies another. */
 export const NATIVE_V2_CERTIFIED = new Map([