kimi-plugin-cc 2.4.4 → 2.5.1

package/plugins/kimi-codex/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/plugins/kimi-codex/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/plugins/kimi-codex/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/plugins/kimi-codex/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([

package/plugins/kimi-codex/dist/swarm-activation.js

@@ -9,7 +9,7 @@ import { assertExecutionPlanMatchesSpawn, assertNoUnsafeExperimentalSelector, }
 import { resolveKimiHome } from "./kimi-home.js";
 import { assertNativeV2Preflight } from "./native-v2-preflight.js";
 import { collectDescendantIdentities, collectProcessGroupsIdentities, probeProcessIdentity, revalidateProcessIdentities, waitForProcessTreeExit, } from "./process-tree.js";
-const PREACTIVATION_VERSIONS = ["2.3.2", "2.3.3", "2.4.0"];
+const PREACTIVATION_VERSIONS = ["2.3.2", "2.3.3", "2.4.0", "2.4.1"];
 const READY_TIMEOUT_MS = 10_000;
 const REST_TIMEOUT_MS = 5_000;
 // Exact 2.4.0 can take longer than 5s to drain session/workspace lifecycle work.

package/plugins/kimi-codex/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.4";
+export const KIMI_PLUGIN_CC_VERSION = "2.5.1";

package/plugins/kimi-dsh/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for describing the origin of the Work and
+      reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Support. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or support.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed line" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 linxule
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied. See the License for the specific language governing
+   permissions and limitations under the License.

package/plugins/kimi-dsh/README.md

@@ -0,0 +1,80 @@
+# kimi-plugin-cc for DeepSeek Harness
+
+Kimi Code subagents for DeepSeek Harness (DSH), backed by the same companion runtime as the Claude Code and Codex plugins.
+
+## What this bundle provides
+
+| Tool | Operation | File access |
+|---|---|---|
+| `kimi_ask` | Answer a self-contained repository question | Read-only |
+| `kimi_review` | Review the working tree, including untracked files | Read-only |
+| `kimi_challenge` | Challenge assumptions and design choices | Read-only |
+| `kimi_rescue` | Investigate and implement a bounded fix | Can edit the selected workspace |
+| `kimi_pursue` | Pursue an autonomous multi-turn objective with a finite budget | Can edit the selected workspace |
+| `kimi_swarm` | Fan out independent read-only subagents | Read-only |
+| `kimi_swarm_write` | Edit disjoint targets in a temporary worktree and return a patch | Patch only; never applies or commits |
+
+Every activation starts a fresh companion and Kimi CLI process. The existing runtime owns hook verification, exact Kimi-version certification, SQLite jobs, response or safety budgets, artifacts, and process teardown. DSH owns delegation identity and completion notices. Parent conversations do not flow into the child, and child tool traffic stays out of the parent conversation.
+
+Job controls are `/kimi-status [job-id]`, `/kimi-result [job-id]`, and `/kimi-cancel [job-id]`. Without an id, status and result select the latest job for the current repository, and cancel selects the latest active job. Cancellation stops work but does not roll back changes or patches already produced.
+
+## Requirements
+
+- Node.js 24.9.0 or later.
+- DeepSeek Harness >=0.2.1-rc.5 <0.3.0; this package is developed and composed against 0.2.1-rc.5.
+- Kimi Code CLI on `PATH`, authenticated and configured through Kimi. The companion's exact-version certification table remains authoritative.
+
+## Install
+
+From this repository checkout:
+
+```sh
+dsh plugin --profile web add ./plugins/kimi-dsh
+```
+
+For another DSH profile, replace `web` with its name. To install the published root package instead, run `dsh plugin --profile web add kimi-plugin-cc`.
+
+Restart when requested, then run `/kimi-setup`. Setup is explicit: installing or enabling the bundle does not modify Kimi configuration. Delegation refuses to start when the DSH managed hook is missing or invalid.
+
+Useful setup commands:
+
+```text
+/kimi-setup --check
+/kimi-setup --models
+/kimi-setup --models --json
+/kimi-setup --uninstall
+```
+
+Model inventory is local and credential-safe; it is not a connection test. Uninstall removes only the DSH managed block. The all-host `--uninstall --all` action is deliberately not exposed through the DSH command.
+
+## Use
+
+Ask DSH to use one of the seven tools with a self-contained task. Each accepts a description, prompt, and optional working directory, returns an activation id, and delivers the final result when the companion finishes. Review and challenge treat the prompt as focus text. Pursue and swarm operations retain their existing finite default budgets; swarm-write returns the captured patch path without applying it.
+
+Prefer `/kimi-cancel` for stopping work when possible. DSH cancellation also terminates the managed subprocess range and waits for quiescence.
+
+## Configuration
+
+The bundle's `kimi-plugin-cc` row accepts:
+
+| Field | Default | Meaning |
+|---|---|---|
+| `dataRoot` | `$DSH_HOME/plugin-data/kimi-plugin-cc` | Absolute companion data directory; `KIMI_PLUGIN_CC_DATA` overrides the derived default |
+| `env` | `{}` | Explicit child environment layered over DSH's credential-scrubbed environment |
+| `disposeGraceMs` | `6000` | Managed subprocess termination grace |
+| `maxOutputBytes` | `16777216` | Maximum captured stdout or stderr bytes per command |
+| `model` | Native Kimi default | Optional configured model alias applied to every delegation |
+| `thinkingEffort` | Native Kimi default | Optional per-run thinking effort request |
+| `budget` | Existing command default | Optional duration such as `30m`, `1h`, or `90s`, validated at load and capped at 24h |
+| `reviewBase` | Working tree | Optional Git base applied only to review and challenge |
+
+Host identity, workspace, hook path, Node binary, and bypass variables are provider-owned and cannot be replaced through `env`. The DSH managed block uses host id `dsh`; Claude Code and Codex blocks remain independent. Native Kimi authentication and provider configuration stay under `KIMI_CODE_HOME` or `~/.kimi-code`.
+
+## Limits
+
+- Activations are one-shot and do not accept follow-up input, parent-context inheritance, per-call model overrides, output schemas, or Harness depth enforcement. Use profile configuration for a fixed model or thinking request; interactive ask/rescue resume stays outside the DSH provider.
+- DSH activation ids are not companion job ids. Use the slash commands to inspect companion state.
+- There is no child progress stream. Response-time budgets, safety ceilings, and timeout artifacts follow the existing companion rules.
+- The parent receives final stdout only on success. stderr stays on the host; failures use bounded diagnostics without task text, credentials, or raw protocol payloads.
+- This package does not create an account, select a provider, repair Kimi authentication, or provide an approval channel beyond the companion's managed PreToolUse policy.
+- Rescue and pursue edit the real selected workspace. Swarm-write works from born HEAD in a temporary worktree, excludes uncommitted changes, and returns a patch without applying or committing it.

package/plugins/kimi-dsh/cordis.patch.yml

@@ -0,0 +1,45 @@
+- insert:
+    - id: kimi-plugin-cc
+      name: 'kimi-plugin-cc'
+    - id: tool-kimi-ask
+      name: '@deepseek-ai/dsh-tool-subagent'
+      config:
+        provider: kimi-ask
+        toolName: kimi_ask
+        maxDepth: provider-managed
+    - id: tool-kimi-review
+      name: '@deepseek-ai/dsh-tool-subagent'
+      config:
+        provider: kimi-review
+        toolName: kimi_review
+        maxDepth: provider-managed
+    - id: tool-kimi-challenge
+      name: '@deepseek-ai/dsh-tool-subagent'
+      config:
+        provider: kimi-challenge
+        toolName: kimi_challenge
+        maxDepth: provider-managed
+    - id: tool-kimi-rescue
+      name: '@deepseek-ai/dsh-tool-subagent'
+      config:
+        provider: kimi-rescue
+        toolName: kimi_rescue
+        maxDepth: provider-managed
+    - id: tool-kimi-pursue
+      name: '@deepseek-ai/dsh-tool-subagent'
+      config:
+        provider: kimi-pursue
+        toolName: kimi_pursue
+        maxDepth: provider-managed
+    - id: tool-kimi-swarm
+      name: '@deepseek-ai/dsh-tool-subagent'
+      config:
+        provider: kimi-swarm
+        toolName: kimi_swarm
+        maxDepth: provider-managed
+    - id: tool-kimi-swarm-write
+      name: '@deepseek-ai/dsh-tool-subagent'
+      config:
+        provider: kimi-swarm-write
+        toolName: kimi_swarm_write
+        maxDepth: provider-managed