kimi-plugin-cc 2.4.0 → 2.4.2

package/plugins/kimi-codex/dist/git.js

@@ -85,12 +85,13 @@ async function runGit(args, cwd) {
     }
     return result.stdout;
 }
-async function runGitAllowFailure(args, cwd) {
+async function runGitAllowFailure(args, cwd, signal) {
     try {
         const { stdout, stderr } = await execFileAsync("git", args, {
             cwd,
             env: process.env,
             maxBuffer: 10 * 1024 * 1024,
+            signal,
         });
         return { ok: true, stdout, stderr };
     }
@@ -163,11 +164,11 @@ export async function createEphemeralWorktree(repoRoot, base, worktreePath) {
  *
  * Returns the patch text (empty string if the swarm changed nothing).
  */
-export async function captureWorktreePatch(worktreePath) {
+export async function captureWorktreePatch(worktreePath, signal) {
     // Intent-to-add is required so untracked files surface in `git diff HEAD`.
     // An add -N failure aborts capture rather than returning a patch that omits
     // new files.
-    const intentToAdd = await runGitAllowFailure(["add", "-N", "--", "."], worktreePath);
+    const intentToAdd = await runGitAllowFailure(["add", "-N", "--", "."], worktreePath, signal);
     if (!intentToAdd.ok) {
         throw new RuntimeError("GIT_WORKTREE_INTENT_TO_ADD_FAILED", `git add -N (worktree capture) failed: ${intentToAdd.stderr || "unknown error"}`, "swarm.worktree", { details: { worktreePath } });
     }
@@ -176,6 +177,7 @@ export async function captureWorktreePatch(worktreePath) {
             cwd: worktreePath,
             env: process.env,
             maxBuffer: MAX_PATCH_BYTES,
+            signal,
         });
         return stdout;
     }

package/plugins/kimi-codex/dist/help.js

@@ -1,5 +1,5 @@
-import { hasHelpFlag, ASK_SUPPORTED_FLAGS, RESCUE_SUPPORTED_FLAGS, REVIEW_SUPPORTED_FLAGS, PURSUE_SUPPORTED_FLAGS, SWARM_SUPPORTED_FLAGS, JOB_LOOKUP_SUPPORTED_FLAGS, SETUP_SUPPORTED_FLAGS, REPAIR_SESSIONS_SUPPORTED_FLAGS, REPLAY_SUPPORTED_FLAGS, } from "./parsing.js";
-const SUBCOMMANDS = "setup, review, task, ask, status, result, cancel, replay, repair-sessions";
+import { hasHelpFlag, ASK_SUPPORTED_FLAGS, RESCUE_SUPPORTED_FLAGS, REVIEW_SUPPORTED_FLAGS, PURSUE_SUPPORTED_FLAGS, SWARM_SUPPORTED_FLAGS, JOB_LOOKUP_SUPPORTED_FLAGS, SETUP_SUPPORTED_FLAGS, REPAIR_SESSIONS_SUPPORTED_FLAGS, REPLAY_SUPPORTED_FLAGS, RECOVER_SWARM_SUPPORTED_FLAGS, } from "./parsing.js";
+const SUBCOMMANDS = "setup, review, task, ask, status, result, cancel, replay, repair-sessions, recover-swarm";
 const TASK_KINDS = "rescue, challenge, pursue, swarm";
 /** Help is a dispatch-only, side-effect-free exception to normal argument parsing. */
 export function companionHelp(argv) {
@@ -33,6 +33,7 @@ export function companionHelp(argv) {
         case "cancel":
             return usage(command, "[job-id] [options]", JOB_LOOKUP_SUPPORTED_FLAGS, command === "status" ? "Show job state as JSON." : command === "result" ? "Read a terminal artifact, optionally in a JSON envelope." : "Cancel a running job; without an id, target the repository's latest running job.");
         case "replay": return usage(command, "<job-id>", REPLAY_SUPPORTED_FLAGS, "Replay a completed job's persisted stream log.");
+        case "recover-swarm": return `Usage: companion.sh recover-swarm <job-id> [${RECOVER_SWARM_SUPPORTED_FLAGS}]. Preview durable swarm recovery; --apply stops verified orphans, disables the recorded session and captures a patch. Never resumes prompts or changes terminal job outcomes.`;
         case "repair-sessions": return usage(command, "[options]", REPAIR_SESSIONS_SUPPORTED_FLAGS, "Preview session metadata repair; --apply writes, --all selects all host-owned repositories.");
         case "worker": return "Usage: companion.sh worker <ask|rescue> <job-id>. Internal detached-worker entry point; launched by ask/rescue, not manually.";
         case "mcp": return "Usage: companion.sh mcp. Run the Kimi MCP stdio server; normally launched by Claude Code or Codex plugin configuration.";

package/plugins/kimi-codex/dist/hooks/config-safety.js

@@ -594,8 +594,8 @@ 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) and 2.3.1 (684bae9e): the additive events and HookDefSchema
-    // are unchanged. Require the full version string AND matching components;
+    // 2.3.0 (b5e28fd6), 2.3.1 (684bae9e) and 2.3.2 (b8dd3a13): 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) ||
@@ -604,7 +604,8 @@ function validateVersionSensitiveEvents(events, version) {
             (version.version === "2.1.1" && version.patch === 1))) ||
         (version.minor === 2 && ((version.version === "2.2.0" && version.patch === 0))) ||
         (version.minor === 3 && ((version.version === "2.3.0" && version.patch === 0) ||
-            (version.version === "2.3.1" && version.patch === 1))))) {
+            (version.version === "2.3.1" && version.patch === 1) ||
+            (version.version === "2.3.2" && version.patch === 2))))) {
         return { valid: true };
     }
     if (version.major !== 0) {

package/plugins/kimi-codex/dist/job-store.js

@@ -122,6 +122,8 @@ export class JobStore {
       CREATE INDEX IF NOT EXISTS jobs_repo_updated_idx
         ON jobs (repo_id, updated_at DESC);
 
+      CREATE TABLE IF NOT EXISTS swarm_recovery (job_id TEXT PRIMARY KEY, payload TEXT NOT NULL, recovery_owner TEXT);
+
       CREATE INDEX IF NOT EXISTS jobs_repo_type_updated_idx
         ON jobs (repo_id, command_type, updated_at DESC);
 
@@ -186,6 +188,17 @@ export class JobStore {
             throw translateSqliteError(error);
         }
     }
+    getSwarmRecovery(jobId) {
+        const row = this.db.get("SELECT payload, recovery_owner FROM swarm_recovery WHERE job_id = ?", jobId);
+        return row ? { record: JSON.parse(row.payload), owner: row.recovery_owner } : null;
+    }
+    saveSwarmRecovery(jobId, record) {
+        this.db.run("INSERT INTO swarm_recovery (job_id, payload) VALUES (?, ?) ON CONFLICT(job_id) DO UPDATE SET payload = excluded.payload", [jobId, JSON.stringify(record)]);
+    }
+    claimSwarmRecovery(jobId, expected, owner) {
+        this.db.run("UPDATE swarm_recovery SET recovery_owner = ? WHERE job_id = ? AND recovery_owner IS ?", [owner, jobId, expected]);
+        return this.db.get("SELECT changes() AS count").count === 1;
+    }
     close() {
         this.db.close();
     }

package/plugins/kimi-codex/dist/jobs.js

@@ -85,6 +85,9 @@ export async function sweepStaleJobs(store, paths) {
     for (const job of store.listRunningJobsWithProcessHints()) {
         if (store.getMcpTask(job.job_id))
             continue;
+        // Recovery owns orphaned swarm resources; PID-only sweeping must not signal replacements.
+        if (store.getSwarmRecovery(job.job_id))
+            continue;
         if (!isStaleEnoughToSweep(job)) {
             continue;
         }

package/plugins/kimi-codex/dist/kimi-engine.js

@@ -41,6 +41,7 @@ export const NATIVE_V2_CERTIFIED_VERSIONS = Object.freeze([
     "2.2.0",
     "2.3.0",
     "2.3.1",
+    "2.3.2",
 ]);
 /** Per-operation native-v2 certification. One green operation never certifies another. */
 export const NATIVE_V2_CERTIFIED = new Map([

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

@@ -44,6 +44,11 @@ export function classifyManagedCommandFailure(error, commandType, jobId, options
     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)
@@ -129,28 +134,29 @@ function classifyKimiAvailability(error) {
             authProbe: "failed",
         };
     }
-    if (error instanceof RuntimeError && error.code === "CLI_SPAWN_FAILED") {
-        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 async ENOENT (Bun) as CLI_PROCESS_ERROR with
-    // "spawn ... ENOENT" in the message. Map that to binary_unavailable so
-    // the failure message points users at /kimi:setup.
     if (error instanceof RuntimeError &&
-        error.code === "CLI_PROCESS_ERROR" &&
-        /\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",
-        };
+        (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

package/plugins/kimi-codex/dist/parsing.js

@@ -18,6 +18,7 @@ export const RESCUE_SUPPORTED_FLAGS = "-m/--model <name>, --thinking <off|low|me
 export const REVIEW_SUPPORTED_FLAGS = "--base <ref>, -m/--model <name>, --thinking <off|low|medium|high>, --budget <30m|1h|90s>";
 export const JOB_LOOKUP_SUPPORTED_FLAGS = "--type <review|challenge|rescue|review_gate|ask>, --json";
 export const SETUP_SUPPORTED_FLAGS = "--check, --uninstall, --all (with --uninstall), --enable-review-gate, --disable-review-gate, --models [--json] (without other setup flags)";
+export const RECOVER_SWARM_SUPPORTED_FLAGS = "--apply";
 export const REPAIR_SESSIONS_SUPPORTED_FLAGS = "--apply, --all";
 export const REPLAY_SUPPORTED_FLAGS = "none (one job-id required)";
 /** Validate syntax only; upstream per-model supportEfforts remains authoritative. */

package/plugins/kimi-codex/dist/process-tree.js

@@ -6,7 +6,7 @@ const MAX_DESCENDANT_DEPTH = 8;
 const MAX_DESCENDANT_PIDS = 512;
 const PROCESS_EXIT_POLL_MS = 10;
 const PROCESS_SNAPSHOT_TIMEOUT_MS = 1_000;
-const PROCESS_IDENTITY_PROBE_TIMEOUT_MS = 250;
+const PROCESS_IDENTITY_PROBE_TIMEOUT_MS = 1_000;
 const PROBE_TIMEOUT = Symbol("process-probe-timeout");
 /**
  * Capture descendant ancestry and reusable identities in the same bounded
@@ -23,6 +23,18 @@ export async function collectDescendantIdentities(rootPid) {
     }
     return snapshot;
 }
+/** Return current members of the selected process groups, or undefined when unreadable. */
+export async function collectProcessGroupsIdentities(processGroupIds) {
+    if (process.platform === "win32")
+        return undefined;
+    const groups = new Set(processGroupIds.filter((id) => Number.isInteger(id) && id > 0));
+    if (groups.size === 0)
+        return [];
+    const rows = await raceValueWithTimeout(collectProcessSnapshotRows(), PROCESS_SNAPSHOT_TIMEOUT_MS);
+    if (rows === PROBE_TIMEOUT || rows === undefined)
+        return undefined;
+    return rows.filter((row) => groups.has(row.processGroupId)).map(toProcessIdentity);
+}
 /**
  * Compatibility surface for callers that only need numeric process listings.
  * Cancellation must use collectDescendantIdentities so ancestry and identity
@@ -36,15 +48,21 @@ export async function collectDescendants(rootPid) {
         return [];
     }
 }
-/** Read one reusable process identity. PID alone is not stable across teardown. */
-export async function readProcessIdentity(pid) {
+/** Distinguish a missing process from a failed or timed-out identity probe. */
+export async function probeProcessIdentity(pid) {
     if (!Number.isInteger(pid) || pid <= 0 || process.platform === "win32")
-        return undefined;
+        return { complete: true };
     const read = process.platform === "linux"
         ? readProcessIdentityBatchFromProc([pid])
         : readProcessIdentityBatchWithPs([pid]);
     const batch = await raceValueWithTimeout(read, PROCESS_IDENTITY_PROBE_TIMEOUT_MS);
-    return batch === PROBE_TIMEOUT ? undefined : batch.identities.get(pid);
+    if (batch === PROBE_TIMEOUT)
+        return { complete: false };
+    return { identity: batch.identities.get(pid), complete: batch.complete };
+}
+/** Read one reusable process identity. PID alone is not stable across teardown. */
+export async function readProcessIdentity(pid) {
+    return (await probeProcessIdentity(pid)).identity;
 }
 /**
  * Revalidate all captured identities concurrently under one deadline. The
@@ -63,16 +81,26 @@ export async function revalidateProcessIdentities(expectedIdentities, options =
     if (batch === PROBE_TIMEOUT)
         return { identities: [], complete: false };
     const identities = [];
+    const groupChanged = [];
     for (const expectedIdentity of expected) {
         const current = batch.identities.get(expectedIdentity.pid);
-        if (current !== undefined &&
-            current.startToken === expectedIdentity.startToken &&
-            current.processGroupId === expectedIdentity.processGroupId &&
-            !isQuiescentState(current.state)) {
+        if (current === undefined ||
+            current.startToken !== expectedIdentity.startToken ||
+            isQuiescentState(current.state)) {
+            continue;
+        }
+        if (current.processGroupId !== expectedIdentity.processGroupId) {
+            groupChanged.push(current);
+        }
+        else {
             identities.push(current);
         }
     }
-    return { identities, complete: batch.complete };
+    return {
+        identities,
+        complete: batch.complete,
+        ...(groupChanged.length > 0 ? { groupChanged } : {}),
+    };
 }
 /** Return the current identity only when pid, start token, and PGID still match. */
 export async function revalidateProcessIdentity(expected, identityReader) {
@@ -104,7 +132,7 @@ export async function waitForProcessTreeExit(identities, timeoutMs, options = {}
                 identityReader: options.identityReader,
                 timeoutMs: probeTimeoutMs,
             });
-            active = !validation.complete || validation.identities.length > 0;
+            active = !validation.complete || validation.identities.length > 0 || (validation.groupChanged?.length ?? 0) > 0;
         }
         if (!active)
             return true;
@@ -117,13 +145,13 @@ export async function waitForProcessTreeExit(identities, timeoutMs, options = {}
 async function collectVerifiedDescendantIdentities(rootPid) {
     const initialRows = await collectProcessSnapshotRows();
     if (initialRows === undefined)
-        return [];
+        throw new Error("process snapshot unavailable");
     const candidateRows = descendantRowsFromSnapshot(rootPid, initialRows);
     const initialRoot = initialRows.find((row) => row.pid === rootPid);
     if (initialRoot === undefined || candidateRows.length === 0)
         return [];
-    // A second, targeted snapshot closes the cross-row /proc race: every child
-    // identity and every numeric parent edge must still match before acceptance.
+    // A second, targeted snapshot closes the cross-row /proc race: each child
+    // must retain its PID and start token. Reparenting and PGID changes are not exit.
     const expectedRows = [initialRoot, ...candidateRows];
     const expectedByPid = new Map(expectedRows.map((row) => [row.pid, row]));
     const verificationRows = await readCurrentSnapshotRows(expectedRows);
@@ -131,11 +159,9 @@ async function collectVerifiedDescendantIdentities(rootPid) {
         const expected = expectedByPid.get(current.pid);
         return (expected !== undefined &&
             current.startToken === expected.startToken &&
-            current.processGroupId === expected.processGroupId &&
-            current.parentPid === expected.parentPid &&
             !isQuiescentState(current.state));
     });
-    return descendantRowsFromSnapshot(rootPid, stableRows).map(toProcessIdentity);
+    return stableRows.map(toProcessIdentity);
 }
 function descendantRowsFromSnapshot(rootPid, rows) {
     const root = rows.find((row) => row.pid === rootPid);
@@ -186,6 +212,9 @@ async function readCurrentSnapshotRows(expectedRows) {
         Promise.all(procPids.map((pid) => readProcRow(pid))),
         collectProcessSnapshotRowsFromPs(psPids),
     ]);
+    if (procOutcomes.some((outcome) => outcome.status === "error") || (psPids.length > 0 && psRows === undefined)) {
+        throw new Error("process identity verification failed");
+    }
     return [
         ...procOutcomes.flatMap((outcome) => outcome.status === "found" ? [outcome.row] : []),
         ...(psRows ?? []),
@@ -212,6 +241,8 @@ async function collectProcessSnapshotRowsFromProc() {
     const outcomes = await Promise.all(entries
         .filter((entry) => /^\d+$/.test(entry))
         .map((entry) => readProcRow(Number.parseInt(entry, 10))));
+    if (outcomes.some((outcome) => outcome.status === "error"))
+        return undefined;
     return outcomes.flatMap((outcome) => outcome.status === "found" ? [outcome.row] : []);
 }
 async function collectProcessSnapshotRowsFromPs(pids) {

package/plugins/kimi-codex/dist/prompt-size.js

@@ -0,0 +1,18 @@
+import { RuntimeError } from "./errors.js";
+// Node/libuv's default CreateProcess argument quoting (UTF-16 code units).
+export function windowsCommandLineLength(command, args) {
+    const quotedLength = (value) => {
+        if (value.length > 0 && !/[\s"]/u.test(value))
+            return value.length;
+        return 2 + value.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, '$1$1').length;
+    };
+    return [command, ...args].reduce((size, value) => size + quotedLength(value) + 1, 0);
+}
+export function assertPromptFitsCommandLine(command, args, platform = process.platform) {
+    if (platform !== "win32")
+        return;
+    const size = windowsCommandLineLength(command, args);
+    if (size <= 32_767)
+        return;
+    throw new RuntimeError("CLI_COMMAND_LINE_TOO_LONG", "The Kimi prompt exceeds the Windows command-line limit; the CLI was not started. Narrow the review or split it into smaller scopes. A short ask prompt can reference a saved diff inside the workspace. Reinstalling Kimi or running setup will not fix this. The current print transport does not support stdin prompts.", "cli-client.pre-spawn", { details: { command_line_utf16_units: size, limit_utf16_units: 32_767, platform } });
+}