kimi-plugin-cc 2.4.5 → 2.5.1

package/plugins/kimi-dsh/dist/kimi-errors.js

@@ -0,0 +1,260 @@
+import { RuntimeError, formatError } from "./errors.js";
+const BUDGET_CEILING_MS = 24 * 60 * 60 * 1_000;
+function formatBudgetMs(ms) {
+    if (ms % 3_600_000 === 0)
+        return `${ms / 3_600_000}h`;
+    if (ms % 60_000 === 0)
+        return `${ms / 60_000}m`;
+    return `${Math.ceil(ms / 1_000)}s`;
+}
+/**
+ * Suggest a concrete next budget from the one that just expired: double it,
+ * capped at the 24h ceiling. At the ceiling there is nothing left to raise,
+ * so the only honest advice is to narrow the prompt.
+ */
+function budgetAdvice(budgetMs) {
+    if (budgetMs === undefined || !Number.isFinite(budgetMs) || budgetMs <= 0)
+        return "raise the budget (`--budget <dur>`, at most 24h)";
+    if (budgetMs >= BUDGET_CEILING_MS)
+        return "note the budget is already at the 24h ceiling, so narrowing the prompt is the only remaining lever";
+    return `raise the budget (e.g. \`--budget ${formatBudgetMs(Math.min(budgetMs * 2, BUDGET_CEILING_MS))}\`)`;
+}
+export function classifyManagedCommandFailure(error, commandType, jobId, options) {
+    const classification = classifyKimiAvailability(error);
+    if (!classification) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    if (classification.kind === "response_timeout" && commandType !== "review_gate" && options?.background !== undefined) {
+        const foregroundAdvice = !options?.background && (commandType === "ask" || commandType === "rescue")
+            ? " Or run with --background so the caller's shell timeout is not the limit."
+            : "";
+        classification.nextStep = `Narrow the prompt or ${budgetAdvice(options.budgetMs)}. Partial output, if any, is in the artifact (\`result ${jobId}\`).${foregroundAdvice}`;
+    }
+    const label = formatCommandLabel(commandType);
+    const stage = options?.preserveStage && error instanceof RuntimeError
+        ? error.stage
+        : `${commandType}.runtime`;
+    // Thread the cause's code and message into `details` so the underlying
+    // failure survives the wrap on every channel (formatError renders details
+    // as a JSON line; normalizeJobError persists them in the job row). Without
+    // this, a CLI_NONZERO_EXIT whose message embeds kimi's stderr tail (e.g.
+    // `auth.login_required` on 2026-08-08) was reduced to the generic
+    // "run /kimi:setup" advice with the real cause reachable only as `cause`,
+    // which no output channel serializes — an LLM caller could not diagnose it.
+    const details = { availability: classification.kind };
+    if (error instanceof RuntimeError) {
+        details.cause_code = error.code;
+        for (const key of ["spawn_code", "spawn_errno", "spawn_message"]) {
+            if (error.details[key] !== undefined)
+                details[key] = key === "spawn_message" && typeof error.details[key] === "string"
+                    ? truncateCauseMessageForDetails(error.details[key]) : error.details[key];
+        }
+        if (error.code === "RESPONSE_TIMEOUT") {
+            for (const key of ["budget_ms", "record_count", "partial_output_chars", "aborted", "settled_post_abort", "hook_escapes"]) {
+                if (error.details[key] !== undefined)
+                    details[key] = error.details[key];
+            }
+            if (details.budget_ms === undefined && options?.budgetMs !== undefined)
+                details.budget_ms = options.budgetMs;
+        }
+    }
+    if (error instanceof Error && error.message.length > 0) {
+        details.cause_message = truncateCauseMessageForDetails(error.message);
+    }
+    return new RuntimeError(mapAvailabilityCode(classification.kind, commandType), `${label} could not run because ${classification.summary} ${classification.nextStep} Job ${jobId} was persisted as failed.`, stage, error instanceof Error ? { cause: error, details } : { details });
+}
+/**
+ * Cap the cause message carried in `details` so a large stderr tail cannot
+ * bloat the SQLite job row or the rendered details JSON line. Keep the TAIL
+ * end: for a crashed subprocess the informative lines (kimi's own `error:`
+ * output) are the trailing bytes of stderr, which cli-helpers appends last.
+ */
+const CAUSE_MESSAGE_DETAILS_MAX = 2000;
+function truncateCauseMessageForDetails(message) {
+    if (message.length <= CAUSE_MESSAGE_DETAILS_MAX) {
+        return message;
+    }
+    return `…${message.slice(-CAUSE_MESSAGE_DETAILS_MAX)}`;
+}
+export function summarizeKimiAvailabilityWarning(error, commandType) {
+    const classification = classifyKimiAvailability(error);
+    if (!classification) {
+        return null;
+    }
+    if (classification.kind === "auth_unavailable") {
+        return `Kimi ${formatCommandLabel(commandType).toLowerCase()} is not configured for model access; allowing stop.`;
+    }
+    if (classification.kind === "binary_unavailable") {
+        return `Kimi ${formatCommandLabel(commandType).toLowerCase()} could not find the Kimi CLI; allowing stop.`;
+    }
+    if (classification.kind === "startup_failed") {
+        return `Kimi ${formatCommandLabel(commandType).toLowerCase()} could not start a usable Kimi subprocess; allowing stop.`;
+    }
+    switch (classification.kind) {
+        case "startup_timeout":
+            return `Kimi ${formatCommandLabel(commandType).toLowerCase()} did not respond during startup; allowing stop.`;
+        case "initialize_timeout":
+            return `Kimi ${formatCommandLabel(commandType).toLowerCase()} did not complete session initialization; allowing stop.`;
+        case "response_timeout":
+            return `Kimi ${formatCommandLabel(commandType).toLowerCase()} did not return a final response; allowing stop.`;
+        case "max_steps_reached":
+            return `Kimi ${formatCommandLabel(commandType).toLowerCase()} exhausted its step budget; allowing stop.`;
+        case "timeout":
+            return `Kimi ${formatCommandLabel(commandType).toLowerCase()} timed out; allowing stop.`;
+    }
+}
+export function classifySetupFailure(error) {
+    return classifyKimiAvailability(error);
+}
+function classifyKimiAvailability(error) {
+    const message = formatError(error);
+    // kimi-code's managed OAuth store emits `auth.login_required: OAuth
+    // provider "managed:kimi-code" requires login…` on stderr when the token
+    // is missing or expired (observed on 0.34.0 after an out-of-band binary
+    // upgrade invalidated the token). The line reaches us inside the
+    // CLI_NONZERO_EXIT message because cli-helpers embeds the stderr tail.
+    // This MUST precede the code-based CLI_NONZERO_EXIT branch below, which
+    // would otherwise misclassify a logged-out CLI as startup_failed and
+    // point the user at /kimi:setup — which cannot fix auth.
+    if (message.includes("auth.login_required")) {
+        return {
+            kind: "auth_unavailable",
+            summary: "the local Kimi CLI is logged out (its OAuth login is missing or expired).",
+            nextStep: "Run `kimi login` to re-authenticate, then retry. `/kimi:setup` does not repair auth.",
+            runtimeProbe: "ok",
+            authProbe: "failed",
+        };
+    }
+    if (message.includes("LLM is not set") || message.includes("LLM service error")) {
+        return {
+            kind: "auth_unavailable",
+            summary: "local Kimi authentication or model configuration is not usable.",
+            nextStep: "Run `/kimi:setup`, then `kimi login` or fix the local Kimi model configuration and retry.",
+            runtimeProbe: "ok",
+            authProbe: "failed",
+        };
+    }
+    if (error instanceof RuntimeError &&
+        (error.code === "CLI_SPAWN_FAILED" || error.code === "CLI_PROCESS_ERROR")) {
+        const spawnCode = error.details.spawn_code;
+        const binaryUnavailable = typeof spawnCode === "string" && ["ENOENT", "EACCES", "ENOEXEC"].includes(spawnCode);
+        if (typeof spawnCode === "string" && !binaryUnavailable) {
+            return {
+                kind: "startup_failed",
+                summary: "the Kimi subprocess could not be started or used.",
+                nextStep: "Check the underlying process error; shorten the prompt or environment if an argument-size limit was exceeded, then retry.",
+                runtimeProbe: "failed",
+                authProbe: "failed",
+            };
+        }
+        // Keep opaque synchronous failures and legacy async ENOENT diagnostics compatible.
+        if (binaryUnavailable || error.code === "CLI_SPAWN_FAILED" || /\bENOENT\b/.test(message)) {
+            return {
+                kind: "binary_unavailable",
+                summary: "the Kimi CLI is missing from PATH or not executable in this environment.",
+                nextStep: "Run `/kimi:setup` to verify the install, then expose `kimi` on PATH and retry.",
+                runtimeProbe: "failed",
+                authProbe: "failed",
+            };
+        }
+    }
+    // v1.0 cli-client surfaces non-ENOENT process errors and non-zero
+    // exits as CLI_PROCESS_ERROR / CLI_NONZERO_EXIT. Treat both as
+    // startup-failed for classifier purposes — the next step is the same
+    // (run /kimi:setup) and the distinction between "kimi crashed during
+    // init" vs "kimi exited with status 1" is post-hoc.
+    if (error instanceof RuntimeError &&
+        (error.code === "CLI_PROCESS_ERROR" || error.code === "CLI_NONZERO_EXIT")) {
+        return {
+            kind: "startup_failed",
+            summary: "the Kimi CLI exited before completing the requested operation.",
+            nextStep: "Run `/kimi:setup` to verify local Kimi health, then retry.",
+            runtimeProbe: "failed",
+            authProbe: "failed",
+        };
+    }
+    if (error instanceof RuntimeError && error.code === "MAX_STEPS_REACHED") {
+        return {
+            kind: "max_steps_reached",
+            summary: "Kimi exhausted its step budget before finalizing the turn.",
+            nextStep: "Retry with a more focused prompt or a higher step budget.",
+            runtimeProbe: "ok",
+            authProbe: "ok",
+        };
+    }
+    if (error instanceof RuntimeError) {
+        // STARTUP_TIMEOUT and INITIALIZE_TIMEOUT predate the v1.0 subprocess
+        // transport (the v0.4 Wire client had a three-phase startup). The
+        // v1.0 cli-client only emits RESPONSE_TIMEOUT, so these branches are
+        // defensive — callers that synthesize the old codes (or load v0.4
+        // job rows from SQLite) still get a useful classification.
+        if (error.code === "STARTUP_TIMEOUT") {
+            return {
+                kind: "startup_timeout",
+                summary: "the Kimi CLI did not respond during startup.",
+                nextStep: "Run `/kimi:setup` to verify local Kimi health, then retry.",
+                runtimeProbe: "failed",
+                authProbe: "failed",
+            };
+        }
+        if (error.code === "INITIALIZE_TIMEOUT") {
+            return {
+                kind: "initialize_timeout",
+                summary: "the Kimi session started but did not finish initializing in time.",
+                nextStep: "Run `/kimi:setup` to verify local Kimi configuration and retry.",
+                runtimeProbe: "failed",
+                authProbe: "failed",
+            };
+        }
+        if (error.code === "RESPONSE_TIMEOUT") {
+            return {
+                kind: "response_timeout",
+                summary: "Kimi started and accepted the prompt but never returned a final response.",
+                nextStep: "Narrow the prompt or raise the budget (`--budget <dur>`, at most 24h). Check the job artifact (`result <jobId>`) for any captured partial output. Backgrounding does not extend the runtime budget.",
+                runtimeProbe: "ok",
+                authProbe: "ok",
+            };
+        }
+    }
+    if (message.includes("timed out")) {
+        return {
+            kind: "timeout",
+            summary: "the Kimi runtime did not become ready within the expected time budget.",
+            nextStep: "Run `/kimi:setup` to check local Kimi auth and network health, then retry.",
+            runtimeProbe: "failed",
+            authProbe: "failed",
+        };
+    }
+    return null;
+}
+function mapAvailabilityCode(kind, commandType) {
+    const prefix = commandType.toUpperCase();
+    switch (kind) {
+        case "auth_unavailable":
+            return `${prefix}_KIMI_AUTH_UNAVAILABLE`;
+        case "binary_unavailable":
+            return `${prefix}_KIMI_BINARY_UNAVAILABLE`;
+        case "startup_failed":
+            return `${prefix}_KIMI_STARTUP_FAILED`;
+        case "startup_timeout":
+            return `${prefix}_KIMI_STARTUP_TIMEOUT`;
+        case "initialize_timeout":
+            return `${prefix}_KIMI_INITIALIZE_TIMEOUT`;
+        case "response_timeout":
+            return `${prefix}_KIMI_RESPONSE_TIMEOUT`;
+        case "timeout":
+            return `${prefix}_KIMI_TIMEOUT`;
+        case "max_steps_reached":
+            return `${prefix}_KIMI_MAX_STEPS_REACHED`;
+    }
+}
+function formatCommandLabel(commandType) {
+    switch (commandType) {
+        case "challenge":
+            return "challenge";
+        case "review_gate":
+            return "review gate";
+        default:
+            return commandType.replaceAll("_", " ");
+    }
+}

