kimi-plugin-cc 2.4.5 → 2.5.2

package/dist/dsh/companion.js

@@ -0,0 +1,177 @@
+import { randomUUID } from "node:crypto";
+import { brandString } from "@deepseek-ai/dsh-brand";
+import { assertUsableCwd, settleRunResult, subprocessRunHandle, } from "@deepseek-ai/dsh-subagent";
+import { preferStableNodePath } from "../hooks/install-paths.js";
+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 = preferStableNodePath(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 = preferStableNodePath(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 {
+        const nodeBin = preferStableNodePath(process.execPath);
+        child = spec.spawn({
+            argv: companionArgv(operation, prompt, spec.companionPath, nodeBin, spec),
+            cwd,
+            stdio: {
+                stdin: "ignore",
+                stdout: { maxBytes: spec.maxOutputBytes },
+                stderr: "inherit",
+            },
+            graceMs: spec.disposeGraceMs,
+            signal: termination.signal,
+            env: companionEnvironment(spec.dataRoot, cwd, spec.env, nodeBin),
+        });
+    }
+    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 nodeBin = preferStableNodePath(process.execPath);
+    const child = spec.spawn({
+        argv: [nodeBin, 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, nodeBin),
+    });
+    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,169 @@
+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"];
+export const DSH_TOOL_GUIDANCE = [
+    "Kimi delegation tools have different write boundaries:",
+    "kimi_ask, kimi_review, and kimi_challenge are read-only; kimi_swarm is a read-only parallel review.",
+    "kimi_rescue and kimi_pursue can edit the selected workspace; kimi_pursue continues toward a bounded goal.",
+    "kimi_swarm_write edits a temporary worktree and returns a patch without applying it.",
+].join(" ");
+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 < DEFAULT_DISPOSE_GRACE_MS || resolved.disposeGraceMs > MAX_TIMER_DELAY_MS) {
+        throw new Error(`kimi-plugin-cc: disposeGraceMs must be at least ${DEFAULT_DISPOSE_GRACE_MS} 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(["systemPrompt"], (promptCtx) => {
+        promptCtx.systemPrompt.section({
+            name: "kimi-plugin-cc:tool-boundaries",
+            order: promptCtx.systemPrompt.getSectionOrder("TOOL_SUBAGENT"),
+            text: () => DSH_TOOL_GUIDANCE,
+        });
+    });
+    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/hooks/managed-block.js

@@ -45,10 +45,80 @@ const MATCHER_LINE_RE = /^matcher\s*=/;
 /** `timeout = <int>` — the only other key our managed [[hooks]] table emits. */
 const TIMEOUT_LINE_RE = /^timeout\s*=\s*\d+\s*$/;
 const HOOKS_TABLE_RE = /^\[\[hooks\]\]\s*$/;
+// Recognize comment lines lexically, not text inside TOML string values.
+// Whole-document parsing remains the authority for TOML validity.
+function scanTomlLines(contents) {
+    const markers = new Set();
+    const tables = new Set();
+    let state = "plain";
+    let line = 0;
+    let blankPrefix = true;
+    for (let i = 0; i < contents.length; i += 1) {
+        const c = contents[i];
+        if (c === "\n") {
+            line += 1;
+            blankPrefix = true;
+            continue;
+        }
+        const onlyWhitespaceBefore = blankPrefix;
+        if (c !== " " && c !== "\t" && c !== "\r")
+            blankPrefix = false;
+        if (state === "plain") {
+            if (c === "[" && onlyWhitespaceBefore)
+                tables.add(line);
+            if (c === "#") {
+                if (onlyWhitespaceBefore) {
+                    const end = contents.indexOf("\n", i);
+                    const comment = contents.slice(i, end < 0 ? contents.length : end).trim();
+                    if (BEGIN_LINE_RE.test(comment) || END_LINE_RE.test(comment))
+                        markers.add(line);
+                }
+                const end = contents.indexOf("\n", i);
+                if (end < 0)
+                    break;
+                i = end - 1;
+            }
+            else if (c === '"' || c === "'") {
+                const triple = contents.slice(i, i + 3) === c.repeat(3);
+                state = c === '"' ? (triple ? "multibasic" : "basic") : (triple ? "multiliteral" : "literal");
+                if (triple)
+                    i += 2;
+            }
+        }
+        else {
+            const basic = state === "basic" || state === "multibasic";
+            const quote = basic ? '"' : "'";
+            if (basic && c === "\\") {
+                if (contents[i + 1] === "\n") {
+                    line += 1;
+                    blankPrefix = true;
+                }
+                i += 1;
+                continue;
+            }
+            if (c !== quote)
+                continue;
+            if (state === "basic" || state === "literal")
+                state = "plain";
+            else if (contents.slice(i, i + 3) === quote.repeat(3)) {
+                while (contents[i + 1] === quote)
+                    i += 1;
+                state = "plain";
+            }
+        }
+    }
+    return { markers, tables };
+}
+export function markerCommentLines(contents) {
+    return scanTomlLines(contents).markers;
+}
 /** Locate every BEGIN/END marker line, in order, with its parsed host id. */
 function findMarkers(lines) {
     const hits = [];
+    const comments = markerCommentLines(lines.join("\n"));
     for (let i = 0; i < lines.length; i += 1) {
+        if (!comments.has(i))
+            continue;
         const trimmed = lines[i].trim();
         const begin = BEGIN_LINE_RE.exec(trimmed);
         if (begin !== null) {
@@ -66,7 +136,7 @@ function findMarkers(lines) {
 }
 /**
  * Pair BEGIN/END markers into well-formed blocks. Return the first orphan
- * (BEGIN-without-END or END-without-BEGIN); either is a hard error for install.
+ * (BEGIN-without-END or END-without-BEGIN); verification fails closed on either.
  */
 function pairBlocks(lines) {
     const markers = findMarkers(lines);
@@ -83,6 +153,8 @@ function pairBlocks(lines) {
         // end
         if (open === null)
             return { orphan: "END-without-BEGIN" };
+        if (open.hostId !== marker.hostId)
+            return { orphan: "BEGIN-without-END" };
         const body = validateBlockBody(lines.slice(open.index + 1, marker.index));
         blocks.push({
             hostId: open.hostId,
@@ -436,13 +508,13 @@ export function evaluateInstalled(contents, expectedCommand, opts) {
  * The deletion range `[start, end)` is conservative: only the contiguous
  * non-blank body after `[[hooks]]`, stopping at a blank line, table header, or
  * managed marker so adjacent user content is preserved. A separate full-span
- * scan rejects matcher lines recognized by MATCHER_LINE_RE to avoid half-cutting
- * a table. That scan is deliberately heuristic and does not claim to recognize
- * every quoted or dotted TOML matcher spelling. `command` is decoded for the
- * caller's ownership checks.
+ * scan refuses any further TOML field before the next table, including quoted
+ * and dotted keys, so pruning cannot attach those fields to another table.
+ * `command` is decoded for the caller's ownership checks.
  */
 export function findBareApprovalHookTables(contents) {
     const lines = contents.split("\n").map((line) => line.replace(/\r$/, ""));
+    const tableLines = scanTomlLines(contents).tables;
     const managed = new Set();
     const paired = pairBlocks(lines);
     if ("blocks" in paired) {
@@ -455,7 +527,7 @@ export function findBareApprovalHookTables(contents) {
     for (let i = 0; i < lines.length; i += 1) {
         if (managed.has(i))
             continue;
-        if (!HOOKS_TABLE_RE.test(lines[i].trim()))
+        if (!tableLines.has(i) || !HOOKS_TABLE_RE.test(lines[i].trim()))
             continue;
         // Collect the contiguous table body.
         let j = i + 1;
@@ -500,22 +572,16 @@ export function findBareApprovalHookTables(contents) {
             }
             j += 1;
         }
-        // A blank line does NOT end a TOML table; membership continues to the next
-        // header or EOF. The deletion range nevertheless stops at the blank to
-        // preserve adjacent user content. Scan the remaining span for matcher lines
-        // this scanner recognizes and reject the table rather than half-cutting it:
-        // matcher is schema-valid but can disable the hook at runtime. Foreign keys
-        // and other TOML spellings are handled by whole-file schema validation and
-        // the parser-based installed checks, not by this prune heuristic.
-        let matcherBeyondBody = false;
+        // Blank lines and marker comments do not end a TOML table. Never leave any
+        // field behind to be rebound to a preceding table after pruning, regardless
+        // of the field's spelling or whether it is valid for a hook.
+        let fieldBeyondBody = false;
         for (let k = j; k < lines.length; k += 1) {
             const t = lines[k].trim();
-            // The current table's TOML span ends at the next table header or a
-            // managed marker; a matcher past that point belongs to a different table.
-            if (t.startsWith("[") || BEGIN_LINE_RE.test(t) || END_LINE_RE.test(t))
+            if (tableLines.has(k))
                 break;
-            if (MATCHER_LINE_RE.test(t)) {
-                matcherBeyondBody = true;
+            if (t.length > 0 && !t.startsWith("#")) {
+                fieldBeyondBody = true;
                 break;
             }
         }
@@ -527,7 +593,7 @@ export function findBareApprovalHookTables(contents) {
             commandDecoded.length > 0 &&
             hasPreToolUseEvent &&
             !hasMatcher &&
-            !matcherBeyondBody) {
+            !fieldBeyondBody) {
             ranges.push({ start: i, end: j, command: commandDecoded });
         }
     }

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.2";

package/docs/migration.md

@@ -1,6 +1,8 @@
 # Compatibility and upgrades
 
-Plugin 2.4.5 certifies Kimi Code CLI 2.4.1 for all eight operations, alongside exact native-v2 versions `0.42.0`, `0.43.0`, `0.43.1`, `2.0.0`, `2.0.1`, `2.0.2`, `2.1.0`, `2.1.1`, `2.2.0`, `2.3.0`, `2.3.1`, `2.3.2`, `2.3.3`, and `2.4.0`. Later patches and minor releases are not accepted automatically. The npm distribution adds an installation channel; it does not change this compatibility table.
+Plugin 2.5.1 certifies Kimi Code CLI 2.4.1 for all eight operations, alongside exact native-v2 versions `0.42.0`, `0.43.0`, `0.43.1`, `2.0.0`, `2.0.1`, `2.0.2`, `2.1.0`, `2.1.1`, `2.2.0`, `2.3.0`, `2.3.1`, `2.3.2`, `2.3.3`, and `2.4.0`. Later patches and minor releases are not accepted automatically. The npm distribution adds an installation channel; it does not change this compatibility table.
+
+Plugin 2.5.1 also adds DeepSeek Harness as a third host with all seven operations and a DSH-specific bundle, data root, and managed hook id. Existing Claude Code and Codex certification, job stores, and host-scoped hooks are unchanged; no migration is required for those hosts. New DSH installations follow the [README DSH section](../README.md#install-in-deepseek-harness), including `/kimi-setup` on that host.
 
 Explicitly pinned legacy-v1 binaries remain supported within `KIMI_TESTED_MINORS`, through 0.41.x, subject to each operation's minimum version. The [runtime table](../runtime/kimi-engine.ts) is the authority.
 
@@ -8,7 +10,7 @@ Use the [README installation and update steps](../README.md) for Claude Code or
 
 ## Plugin versions and upgrades
 
-Plugin versions advance independently using ordinary SemVer and may deliberately align with a certified CLI release. Plugin 2.4.5 certifies exact CLI 2.4.1; the nearby numbers do not imply version alignment. Published versions and tags are never reused. Every upstream patch requires its own certification. The native-v2 no-plan profile, plugin/marketplace IDs and existing job store are preserved.
+Plugin versions advance independently using ordinary SemVer and may deliberately align with a certified CLI release. Plugin 2.5.1 certifies exact CLI 2.4.1; the nearby numbers do not imply version alignment. Published versions and tags are never reused. Every upstream patch requires its own certification. The native-v2 no-plan profile, plugin/marketplace IDs and existing job store are preserved.
 
 ## CLI 2.3.2, 2.3.3, 2.4.0 and 2.4.1 swarm activation
 

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.