kimi-plugin-cc 2.4.5 → 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.5"
+    "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.5",
+  "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,20 @@
 
 > **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).

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,19 +27,19 @@ 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
+- 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.5 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.5
+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
 ```
 
@@ -251,19 +267,19 @@ 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 或更高版本
+- 支持插件的 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。在终端检查版本：
@@ -450,19 +466,19 @@ 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
+- 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 :
@@ -649,19 +665,19 @@ 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 以降
+- プラグインに対応した 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 には対応していません。ターミナルでバージョンを確認します。

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/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/version.js

@@ -4,4 +4,4 @@
 // and AGENTS.md on every release. A future improvement would read this from
 // package.json at build time, but that adds a build-step dependency we
 // don't want yet.
-export const KIMI_PLUGIN_CC_VERSION = "2.4.5";
+export const KIMI_PLUGIN_CC_VERSION = "2.5.1";

package/docs/models.md

@@ -6,7 +6,7 @@ configured model for one task without changing that default.
 ## See configured models
 
 In Claude Code, run `/kimi:setup --models`. In Codex, ask `$kimi-setup` to list
-models. The underlying command is:
+models. In DSH, run `/kimi-setup --models` (or `--models --json`). The underlying command is:
 
 ```sh
 "<plugin-root>/scripts/companion.sh" setup --models
@@ -35,6 +35,8 @@ several, and guide setup when there is none. They do not guess model IDs or
 silently substitute the default after an error. An explicit `-m` remains a
 pass-through alias, so upstream can resolve it or report an error.
 
+DSH activations are one-shot and do not expose per-call model fields. Set `model` in the bundle's `kimi-plugin-cc` profile row to use one exact configured alias for every delegation from that profile; omit it to use the native Kimi default. This does not change the saved default or add fallback selection.
+
 Omitting `-m` uses the default for a **fresh** session. A resumed session keeps
 its previous model unless you supply `-m`. The optional review gate also uses
 the default unless `KIMI_PLUGIN_CC_REVIEW_GATE_MODEL` explicitly selects an alias.
@@ -87,6 +89,8 @@ including `kosongConfig/configSection.ts`, `envOverlay.ts`, and
 
 Use `--thinking off`, `--thinking high`, or `--thinking=<effort>` before the prompt. Values are lowercased and must match `/^[a-z][a-z0-9-]{0,31}$/` (a plugin-owned syntax bound; a future upstream token outside it is rejected before upstream sees it); upstream per-model `supportEfforts`, not a plugin enum, determines supported values. `--no-thinking` is an error: use `--thinking off`. In CLI 2.2.0 only the three Moonshot `kimi*` provider definitions are trait-driven. BYO providers ignore the request silently; an always-thinking model may remain thinking.
 
+DSH forwards the profile's `thinkingEffort` value as `--thinking <effort>` on every delegation. Omission preserves the ambient operator value; the same provider and observability limits apply.
+
 Jobs persist nullable `thinking_effort`; status and `result --json` expose `thinking_effort_requested`, not observed effort. Detached ask/rescue workers replay the request. A resume without `--thinking` exports no new override (any ambient operator value remains). No config.toml write occurs.
 
 The review gate requests `off` by default. `KIMI_PLUGIN_CC_REVIEW_GATE_THINKING=inherit` exports no override; another non-empty value is lowercased and must match the same regex. Unset or empty means `off`; an invalid value makes the gate skip visibly. The gate remains fail-open on its 8 s timeout: a BYO provider or always-thinking model can ignore the request, and even an honoured request does not guarantee completion within the budget.

package/docs/registry-releases.md

@@ -1,16 +1,14 @@
 # Registry releases
 
 The npm package `kimi-plugin-cc` ships the Claude plugin at its root and the
-self-contained Codex plugin under `plugins/kimi-codex`. GitHub marketplaces
-remain available. The package has no install scripts and no separate CLI.
+self-contained Codex and DSH plugins under `plugins/`. DSH users install that
+same root package with `dsh plugin --profile <name> add kimi-plugin-cc`.
+GitHub marketplaces remain available. The package has no install scripts and
+no separate CLI.
 
 ## Publishing status
 
-Plugin **2.4.5** adds exact CLI **2.4.1** certification for all eight operations,
-with the existing host-preactivated swarm lifecycle and durable recovery.
-See the [certification record](./upstream-2.4.1-certification.md).
-Release execution and registry verification are recorded in the release notes;
-publication uses the same validated-tarball OIDC workflow below.
+Plugin **2.4.5** certifies exact CLI **2.4.1** for all eight operations with host-preactivated swarm sessions. [Release v2.4.5](https://github.com/linxule/kimi-plugin-cc/releases/tag/v2.4.5) is anchored at `de8c195c2986443a088b674717133b164d2e4ef2`; its [CI check](https://github.com/linxule/kimi-plugin-cc/actions/runs/41226096281) and [release-event publishing run](https://github.com/linxule/kimi-plugin-cc/actions/runs/41226438326) passed. The registry tarball has SHA-1 `39f97a6de4b26ad51ac77305054682fcd5cd0164`, contains 233 files, and matches the CI artifact byte-for-byte. Fresh registry installs passed setup/check and unsupported-version refusal for both Claude Code and Codex, and both compiled mirrors are byte-identical to the release checkout. See the [certification record](./upstream-2.4.1-certification.md) and structured verification at `.claude/kimi-code-research/release-2.4.5/registry-verification.json`.
 
 Plugin **2.4.2** adds durable interrupted-swarm recovery and Windows spawn diagnostics.
 Exact CLI certification remains unchanged through **2.3.2**; this is not a new
@@ -90,15 +88,18 @@ bun run build
 bun run generate:surfaces
 # Review and stage generated distributions before the drift gate.
 bun run check
-bun run check:package .tmp/npm
+node scripts/check-package.mjs .tmp/npm
+node scripts/check-dsh-package.mjs .tmp/dsh-npm
 ```
 
-The package check inspects the actual tarball, rejects sync-conflict copies in
+The root package check inspects the actual tarball, rejects sync-conflict copies in
 any path component, verifies runtime copies and vendored licenses, and
-installs/checks the safety hook in isolated homes for both hosts. It also
+installs/checks the safety hook in isolated homes for all three hosts. It also
 exercises unsupported-version refusal using a fake CLI and modern MCP discovery
-plus legacy initialization on both extracted compiled distributions. It does
-not invoke a model or read the maintainer's Kimi configuration.
+plus legacy initialization on the extracted compiled distributions. The DSH
+check installs that same root tarball into an isolated DSH home, verifies all
+seven tools, and boots the Web host. Neither check invokes a model or reads the
+maintainer's Kimi configuration.
 
 ## First publication (completed bootstrap reference)
 
@@ -135,8 +136,10 @@ operations; Bun remains the development toolchain.
 
 Push the reviewed release commit, wait for CI, tag it, and publish its GitHub
 release. `.github/workflows/publish.yml` runs on `release.published`; it checks
-the tag against `package.json`, runs the full gate and package smoke, then
-publishes the validated tarball through OIDC with provenance. The publish job
-has no source checkout or build scripts. A manual dispatch with an existing
-release tag is available for recovery after a verified publication failure.
-Check npm before retrying; released versions are immutable.
+the tag against `package.json`, runs the full gate and both package smokes, then
+publishes the root tarball through OIDC with provenance. The DSH smoke installs
+that same tarball directly into an isolated DSH profile, so no second npm
+package or Trusted Publishing binding is needed. The publish job has no source
+checkout or build scripts. A manual dispatch with an existing release tag is
+available for recovery after a verified publication failure. Check npm before
+retrying; released versions are immutable.