kimi-plugin-cc 2.4.5 → 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

package/plugins/kimi-dsh/dist/background-spawn.js

@@ -0,0 +1,216 @@
+import { spawn } from "node:child_process";
+import { access, appendFile, constants as fsConstants } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { RuntimeError, formatError } from "./errors.js";
+import { preferStableNodePath } from "./hooks/install-paths.js";
+import { markJobFailed, waitForTerminalJob } from "./jobs.js";
+import { JobStore } from "./job-store.js";
+import { readArtifact } from "./render.js";
+// Resolves to runtime/companion.ts in dev (via tsx) and dist/companion.js in production (compiled
+// with tsc to the same relative layout). The extension is derived from the running module so the
+// child-process spawn in startBackgroundJob targets the right entrypoint in both modes.
+const isCompiledRuntime = import.meta.url.endsWith(".js");
+const companionEntrypoint = fileURLToPath(new URL(isCompiledRuntime ? "./companion.js" : "./companion.ts", import.meta.url));
+const companionProjectRoot = path.resolve(path.dirname(companionEntrypoint), "..");
+const FAILURE_PERSIST_RETRY_DELAYS_MS = [100, 200, 400];
+export async function startBackgroundJob(job, prompt, context, paths, options) {
+    // Background spawn and hook verification must resolve the same stable Node
+    // path: the worker re-verifies the byte-exact hook command from its own
+    // runtime path, so a different spelling than setup pinned fails closed. For
+    // example, spawn(process.execPath) can resolve …/Cellar/node/<ver>/bin/node
+    // while setup pinned /opt/homebrew/bin/node.
+    //
+    // An explicit spawn override need not be absolute because spawn() resolves
+    // bare names through PATH. The hook command separately requires an absolute
+    // override because /bin/sh -c may have a sanitized PATH. Only the no-override
+    // default uses preferStableNodePath to match the verifier.
+    const override = context.env.KIMI_PLUGIN_CC_NODE_BIN;
+    const nodeBinary = override !== undefined && override.length > 0
+        ? override
+        : preferStableNodePath(process.execPath);
+    // Only fast-path the `fs.access` check for absolute/relative paths. A bare
+    // name like "node" is resolved by spawn() via PATH; the spawn `error` listener
+    // will still surface ENOENT on nextTick for that path, classified as
+    // spawnFailedErrorCode via the listener below.
+    if (nodeBinary.includes("/") || nodeBinary.includes("\\")) {
+        try {
+            await access(nodeBinary, fsConstants.X_OK);
+        }
+        catch (accessError) {
+            const code = accessError.code;
+            if (code === "ENOENT" || code === "EACCES" || code === "EPERM") {
+                const classified = new RuntimeError(options.nodeBinInvalidErrorCode, `Configured Node binary is not executable: ${nodeBinary}. Set KIMI_PLUGIN_CC_NODE_BIN to a valid Node >=22.5 executable and retry.`, options.spawnStage, accessError instanceof Error ? { cause: accessError } : undefined);
+                await persistBackgroundFailure(paths, job.job_id, classified, options.failedSummary, "node-bin-invalid");
+                throw classified;
+            }
+            // Any other errno (EIO, etc.) — fall through to the spawn attempt and let the
+            // existing spawn error path surface it.
+        }
+    }
+    const b64 = Buffer.from(prompt, "utf8").toString("base64");
+    const spawnArgs = isCompiledRuntime
+        ? [companionEntrypoint, "worker", options.workerKind, job.job_id]
+        : ["--import", "tsx", companionEntrypoint, "worker", options.workerKind, job.job_id];
+    const child = spawn(nodeBinary, spawnArgs, {
+        cwd: companionProjectRoot,
+        detached: true,
+        stdio: "ignore",
+        env: {
+            ...context.env,
+            KIMI_PLUGIN_CC_WORKSPACE_CWD: context.cwd,
+            [options.promptEnvVar]: b64,
+            [options.reusedSessionEnvVar]: options.reusedSession ? "1" : "0",
+            ...(options.extraEnv ?? {}),
+            // A worker must reopen the exact store its parent selected, regardless of cwd.
+            KIMI_PLUGIN_CC_DATA: path.resolve(paths.claudePluginData),
+        },
+    });
+    let spawnReportedFailure = false;
+    const spawnErrorPromise = new Promise((resolve) => {
+        let settled = false;
+        const settle = (value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            resolve(value);
+        };
+        child.once("error", (spawnError) => {
+            spawnReportedFailure = true;
+            settle(new RuntimeError(options.spawnFailedErrorCode, `Background ${options.workerKind} worker failed to spawn: ${spawnError.message}`, options.spawnStage, { cause: spawnError }));
+        });
+        // Give the event loop one tick to deliver a synchronous spawn error
+        // (ENOENT fires on process.nextTick). If nothing fires by then, the
+        // child is live and we can proceed.
+        setImmediate(() => settle(null));
+    });
+    child.on("close", (exitCode, signal) => {
+        if (spawnReportedFailure) {
+            return;
+        }
+        if (exitCode === null || exitCode === 0) {
+            return;
+        }
+        // The worker exited non-zero before any state update. If the job is
+        // still in its spawn phase, the worker never reached executeJob.
+        const classified = new RuntimeError(options.earlyExitErrorCode, `Background ${options.workerKind} worker exited with code ${exitCode}${signal ? ` (signal ${signal})` : ""} before reporting a result.`, options.spawnStage);
+        void markEarlyExit(paths, job.job_id, classified, options.failedSummary);
+    });
+    child.unref();
+    const spawnError = await spawnErrorPromise;
+    if (spawnError) {
+        await markSpawnFailure(paths, job.job_id, spawnError, options.failedSummary);
+        throw spawnError;
+    }
+    const store = new JobStore(paths);
+    try {
+        store.updateRunningJob(job.job_id, {
+            pid: child.pid ?? null,
+            phase: "worker-spawned",
+        });
+    }
+    finally {
+        store.close();
+    }
+    if (options.wait) {
+        const completed = await waitForTerminalJob(() => new JobStore(paths), job.job_id);
+        if (!completed.final_output_path) {
+            throw new RuntimeError(options.missingResultErrorCode, describeMissingResult(completed, options.workerKind), options.waitStage);
+        }
+        return readArtifact(completed.final_output_path);
+    }
+    return `${JSON.stringify({
+        job_id: job.job_id,
+        command_type: job.command_type,
+    }, null, 2)}\n`;
+}
+async function markSpawnFailure(paths, jobId, classified, failedSummary) {
+    await persistBackgroundFailure(paths, jobId, classified, failedSummary, "spawn-failed");
+}
+async function markEarlyExit(paths, jobId, classified, failedSummary) {
+    await persistBackgroundFailure(paths, jobId, classified, failedSummary, "early-exit", (current) => {
+        // Only mark failure if the worker exited before advancing past the spawn phase.
+        // Once the worker reaches worker-running or turn-running, the child owns the
+        // job state and the parent's close listener must not race with it.
+        return current.phase === "worker-spawned" || current.phase === "queued";
+    });
+}
+async function persistBackgroundFailure(paths, jobId, classified, failedSummary, event, shouldMark = () => true) {
+    let lastWriteError;
+    for (let attempt = 0; attempt <= FAILURE_PERSIST_RETRY_DELAYS_MS.length; attempt += 1) {
+        let store;
+        try {
+            store = new JobStore(paths);
+            const current = store.getJob(jobId);
+            if (!current || current.status !== "running" || !shouldMark(current)) {
+                return;
+            }
+            await markJobFailed(store, paths, current, classified, failedSummary, { phase: "failed" });
+            return;
+        }
+        catch (writeError) {
+            lastWriteError = writeError;
+            if (attempt < FAILURE_PERSIST_RETRY_DELAYS_MS.length) {
+                await sleep(FAILURE_PERSIST_RETRY_DELAYS_MS[attempt]);
+            }
+        }
+        finally {
+            try {
+                store?.close();
+            }
+            catch {
+                // The persistence attempt outcome above is the signal that matters.
+            }
+        }
+    }
+    await appendStuckJobTelemetry(paths, {
+        event,
+        job_id: jobId,
+        failed_summary: failedSummary,
+        error: {
+            code: classified.code,
+            stage: classified.stage,
+            message: classified.message,
+            details: classified.details,
+        },
+        persistence_error: formatError(lastWriteError),
+    });
+}
+async function appendStuckJobTelemetry(paths, entry) {
+    const stuckPath = path.join(paths.pluginRoot, "stuck-jobs.jsonl");
+    try {
+        await appendFile(stuckPath, `${JSON.stringify({ ts: new Date().toISOString(), ...entry })}\n`, "utf8");
+    }
+    catch (appendError) {
+        process.stderr.write(`[kimi-plugin-cc] failed to append stuck job telemetry at ${stuckPath}: ${formatError(appendError)}\n`);
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+/**
+ * Builds a descriptive message for the rare edge case where `waitForTerminalJob`
+ * returns a terminal job whose `final_output_path` is null (e.g. `markJobFailed`'s
+ * own artifact write failed). The normal background --wait failure path returns
+ * the rendered failure artifact via `readArtifact` — that artifact already
+ * carries the code, stage, and message via `renderTerminalJobArtifact`. This
+ * helper is belt-and-suspenders for the near-unreachable case where even the
+ * failure artifact could not be written. Intended for terminal job records only;
+ * a running record would render the generic "finished without a rendered result."
+ * sentence, which would be misleading.
+ */
+export function describeMissingResult(job, workerKind = "rescue") {
+    const base = `Background ${workerKind} job ${job.job_id} finished without a rendered result`;
+    if (job.status === "failed" || job.status === "cancelled") {
+        const code = job.error?.code || "unknown";
+        const stage = job.error?.stage || "unknown";
+        // `||` (not `??`) intentionally: empty-string error.message or summary
+        // should fall through to the next fallback, not render as blank.
+        const detail = job.error?.message || job.summary || "no further detail";
+        return `${base} (${job.status}, ${code}, stage ${stage}): ${detail}`;
+    }
+    return `${base}.`;
+}

package/plugins/kimi-dsh/dist/cli-cancellation.js

@@ -0,0 +1,43 @@
+import process from "node:process";
+export function createCliCancellationHandlers() {
+    const controller = new AbortController();
+    let cancelling = false;
+    let disposed = false;
+    const onSignal = () => {
+        if (cancelling)
+            return;
+        cancelling = true;
+        // Abort BEFORE running through dispose — the cli-client may still be
+        // in its pre-spawn signal check or its post-spawn wait, both of which
+        // honor signal.aborted.
+        try {
+            controller.abort();
+        }
+        catch {
+            // AbortController.abort() can't throw in standard runtimes, but
+            // belt-and-suspenders for runtime quirks (e.g. test harnesses
+            // overriding global AbortController).
+        }
+    };
+    // Use `process.on` (not `once`) so dispose() can remove the listener
+    // via the function reference. `process.once` wraps the callback
+    // internally and depending on Node version removeListener may miss it.
+    // Idempotency comes from the `if (cancelling) return` guard.
+    process.on("SIGTERM", onSignal);
+    process.on("SIGINT", onSignal);
+    return {
+        get cancelling() {
+            return cancelling;
+        },
+        get signal() {
+            return controller.signal;
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            process.off("SIGTERM", onSignal);
+            process.off("SIGINT", onSignal);
+        },
+    };
+}