kimi-plugin-cc 2.4.1 → 2.4.3

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

@@ -594,7 +594,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) and 2.3.2 (b8dd3a13): the additive
+    // 2.3.0 (b5e28fd6), 2.3.1 (684bae9e) 2.3.2 (b8dd3a13), and 2.3.3 (ec495f0c): 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) ||
@@ -605,7 +605,8 @@ function validateVersionSensitiveEvents(events, version) {
         (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.2" && version.patch === 2))))) {
+            (version.version === "2.3.2" && version.patch === 2) ||
+            (version.version === "2.3.3" && version.patch === 3))))) {
         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

@@ -42,6 +42,7 @@ export const NATIVE_V2_CERTIFIED_VERSIONS = Object.freeze([
     "2.3.0",
     "2.3.1",
     "2.3.2",
+    "2.3.3",
 ]);
 /** 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/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 } });
+}

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_VERSION = "2.3.2";
+const PREACTIVATION_VERSIONS = ["2.3.2", "2.3.3"];
 const READY_TIMEOUT_MS = 10_000;
 const REST_TIMEOUT_MS = 5_000;
 const SHUTDOWN_TIMEOUT_MS = 5_000;
@@ -25,7 +25,7 @@ const ESCALATION_MS = 1_500;
 const POST_KILL_QUIESCENCE_MS = 500;
 const ENV_MODEL_ALIAS = "__kimi_env_model__";
 export function requiresSwarmPreactivation(version) {
-    return version === PREACTIVATION_VERSION;
+    return version !== null && PREACTIVATION_VERSIONS.includes(version);
 }
 export async function preactivateSwarmSession(options) {
     const failureCode = "SWARM_ACTIVATION_FAILED";
@@ -39,6 +39,7 @@ export async function preactivateSwarmSession(options) {
         await verifyMeta(web, prepared.expectedVersion, options.signal, failureCode);
         const model = await resolveProfileModel(web, options, failureCode);
         identity = await createSession(web, options, failureCode);
+        options.onRecoveryEvent?.({ kind: "session", ...identity });
         profileMutationAttempted = true;
         await postSwarmProfile(web, identity, true, model, options.signal, failureCode);
         await verifySwarmStatus(web, identity, true, model, options.signal, failureCode);
@@ -88,6 +89,7 @@ export async function deactivateSwarmSession(options) {
         await verifySwarmStatus(web, options, false, undefined, options.signal, failureCode);
         await shutdownWeb(web, options.signal, failureCode);
         await requireSwarmJournal(prepared.kimiHome, options, "exit", options.signal, failureCode);
+        options.onRecoveryEvent?.({ kind: "disabled" });
         throwIfAborted(options.signal, failureCode, "swarm-deactivation.complete");
     }
     catch (error) {
@@ -114,7 +116,7 @@ async function prepareWebSpawn(options, failureCode) {
     }
     const expectedVersion = options.expectedVersion ?? options.executionPlan.kimiVersion;
     if (expectedVersion === null || !requiresSwarmPreactivation(expectedVersion)) {
-        throw failure(failureCode, "swarm-activation.version", `Swarm web preactivation requires exact kimi-code ${PREACTIVATION_VERSION}.`);
+        throw failure(failureCode, "swarm-activation.version", `Swarm web preactivation requires exact kimi-code ${PREACTIVATION_VERSIONS.join(" or ")}.`);
     }
     const kimiHome = resolveKimiHome(options.env, options.cwd);
     if (options.executionPlan.intendedEngine === "native-v2") {
@@ -144,6 +146,7 @@ async function startWebChild(options, env, failureCode) {
         "error",
     ];
     let child;
+    options.onRecoveryEvent?.({ kind: "web-spawn" });
     try {
         child = spawn(options.command, args, {
             cwd: options.cwd,
@@ -153,6 +156,7 @@ async function startWebChild(options, env, failureCode) {
         });
     }
     catch {
+        options.onRecoveryEvent?.({ kind: "web-exit" });
         throw failure(failureCode, "swarm-activation.spawn", "Failed to spawn the Kimi web lifecycle process.");
     }
     let exited = false;
@@ -184,6 +188,7 @@ async function startWebChild(options, env, failureCode) {
         child,
         closePromise,
         descendants: [],
+        onRecoveryEvent: options.onRecoveryEvent,
         trackingStopped: false,
         lastSnapshotComplete: false,
         snapshotIncomplete: false,
@@ -198,6 +203,8 @@ async function startWebChild(options, env, failureCode) {
     try {
         const ready = await waitForReadyLine(owned, options.signal, failureCode);
         await refreshOwnedDescendants(owned);
+        if (owned.recoveryFailed)
+            throw failure(failureCode, "swarm-activation.recovery", "Cannot persist web ownership; refusing session mutation.");
         return Object.assign(owned, ready);
     }
     catch (error) {
@@ -610,12 +617,26 @@ async function refreshOwnedDescendants(owned) {
             owned.snapshotIncomplete = true;
             owned.lastSnapshotComplete = false;
         }
+        try {
+            owned.onRecoveryEvent?.({ kind: "web-processes", identities: [...(owned.rootIdentity ? [owned.rootIdentity] : []), ...owned.descendants], complete: owned.lastSnapshotComplete });
+        }
+        catch {
+            owned.recoveryFailed = true;
+        }
     })().finally(() => {
         owned.refreshPromise = undefined;
     });
     return await owned.refreshPromise;
 }
 async function teardownOwnedChild(owned) {
+    const quiescent = await teardownOwnedChildInner(owned);
+    if (quiescent && !owned.recoveryFailed) {
+        owned.onRecoveryEvent?.({ kind: "web-exit" });
+        return true;
+    }
+    return false;
+}
+async function teardownOwnedChildInner(owned) {
     await stopDescendantTracking(owned);
     const childPid = owned.child.pid;
     if (childPid === undefined)

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

@@ -0,0 +1,134 @@
+import { RuntimeError } from "./errors.js";
+import { collectDescendantIdentities, collectProcessGroupsIdentities, probeProcessIdentity, revalidateProcessIdentities } from "./process-tree.js";
+export function recordRecoveryEvent(store, record, event) {
+    record.complete = false;
+    if (event.kind === "session") {
+        record.session = { sessionId: event.sessionId, workspaceId: event.workspaceId };
+        // Write-ahead: this must commit before the profile mutation is attempted.
+        record.sessionDirty = true;
+    }
+    else if (event.kind === "disabled") {
+        record.sessionDirty = false;
+    }
+    else if (event.kind.endsWith("-spawn")) {
+        record.launches.push({ kind: event.kind === "web-spawn" ? "web" : "print", pending: true, identities: [], quiescent: false, uncertain: false });
+    }
+    else {
+        const kind = event.kind.startsWith("web-") ? "web" : "print";
+        const launch = [...record.launches].reverse().find((entry) => entry.kind === kind);
+        if (!launch)
+            throw recoveryError("Missing durable launch intent.");
+        if (event.kind === "web-exit" || event.kind === "print-exit") {
+            launch.quiescent = true;
+            launch.pending = false;
+        }
+        else if ("identities" in event) {
+            const all = [...launch.identities, ...event.identities];
+            launch.identities = [...new Map(all.map((identity) => [`${identity.pid}:${identity.startToken}:${identity.processGroupId}`, identity])).values()];
+            launch.pending = launch.identities.length === 0;
+            launch.uncertain ||= !event.complete;
+        }
+    }
+    store.saveSwarmRecovery(record.jobId, record);
+}
+export function finishRecoveryRecord(store, record) {
+    record.complete = !record.sessionDirty && record.launches.every((entry) => entry.quiescent)
+        && (record.workspaceRoot === null || record.patchPath !== null);
+    store.saveSwarmRecovery(record.jobId, record);
+}
+export function recoveryError(message) {
+    return new RuntimeError("SWARM_RECOVERY_REQUIRED", message, "swarm.recovery");
+}
+export async function assertRecoveryOwnerGone(record) {
+    if (!record.owner || process.platform === "win32")
+        throw recoveryError("No durable, verifiable owner identity; recovery requires manual inspection on this host.");
+    const probe = await probeProcessIdentity(record.ownerPid);
+    if (!probe.complete)
+        throw recoveryError("Cannot verify the original companion's identity.");
+    if (probe.identity?.startToken === record.owner.startToken && !/^[ZX]/i.test(probe.identity.state)) {
+        throw recoveryError("The original companion is still alive. Use cancel for a running job, not recovery.");
+    }
+}
+/**
+ * Linux may fall back from /proc to ps for a whole-group snapshot while targeted
+ * identity reads still use /proc. Those start tokens are different namespaces,
+ * not different processes. Prove both representations current around the known
+ * identity read; never accept a member based on PID/PGID equality alone.
+ */
+export async function validateRecoveryGroupMembers(known, members, validate = revalidateProcessIdentities) {
+    const membership = await validate(members);
+    const ownership = await validate(known);
+    const membershipAfter = await validate(membership.identities);
+    for (const proof of [membership, ownership, membershipAfter]) {
+        if (!proof.complete || proof.groupChanged?.length)
+            throw recoveryError("Process ownership or group membership is uncertain.");
+    }
+    for (const member of membershipAfter.identities) {
+        const owner = ownership.identities.find((id) => id.pid === member.pid && id.processGroupId === member.processGroupId);
+        const crossNamespace = owner && ((owner.startToken.startsWith("proc:") && member.startToken.startsWith("ps:")) ||
+            (owner.startToken.startsWith("ps:") && member.startToken.startsWith("proc:")));
+        if (!owner || (owner.startToken !== member.startToken && !crossNamespace)) {
+            throw recoveryError("An unrecorded process survives in the recorded group; refusing group cleanup.");
+        }
+    }
+    return ownership.identities;
+}
+/** Never signal an unproven group, PID replacement, or changed-PGID process. */
+export async function recoverLaunch(launch, persist, signal) {
+    if (launch.quiescent)
+        return;
+    if (launch.pending || launch.uncertain || launch.identities.length === 0) {
+        throw recoveryError("Launch ownership was not fully recorded before interruption; manual inspection is required. No process was signalled.");
+    }
+    const root = launch.identities[0];
+    const rootProbe = await probeProcessIdentity(root.pid);
+    if (!rootProbe.complete)
+        throw recoveryError("Process identity probe is incomplete.");
+    if (rootProbe.identity?.startToken === root.startToken) {
+        if (rootProbe.identity.processGroupId !== root.processGroupId)
+            throw recoveryError("The recorded root changed process groups; refusing to signal it.");
+        const descendants = await collectDescendantIdentities(root.pid);
+        // Revalidate the ancestry anchor after collection before retaining new identities.
+        const after = await probeProcessIdentity(root.pid);
+        if (!after.complete || after.identity?.startToken !== root.startToken || after.identity.processGroupId !== root.processGroupId) {
+            throw recoveryError("Process ownership changed during recovery inspection.");
+        }
+        launch.identities = [...new Map([...launch.identities, ...descendants].map((id) => [`${id.pid}:${id.startToken}:${id.processGroupId}`, id])).values()];
+        persist();
+    }
+    const inspect = async () => {
+        const members = await collectProcessGroupsIdentities(launch.identities.map((id) => id.processGroupId));
+        if (members === undefined)
+            throw recoveryError("Process group membership is unreadable.");
+        return validateRecoveryGroupMembers(launch.identities, members);
+    };
+    for (const [killSignal, waitMs] of [["SIGTERM", 1500], ["SIGKILL", 500]]) {
+        signal?.throwIfAborted();
+        for (const identity of await inspect()) {
+            signal?.throwIfAborted();
+            const current = await revalidateProcessIdentities([identity]);
+            if (!current.complete || current.groupChanged?.length)
+                throw recoveryError("Process identity changed before signalling.");
+            if (current.identities.length) {
+                try {
+                    process.kill(identity.pid, killSignal);
+                }
+                catch (error) {
+                    if (error.code !== "ESRCH")
+                        throw recoveryError("Unable to stop the recorded process.");
+                }
+            }
+        }
+        const deadline = Date.now() + waitMs;
+        do {
+            signal?.throwIfAborted();
+            if ((await inspect()).length === 0) {
+                launch.quiescent = true;
+                persist();
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        } while (Date.now() < deadline);
+    }
+    throw recoveryError("Recorded processes did not become quiescent; recovery remains pending.");
+}

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.1";
+export const KIMI_PLUGIN_CC_VERSION = "2.4.3";