package/plugins/kimi-dsh/dist/kimi-home.js

@@ -0,0 +1,9 @@
+import os from "node:os";
+import path from "node:path";
+export function resolveKimiHome(env, baseCwd = process.cwd()) {
+    const override = env.KIMI_CODE_HOME?.trim();
+    if (override) {
+        return path.resolve(baseCwd, override);
+    }
+    return path.join(os.homedir(), ".kimi-code");
+}

package/plugins/kimi-dsh/dist/kimi-timeouts.js

@@ -0,0 +1,52 @@
+// Per-command response budgets leave room for thinking-capable workflows;
+// per-run effort is only a request. Ask/review default to 30 minutes and rescue
+// to 45 minutes for repo-wide work. Review-gate stays at 8 seconds because it
+// runs inside Claude Code's Stop hook and requests thinking off by default;
+// KIMI_PLUGIN_CC_REVIEW_GATE_THINKING can override that request.
+/** Ask budget. Conversational; thinking-on free-form reasoning. */
+export const KIMI_ASK_PROMPT_TIMEOUT_MS = 1_800_000; // 30 minutes
+/** Review/challenge budget. Thinking-on single-turn analysis over the workspace. */
+export const KIMI_REVIEW_PROMPT_TIMEOUT_MS = 1_800_000;
+/** Rescue budget. Thinking-on multi-step apply/test/verify loops. */
+export const KIMI_RESCUE_PROMPT_TIMEOUT_MS = 2_700_000; // 45 minutes
+/**
+ * Pursue (autonomous goal mode) DEFAULT wall-clock ceiling when the user
+ * passes no `--budget`. This is the ONLY hard bound on an autonomous goal —
+ * headless goal create sets no token/turn budget, and the managed hook denies
+ * SetGoalBudget. The same duration as
+ * the single-turn rescue default, but a safety ceiling rather than a patience
+ * knob. Deliberately finite. Overridable per-job via `--budget` (parsed to ms in
+ * parsePursueArgs). See runtime/commands/pursue.ts and docs/safety.md.
+ */
+export const KIMI_PURSUE_DEFAULT_BUDGET_MS = 2_700_000; // 45 minutes
+/**
+ * Swarm (read-only parallel fan-out) DEFAULT wall-clock ceiling when the user
+ * passes no `--budget`. Read-only swarm opens no write surface, so the only new
+ * risk is COST/runaway from N parallel model runs (plus possible nested
+ * AgentSwarm). This AbortController is the hard bound on that; the `--cap`
+ * subagent count is a soft prompt-injected hint (not hook-enforceable —
+ * the hook is stateless and can't count subagents). Sized like the single-turn
+ * review budget — a swarm fans review work out in parallel within one process,
+ * so 30m of wall-clock is generous headroom. Overridable per-job via `--budget`
+ * (parsed to ms in parseSwarmArgs). See runtime/commands/swarm.ts and
+ * docs/safety.md.
+ */
+export const KIMI_SWARM_DEFAULT_BUDGET_MS = 1_800_000; // 30 minutes
+/**
+ * Review-gate budget. Fires inside Claude Code's Stop hook so any value
+ * above the user's perceptible wait makes the gate feel broken.
+ *
+ * The gate requests off through KIMI_MODEL_THINKING_EFFORT by default;
+ * KIMI_PLUGIN_CC_REVIEW_GATE_THINKING can inherit or request another effort.
+ * BYO/non-trait-driven providers and always-thinking models can ignore it.
+ * The 8s timeout remains fail-open; a request never guarantees completion.
+ * Hook-escape findings annotate the result and never block or change job outcome.
+ * See docs/safety.md.
+ */
+export const KIMI_REVIEW_GATE_TIMEOUT_MS = 8_000;
+export function isTimeoutCode(code) {
+    return (code === "TIMEOUT" ||
+        code === "STARTUP_TIMEOUT" ||
+        code === "INITIALIZE_TIMEOUT" ||
+        code === "RESPONSE_TIMEOUT");
+}

package/plugins/kimi-dsh/dist/kimi-version-probe.js

@@ -0,0 +1,216 @@
+// Probe the installed kimi-code CLI version and check it against the
+// range kimi-plugin-cc has been tested against.
+//
+// Setup probes the installed command and warns outside the tested range;
+// model jobs probe the exact command + prefix tuple to build a fail-closed
+// execution plan before spawn. The latter is the durable engine-provenance
+// gate: an operation outside its certified engine/version range is refused
+// rather than guessed.
+//
+// What this module is NOT:
+//
+//   - Not, by itself, the policy decision. setup still warns; the execution-
+//     plan layer (`kimi-engine.ts`) decides whether an exact result is certified.
+//   - Not a license to infer historical versions. Old job rows remain unknown
+//     unless their saved logs contain positive evidence.
+import { spawn } from "node:child_process";
+const KIMI_VERSION_PROBE_TIMEOUT_MS = 5_000;
+/**
+ * Legacy-v1 kimi-code minors tested for plugin use. Membership is by
+ * `{major, minor}`; every patch within a listed minor is accepted.
+ *
+ * This table intentionally never gains 0.42, which removed legacy v1.
+ * Exact per-operation native-v2 certification lives in `kimi-engine.ts`.
+ */
+export const KIMI_TESTED_MINORS = [
+    { major: 0, minor: 1 },
+    { major: 0, minor: 2 },
+    { major: 0, minor: 3 },
+    { major: 0, minor: 4 },
+    { major: 0, minor: 5 },
+    { major: 0, minor: 6 },
+    { major: 0, minor: 7 },
+    { major: 0, minor: 8 },
+    { major: 0, minor: 9 },
+    { major: 0, minor: 10 },
+    { major: 0, minor: 11 },
+    { major: 0, minor: 12 },
+    { major: 0, minor: 13 },
+    { major: 0, minor: 14 },
+    { major: 0, minor: 15 },
+    { major: 0, minor: 16 },
+    { major: 0, minor: 17 },
+    { major: 0, minor: 18 },
+    { major: 0, minor: 19 },
+    { major: 0, minor: 20 },
+    { major: 0, minor: 21 },
+    { major: 0, minor: 22 },
+    { major: 0, minor: 23 },
+    { major: 0, minor: 24 },
+    { major: 0, minor: 25 },
+    { major: 0, minor: 26 },
+    { major: 0, minor: 27 },
+    { major: 0, minor: 28 },
+    { major: 0, minor: 29 },
+    { major: 0, minor: 30 },
+    { major: 0, minor: 31 },
+    { major: 0, minor: 32 },
+    { major: 0, minor: 33 },
+    { major: 0, minor: 34 },
+    { major: 0, minor: 35 },
+    { major: 0, minor: 36 },
+    { major: 0, minor: 37 },
+    { major: 0, minor: 38 },
+    { major: 0, minor: 39 },
+    { major: 0, minor: 40 },
+    { major: 0, minor: 41 },
+];
+/**
+ * Spawn `<kimi-bin> --version` and parse the output. Never throws;
+ * failures resolve to `{kind: "failed", reason}` so callers can decide
+ * the policy. The kimi binary path defaults to bare `kimi` (PATH
+ * lookup); callers that need an explicit absolute path should pass it.
+ */
+export async function probeKimiVersion(options) {
+    const bin = options.kimiBin ?? "kimi";
+    const args = [...(options.prefixArgs ?? []), "--version"];
+    const timeoutMs = options.timeoutMs ?? KIMI_VERSION_PROBE_TIMEOUT_MS;
+    return await new Promise((resolve) => {
+        let settled = false;
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(result);
+        };
+        let child;
+        try {
+            child = spawn(bin, args, {
+                cwd: options.cwd,
+                env: options.env,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (err) {
+            settle({
+                kind: "failed",
+                reason: `spawn failed: ${err.message}`,
+            });
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        const timer = setTimeout(() => {
+            try {
+                child.kill("SIGTERM");
+            }
+            catch {
+            }
+            settle({
+                kind: "failed",
+                reason: `\`${[bin, ...args].join(" ")}\` timed out after ${timeoutMs}ms`,
+            });
+        }, timeoutMs);
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            settle({
+                kind: "failed",
+                reason: `spawn error: ${err.message}`,
+            });
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (code !== 0) {
+                const detail = stderr.trim() !== "" ? stderr.trim() : `exit ${code}`;
+                settle({
+                    kind: "failed",
+                    reason: `\`${[bin, ...args].join(" ")}\` failed: ${detail}`,
+                });
+                return;
+            }
+            const parsed = parseVersionLine(stdout);
+            if (parsed === undefined) {
+                settle({
+                    kind: "failed",
+                    reason: `could not parse \`${[bin, ...args].join(" ")}\` output: ${JSON.stringify(stdout.slice(0, 80))}`,
+                });
+                return;
+            }
+            settle({
+                kind: "ok",
+                version: parsed.raw,
+                major: parsed.major,
+                minor: parsed.minor,
+                patch: parsed.patch,
+                inTestedRange: isInTestedRange(parsed.major, parsed.minor),
+            });
+        });
+    });
+}
+/**
+ * Parse a `kimi --version` stdout into a structured version. Accepts
+ * bare semver (`0.2.0`), `v`-prefixed (`v0.2.0`), and trailing
+ * pre-release / build metadata (`0.2.0-beta.1`, `0.2.0+sha.abc`). The
+ * major/minor/patch numbers are the leading three components only —
+ * pre-release / build metadata is preserved in `raw` but doesn't
+ * affect the tested-range check.
+ *
+ * Returns undefined when the first nonempty line doesn't look like a version.
+ */
+export function parseVersionLine(stdout) {
+    const firstLine = stdout.split(/\r?\n/).find((line) => line.trim().length > 0);
+    if (firstLine === undefined)
+        return undefined;
+    const trimmed = firstLine.trim().replace(/^v/, "");
+    const match = trimmed.match(/^(\d+)\.(\d+)\.(\d+)(?:[-+][0-9A-Za-z.-]+)?$/);
+    if (match === null)
+        return undefined;
+    return {
+        raw: trimmed,
+        major: Number.parseInt(match[1], 10),
+        minor: Number.parseInt(match[2], 10),
+        patch: Number.parseInt(match[3], 10),
+    };
+}
+export function isInTestedRange(major, minor) {
+    return KIMI_TESTED_MINORS.some((entry) => entry.major === major && entry.minor === minor);
+}
+/**
+ * The newest `{major, minor}` in the legacy-v1 tested set. Native-v2-certified
+ * versions lie outside this table. Set membership already warns for anything
+ * outside the legacy range; this upper bound lets the warning distinguish a
+ * newer, unverified legacy release from a below/gap version.
+ */
+export function maxTestedMinor() {
+    return KIMI_TESTED_MINORS.reduce((max, entry) => entry.major > max.major || (entry.major === max.major && entry.minor > max.minor)
+        ? entry
+        : max);
+}
+/**
+ * Format a user-facing warning line for an out-of-range version probe.
+ * Setup itself may complete, but the execution-plan gate will refuse model
+ * spawns until the operator selects a certified binary or updates the plugin.
+ */
+export function formatVersionOutOfRangeWarning(probe, pluginVersion) {
+    const tested = KIMI_TESTED_MINORS.map((entry) => `${entry.major}.${entry.minor}.x`).join(", ");
+    const max = maxTestedMinor();
+    const aboveMax = probe.major > max.major || (probe.major === max.major && probe.minor > max.minor);
+    const lines = [
+        `WARNING: kimi-code version ${probe.version} is outside the range kimi-plugin-cc ${pluginVersion} was tested against (${tested}).`,
+    ];
+    if (aboveMax) {
+        // Above the legacy-v1 tested upper bound is a release newer than the last
+        // legacy compatibility audit, commonly from out-of-band auto-upgrade drift.
+        lines.push(`  This is NEWER than the newest version we have tested (${max.major}.${max.minor}.x) and is not yet certified for model execution.`);
+    }
+    lines.push(`  Setup can complete, but model-spawning commands will refuse before Kimi starts rather than run an unreviewed engine/version route.`, `  Update kimi-plugin-cc to a release that certifies this minor, or point KIMI_PLUGIN_CC_KIMI_BIN at a certified kimi-code binary and retry setup.`, `  KIMI_PLUGIN_CC_SKIP_VERSION_PROBE is a test/smoke seam, not a production compatibility override.`);
+    return lines.join("\n");
+}

package/plugins/kimi-dsh/dist/logging.js

@@ -0,0 +1,22 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+export async function writeInvocationLogHeader(logPath, metadata) {
+    const line = `${JSON.stringify({
+        ts: new Date().toISOString(),
+        direction: "meta",
+        message: metadata,
+    })}\n`;
+    await mkdir(path.dirname(logPath), { recursive: true });
+    try {
+        await appendFile(logPath, line, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            // Directory vanished between mkdir and appendFile — recreate and retry once.
+            await mkdir(path.dirname(logPath), { recursive: true });
+            await appendFile(logPath, line, "utf8");
+            return;
+        }
+        throw error;
+    }
+}

package/plugins/kimi-dsh/dist/mcp/binding.js

@@ -0,0 +1,58 @@
+import { realpath } from "node:fs/promises";
+import { RuntimeError } from "../errors.js";
+export async function assertMcpJobBinding(task, job) {
+    if (!job)
+        throw bindingError(task, "The supervised job row does not exist.");
+    if (job.job_id !== task.task_id)
+        throw bindingError(task, "Task and job IDs differ.");
+    if (job.operation_kind !== task.operation_kind)
+        throw bindingError(task, "Task and job operation kinds differ.");
+    if (job.repo_id !== task.repo_id)
+        throw bindingError(task, "Task and job repositories differ.");
+    if (job.background)
+        throw bindingError(task, "Supervised MCP jobs must retain foreground companion ownership.");
+    if (job.status === "running" && (task.companion_pid === null || job.pid !== task.companion_pid)) {
+        throw bindingError(task, "Task and job companion process IDs differ or are missing.");
+    }
+    let jobCwd;
+    try {
+        jobCwd = await realpath(job.cwd);
+    }
+    catch (error) {
+        throw bindingError(task, "The job workspace cannot be resolved.", error);
+    }
+    if (jobCwd !== task.workspace_cwd)
+        throw bindingError(task, "Task and job workspaces differ.");
+    return job;
+}
+export function mcpCompanionIdentity(task) {
+    return parseIdentity(task.companion_identity, task.companion_pid, task, "companion");
+}
+export function mcpKimiIdentity(task, job) {
+    return parseIdentity(task.kimi_identity, job.kimi_pid, task, "Kimi");
+}
+function parseIdentity(serialized, expectedPid, task, label) {
+    if (serialized === null)
+        return null;
+    try {
+        const value = JSON.parse(serialized);
+        if (!Number.isInteger(value.pid) || (value.pid ?? 0) <= 0 ||
+            !Number.isInteger(value.processGroupId) ||
+            typeof value.startToken !== "string" || value.startToken.length === 0 ||
+            typeof value.state !== "string") {
+            throw new Error("invalid identity shape");
+        }
+        if (expectedPid !== null && expectedPid !== value.pid)
+            throw new Error("identity and recorded PID differ");
+        return value;
+    }
+    catch (error) {
+        throw bindingError(task, `The ${label} process identity is invalid.`, error);
+    }
+}
+function bindingError(task, message, cause) {
+    return new RuntimeError("MCP_JOB_BINDING_FAILED", message, "mcp.binding", {
+        ...(cause instanceof Error ? { cause } : {}),
+        details: { job_id: task.task_id, operation_kind: task.operation_kind },
+    });
+}