kimi-plugin-cc 2.3.1 → 2.4.0

package/plugins/kimi-codex/dist/cli-client.js

@@ -305,7 +305,7 @@ export async function runCliPrompt(opts) {
         args,
         command_label: opts.commandLabel ?? null,
     });
-    return await new Promise((resolve, reject) => {
+    return await new Promise(async (resolve, reject) => {
         let aborted = false;
         let cancellationTeardown;
         let settlementStarted = false;
@@ -536,6 +536,16 @@ export async function runCliPrompt(opts) {
         if (opts.signal?.aborted === true) {
             onAbort();
         }
+        if (child.pid !== undefined && opts.onSpawn) {
+            try {
+                await opts.onSpawn(child.pid);
+            }
+            catch (error) {
+                onAbort();
+                settle("reject", new RuntimeError("CLI_SPAWN_CALLBACK_FAILED", `Failed to record the spawned kimi process: ${formatError(error)}`, "cli-client.spawn", error instanceof Error ? { cause: error, details: errorDetails() } : { details: errorDetails() }));
+                return;
+            }
+        }
         earlyErrorHandled = true;
         child.on("error", (err) => {
             appendLogLine({ event: "process_error", message: formatError(err) });

package/plugins/kimi-codex/dist/commands/ask.js

@@ -1,5 +1,5 @@
 import { companionHelp } from "../help.js";
-import { randomUUID } from "node:crypto";
+import { allocateJobId } from "../job-id.js";
 import path from "node:path";
 import { createCliCancellationHandlers } from "../cli-cancellation.js";
 import { runCliPromptWithBudget } from "../cli-client.js";
@@ -55,7 +55,7 @@ export async function runAsk(argv, context) {
     const store = new JobStore(paths);
     try {
         await sweepStaleJobs(store, paths);
-        const jobId = randomUUID();
+        const jobId = allocateJobId(context);
         const sessionResolution = await resolveAskSession(store, repoIdentity.repoId, parsed.fresh, parsed.resume, parsed.resumeTarget);
         const askPrompt = buildAskPrompt(parsed.prompt, sessionResolution.reusedSession);
         const executionPlan = await prepareKimiExecutionPlan({
@@ -152,6 +152,7 @@ export async function executeAskJob(jobId, prompt, context, options) {
         }
         handlers = createCliCancellationHandlers();
         const executionPlan = executionPlanFromPersisted(job);
+        store.updateRunningJob(job.job_id, { phase: "turn-running" });
         // Re-validate resume lineage from the store before spawning: a detached
         // worker (or a forged queued row) reloads the persisted plan and would
         // otherwise hand kimi_session_id to the spawn without the dispatch-time
@@ -174,6 +175,7 @@ export async function executeAskJob(jobId, prompt, context, options) {
             thinkingEffort: job.thinking_effort ?? undefined,
             resumeSessionId: job.kimi_session_id ?? undefined,
             logPath: job.stream_log_path,
+            onSpawn: (pid) => { store.updateRunningJob(job.job_id, { kimi_pid: pid }); },
             signal: handlers.signal,
         }, job.budget_ms ?? KIMI_ASK_PROMPT_TIMEOUT_MS, "ask.prompt");
         store.updateRunningJob(job.job_id, observedExecutionFields(result));

package/plugins/kimi-codex/dist/commands/cancel.js

@@ -5,6 +5,7 @@ import { markJobCancelled, sweepStaleJobs } from "../jobs.js";
 import { JobStore, withJobStore } from "../job-store.js";
 import { ensurePluginPaths, resolvePluginPaths } from "../paths.js";
 import { parseJobLookupArgs } from "../parsing.js";
+import { revalidateProcessIdentities } from "../process-tree.js";
 import { getManagedCommandConfig } from "./registry.js";
 export async function runCancel(argv, context) {
     const parsed = parseJobLookupArgs(argv);
@@ -31,6 +32,10 @@ export async function runCancel(argv, context) {
                 message: "cancel is a no-op for terminal jobs.",
             }, null, 2)}\n`;
         }
+        if (store.getMcpTask(job.job_id) &&
+            (context.mcpCompanionIdentity === undefined || context.mcpKimiIdentity === undefined)) {
+            throw new RuntimeError("MCP_CANCEL_REQUIRES_BINDING", `MCP job ${job.job_id} requires MCP job-control cancellation with recorded identities; use tasks/cancel or kimi_job_cancel.`, "mcp.cancel");
+        }
         if (job.pid === null && job.kimi_pid === null) {
             throw new RuntimeError("CANCEL_NOT_SUPPORTED", `Job ${job.job_id} does not have a recorded process id to cancel.`, "cancel.runtime");
         }
@@ -53,6 +58,7 @@ export async function runCancel(argv, context) {
             catch (error) {
                 preMarkError = error;
             }
+            await assertMcpCompanionIdentity(job, context.mcpCompanionIdentity);
             signalJobProcesses(job, "SIGTERM");
             await sleep(1_000);
             if (hasLiveRecordedProcess(job)) {
@@ -67,6 +73,8 @@ export async function runCancel(argv, context) {
                 message: "review_gate cancelled; SIGTERM→SIGKILL escalation completed.",
             }, null, 2)}\n`;
         }
+        await assertMcpCompanionIdentity(job, context.mcpCompanionIdentity);
+        await assertMcpKimiIdentity(job, context.mcpKimiIdentity);
         signalJobProcesses(job, "SIGTERM");
         const cancelled = await waitForCancellation(paths, job.job_id);
         if (cancelled) {
@@ -76,7 +84,11 @@ export async function runCancel(argv, context) {
                 message: "Cancellation completed.",
             }, null, 2)}\n`;
         }
-        signalJobProcesses(job, "SIGKILL");
+        const companionMatches = await assertMcpCompanionIdentity(job, context.mcpCompanionIdentity, true);
+        const kimiMatches = await assertMcpKimiIdentity(job, context.mcpKimiIdentity, true);
+        if (companionMatches || kimiMatches) {
+            signalJobProcesses(job, "SIGKILL", { companion: companionMatches, kimi: kimiMatches });
+        }
         await withJobStore(paths, async (forcedStore) => {
             const current = forcedStore.getJob(job.job_id);
             if (current?.status === "running") {
@@ -93,11 +105,38 @@ export async function runCancel(argv, context) {
         store.close();
     }
 }
-function signalJobProcesses(job, signal) {
+async function assertMcpCompanionIdentity(job, expected, allowMissing = false) {
+    return assertMcpProcessIdentity(job.pid, expected, "companion", allowMissing);
+}
+async function assertMcpKimiIdentity(job, expected, allowMissing = false) {
+    return assertMcpProcessIdentity(job.kimi_pid, expected, "Kimi", allowMissing);
+}
+async function assertMcpProcessIdentity(actualPid, expected, label, allowMissing) {
+    if (expected === undefined)
+        return true;
+    if (expected === null) {
+        if (actualPid === null)
+            return false;
+        throw new RuntimeError("CANCEL_NOT_SUPPORTED", `MCP job ${actualPid} has no verified ${label} identity; refusing PID-only cancellation.`, "mcp.cancel");
+    }
+    if (actualPid !== expected.pid) {
+        throw new RuntimeError("MCP_PROCESS_IDENTITY_MISMATCH", `The recorded ${label} process identity no longer matches; no signal was sent.`, "mcp.cancel");
+    }
+    const validation = await revalidateProcessIdentities([expected]);
+    if (!validation.complete) {
+        throw new RuntimeError("MCP_PROCESS_IDENTITY_UNAVAILABLE", `The ${label} identity probe was inconclusive; no further signal was sent and the job was not changed.`, "mcp.cancel");
+    }
+    const matches = validation.identities.length > 0;
+    if (!matches && !allowMissing) {
+        throw new RuntimeError("MCP_PROCESS_IDENTITY_MISMATCH", `The recorded ${label} process identity no longer matches; no signal was sent.`, "mcp.cancel");
+    }
+    return matches;
+}
+function signalJobProcesses(job, signal, include = { companion: true, kimi: true }) {
     const pids = new Set();
-    if (job.pid !== null)
+    if (include.companion && job.pid !== null)
         pids.add(job.pid);
-    if (job.kimi_pid !== null)
+    if (include.kimi && job.kimi_pid !== null)
         pids.add(job.kimi_pid);
     for (const pid of pids) {
         try {

package/plugins/kimi-codex/dist/commands/pursue.js

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { allocateJobId } from "../job-id.js";
 import path from "node:path";
 import { createCliCancellationHandlers } from "../cli-cancellation.js";
 import { runCliPromptWithBudget } from "../cli-client.js";
@@ -122,7 +122,7 @@ export async function runPursue(argv, context) {
             env: context.env,
         });
         const prompt = buildGoalPrompt(objective, parsed.turns);
-        const jobId = randomUUID();
+        const jobId = allocateJobId(context);
         const logPath = path.join(paths.logsDir, `pursue-${jobId}.jsonl`);
         const job = store.createJob({
             job_id: jobId,
@@ -226,6 +226,7 @@ async function executePursueJob(jobId, prompt, objective, budgetMs, context) {
             model: job.model ?? undefined,
             thinkingEffort: job.thinking_effort ?? undefined,
             logPath: job.stream_log_path,
+            onSpawn: (pid) => { store.updateRunningJob(job.job_id, { kimi_pid: pid }); },
             signal: handlers.signal,
         }, budgetMs, "pursue.prompt");
         store.updateRunningJob(job.job_id, observedExecutionFields(result));

package/plugins/kimi-codex/dist/commands/rescue.js

@@ -1,5 +1,5 @@
 import { companionHelp } from "../help.js";
-import { randomUUID } from "node:crypto";
+import { allocateJobId } from "../job-id.js";
 import path from "node:path";
 import { createCliCancellationHandlers } from "../cli-cancellation.js";
 import { runCliPromptWithBudget } from "../cli-client.js";
@@ -61,7 +61,7 @@ export async function runRescue(argv, context) {
             resumeSessionId: sessionResolution.kimiSessionId ?? undefined,
             resumeSource: sessionResolution.sourceJob,
         });
-        const jobId = randomUUID();
+        const jobId = allocateJobId(context);
         const logPath = path.join(paths.logsDir, `rescue-${jobId}.jsonl`);
         const job = store.createJob({
             job_id: jobId,
@@ -192,6 +192,7 @@ export async function executeRescueJob(jobId, prompt, context, options) {
             thinkingEffort: job.thinking_effort ?? undefined,
             resumeSessionId: job.kimi_session_id ?? undefined,
             logPath: job.stream_log_path,
+            onSpawn: (pid) => { store.updateRunningJob(job.job_id, { kimi_pid: pid }); },
             signal: handlers.signal,
         }, job.budget_ms ?? KIMI_RESCUE_PROMPT_TIMEOUT_MS, "rescue.prompt");
         store.updateRunningJob(job.job_id, observedExecutionFields(result));

package/plugins/kimi-codex/dist/commands/review-gate.js

@@ -166,10 +166,7 @@ async function executeReviewGate(payload, assistantMessage, context) {
         try {
             const activeStore = store;
             // runCliPromptWithBudget ties the 8 s timeout to an AbortController
-            // that kills the kimi child on expiry — review_gate runs inside
-            // Claude Code's Stop hook, so a runaway kimi after timeout would
-            // hold model tokens with no way for /kimi:cancel to reach it
-            // (the SQLite row's kimi_pid is null). See reports/17 and 18.
+            // that kills the kimi child on expiry and records its PID at spawn.
             const result = await runCliPromptWithBudget({
                 cwd: payload.cwd,
                 env: context.env,
@@ -182,6 +179,7 @@ async function executeReviewGate(payload, assistantMessage, context) {
                 // Requested via env; provider/model may ignore it. The 8s budget still applies.
                 thinkingEffort,
                 logPath,
+                onSpawn: (pid) => { activeStore.updateRunningJob(job.job_id, { kimi_pid: pid }); },
             }, KIMI_REVIEW_GATE_TIMEOUT_MS, "review_gate.runtime");
             activeStore.updateRunningJob(job.job_id, observedExecutionFields(result));
             assertCliResultSuccess(result, "review_gate.runtime");

package/plugins/kimi-codex/dist/commands/review.js

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { allocateJobId } from "../job-id.js";
 import path from "node:path";
 import process from "node:process";
 import { createCliCancellationHandlers } from "../cli-cancellation.js";
@@ -38,7 +38,7 @@ export async function runReview(argv, context, commandType) {
         env: context.env,
     });
     const store = new JobStore(paths);
-    const jobId = randomUUID();
+    const jobId = allocateJobId(context);
     // Leave kimi_session_id NULL until kimi announces an actual ID; never invent
     // one that no on-disk session matches.
     const reviewSessionId = null;
@@ -75,6 +75,7 @@ export async function runReview(argv, context, commandType) {
     const reviewConfig = getManagedCommandConfig(commandType);
     const cancel = reviewConfig.cancellation;
     const handlers = createCliCancellationHandlers();
+    store.updateRunningJob(job.job_id, { phase: "turn-running" });
     try {
         const result = await runCliPromptWithBudget({
             cwd: context.cwd,
@@ -87,6 +88,7 @@ export async function runReview(argv, context, commandType) {
             model: parsed.model,
             thinkingEffort: parsed.thinkingEffort,
             logPath,
+            onSpawn: (pid) => { store.updateRunningJob(job.job_id, { kimi_pid: pid }); },
             signal: handlers.signal,
         }, job.budget_ms ?? KIMI_REVIEW_PROMPT_TIMEOUT_MS, `${commandType}.prompt`);
         store.updateRunningJob(job.job_id, observedExecutionFields(result));

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

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { allocateJobId } from "../job-id.js";
 import { mkdir, readdir, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { createCliCancellationHandlers } from "../cli-cancellation.js";
@@ -180,7 +180,7 @@ async function runReadSwarm(parsed, objective, context) {
             env: context.env,
         });
         const prompt = buildSwarmPrompt(objective, parsed.cap);
-        const jobId = randomUUID();
+        const jobId = allocateJobId(context);
         const logPath = path.join(paths.logsDir, `swarm-${jobId}.jsonl`);
         const job = store.createJob({
             job_id: jobId,
@@ -257,7 +257,7 @@ async function runWriteSwarm(parsed, objective, context) {
             context.stderr.write("[kimi-plugin-cc] /kimi:swarm --write bases its worktree on HEAD — your uncommitted changes are NOT visible to the swarm. Commit or stash them first if the swarm needs them.\n");
         }
         const prompt = buildSwarmWritePrompt(objective, parsed.cap);
-        const jobId = randomUUID();
+        const jobId = allocateJobId(context);
         const logPath = path.join(paths.logsDir, `swarm-write-${jobId}.jsonl`);
         // Namespace worktrees per repo so the cross-repo sweep below only ever
         // touches THIS repo's subtree (the worktreesDir is a single global dir shared
@@ -493,6 +493,7 @@ writeMode) {
             model: job.model ?? undefined,
             thinkingEffort: job.thinking_effort ?? undefined,
             logPath: job.stream_log_path,
+            onSpawn: (pid) => { store.updateRunningJob(job.job_id, { kimi_pid: pid }); },
             signal: handlers.signal,
         }, budgetMs, "swarm.prompt");
         store.updateRunningJob(job.job_id, observedExecutionFields(result));

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

@@ -1,20 +1,17 @@
 import { companionHelp } from "./help.js";
-import { runAsk } from "./commands/ask.js";
 import { runModelInventory } from "./commands/models.js";
 import { runCancel } from "./commands/cancel.js";
-import { notImplementedCompanionCommand } from "./commands/not-implemented.js";
 import { runReplay } from "./commands/replay.js";
 import { runRepairSessions } from "./commands/repair-sessions.js";
 import { runResult } from "./commands/result.js";
-import { runReview } from "./commands/review.js";
-import { runRescue } from "./commands/rescue.js";
-import { runPursue } from "./commands/pursue.js";
-import { runSwarm } from "./commands/swarm.js";
 import { renderSetupResult, runSetup } from "./commands/setup.js";
 import { runStatus } from "./commands/status.js";
 import { runWorker } from "./commands/worker.js";
 import { formatError, RuntimeError } from "./errors.js";
 import { resolveKimiHome } from "./kimi-home.js";
+import { runModelCommand } from "./model-command.js";
+import { runMcpChild } from "./mcp/supervised-child.js";
+import { runMcpServer } from "./mcp/server.js";
 async function main(argv) {
     const help = companionHelp(argv);
     if (help !== undefined) {
@@ -27,11 +24,16 @@ async function main(argv) {
         cwd,
         env: {
             ...process.env,
-            KIMI_CODE_HOME: resolveKimiHome(process.env, cwd),
+            KIMI_CODE_HOME: command === "mcp" ? process.env.KIMI_CODE_HOME : resolveKimiHome(process.env, cwd),
         },
         stdout: process.stdout,
         stderr: process.stderr,
     };
+    const modelResult = await runModelCommand(argv, context);
+    if (modelResult !== undefined) {
+        context.stdout.write(modelResult);
+        return;
+    }
     switch (command) {
         case "setup": {
             if (rest.includes("--models")) {
@@ -57,41 +59,12 @@ async function main(argv) {
             }
             return;
         }
-        case "review": {
-            const result = await runReview(rest, context, "review");
-            context.stdout.write(`${result}\n`);
-            return;
-        }
-        case "task": {
-            const [taskType, ...taskArgs] = rest;
-            if (taskType === "rescue") {
-                const result = await runRescue(taskArgs, context);
-                context.stdout.write(result);
-                return;
-            }
-            if (taskType === "challenge") {
-                const result = await runReview(taskArgs, context, "challenge");
-                context.stdout.write(`${result}\n`);
-                return;
-            }
-            if (taskType === "pursue") {
-                const result = await runPursue(taskArgs, context);
-                context.stdout.write(result);
-                return;
-            }
-            if (taskType === "swarm") {
-                const result = await runSwarm(taskArgs, context);
-                context.stdout.write(result);
-                return;
-            }
-            notImplementedCompanionCommand(taskType ? `task ${taskType}` : "task");
+        case "mcp":
+            await runMcpServer(context);
             return;
-        }
-        case "ask": {
-            const result = await runAsk(rest, context);
-            context.stdout.write(`${result}\n`);
+        case "mcp-child":
+            context.stdout.write(await runMcpChild(rest, context));
             return;
-        }
         case "status":
             context.stdout.write(await runStatus(rest, context));
             return;

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

@@ -35,6 +35,8 @@ export function companionHelp(argv) {
         case "replay": return usage(command, "<job-id>", REPLAY_SUPPORTED_FLAGS, "Replay a completed job's persisted stream log.");
         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.";
+        case "mcp-child": return "Usage: companion.sh mcp-child <job-uuid> <model-operation> [arguments]. Internal supervised MCP child; launched by the MCP server, not manually.";
         default: return undefined;
     }
 }

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

@@ -0,0 +1,12 @@
+import { randomUUID } from "node:crypto";
+import { RuntimeError } from "./errors.js";
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export function allocateJobId(context) {
+    const fixed = context.mcpJobId;
+    if (fixed === undefined)
+        return randomUUID();
+    if (!UUID_PATTERN.test(fixed)) {
+        throw new RuntimeError("MCP_INVALID_JOB_ID", "The supervised job ID must be a valid UUID.", "mcp.child");
+    }
+    return fixed;
+}

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

@@ -99,6 +99,25 @@ export class JobStore {
                 }
             }
             this.db.exec(`
+      CREATE TABLE IF NOT EXISTS mcp_tasks (
+        task_id TEXT PRIMARY KEY,
+        operation_kind TEXT NOT NULL,
+        repo_id TEXT NOT NULL,
+        workspace_cwd TEXT NOT NULL,
+        companion_pid INTEGER,
+        companion_identity TEXT,
+        kimi_identity TEXT,
+        stdout_path TEXT NOT NULL,
+        stderr_path TEXT NOT NULL,
+        launch_state TEXT NOT NULL,
+        launch_error TEXT,
+        created_at TEXT NOT NULL,
+        attached_at TEXT,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS mcp_tasks_workspace_updated_idx
+        ON mcp_tasks (workspace_cwd, updated_at DESC);
 
       CREATE INDEX IF NOT EXISTS jobs_repo_updated_idx
         ON jobs (repo_id, updated_at DESC);
@@ -150,6 +169,9 @@ export class JobStore {
       -- 0.1.6 migration: rename adversarial_review to challenge
       UPDATE jobs SET command_type = 'challenge' WHERE command_type = 'adversarial_review';
     `);
+            if (!mcpTableHasColumn(this.db, "kimi_identity")) {
+                this.db.exec("ALTER TABLE mcp_tasks ADD COLUMN kimi_identity TEXT;");
+            }
         }
         catch (error) {
             // Migration failed — close the adapter so the OS handle is released
@@ -258,6 +280,40 @@ export class JobStore {
       `, repoId, sessionId);
         return row ? hydrateRow(row) : null;
     }
+    createMcpTask(input) {
+        const now = new Date().toISOString();
+        try {
+            this.db.run(`
+        INSERT INTO mcp_tasks (
+          task_id, operation_kind, repo_id, workspace_cwd, companion_pid, companion_identity, kimi_identity,
+          stdout_path, stderr_path, launch_state, launch_error, created_at, attached_at, updated_at
+        ) VALUES (
+          @task_id, @operation_kind, @repo_id, @workspace_cwd, NULL, NULL, NULL,
+          @stdout_path, @stderr_path, 'starting', NULL, @created_at, NULL, @updated_at
+        )
+      `, { ...input, created_at: now, updated_at: now });
+        }
+        catch (error) {
+            throw translateSqliteError(error);
+        }
+        return this.getMcpTask(input.task_id);
+    }
+    getMcpTask(taskId) {
+        return this.db.get("SELECT * FROM mcp_tasks WHERE task_id = ?", taskId) ?? null;
+    }
+    updateMcpTask(taskId, patch) {
+        const updates = ["updated_at = @updated_at"];
+        const params = { task_id: taskId, updated_at: new Date().toISOString() };
+        for (const key of ["companion_pid", "companion_identity", "kimi_identity", "launch_state", "launch_error", "attached_at"]) {
+            const value = patch[key];
+            if (value === undefined)
+                continue;
+            updates.push(`${key} = @${key}`);
+            params[key] = value;
+        }
+        this.db.run(`UPDATE mcp_tasks SET ${updates.join(", ")} WHERE task_id = @task_id`, params);
+        return this.getMcpTask(taskId);
+    }
     updateRunningJob(jobId, patch) {
         return this.updateWhere(jobId, patch, "status = 'running'");
     }
@@ -524,6 +580,9 @@ function tableHasColumn(db, columnName) {
     const columns = db.all(`PRAGMA table_info(jobs)`);
     return columns.some((column) => column.name === columnName);
 }
+function mcpTableHasColumn(db, columnName) {
+    return db.all("PRAGMA table_info(mcp_tasks)").some((column) => column.name === columnName);
+}
 function isSqliteConstraintError(error) {
     const message = formatError(error).toLowerCase();
     return message.includes("unique constraint") || message.includes("constraint failed");

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

@@ -30,6 +30,9 @@ export function normalizeJobError(error) {
     };
 }
 export async function markJobFailed(store, paths, job, error, summary = "Job failed.", options) {
+    const current = store.getJob(job.job_id) ?? job;
+    if (current.status !== "running")
+        return current;
     if (options?.partialOutput) {
         const label = job.command_type[0].toUpperCase() + job.command_type.slice(1);
         summary = `${label} timed out after ${formatBudgetDuration(options.partialOutput.budgetMs)}; partial output captured (${options.partialOutput.text.trim().length} chars).`;
@@ -55,6 +58,9 @@ export async function markJobFailed(store, paths, job, error, summary = "Job fai
     }) ?? artifactJob);
 }
 export async function markJobCancelled(store, paths, job, summary, error, options) {
+    const current = store.getJob(job.job_id) ?? job;
+    if (current.status !== "running")
+        return current;
     const normalized = error ? normalizeJobError(error) : null;
     const phase = options?.phase;
     const artifactJob = {
@@ -77,6 +83,8 @@ export async function markJobCancelled(store, paths, job, summary, error, option
 }
 export async function sweepStaleJobs(store, paths) {
     for (const job of store.listRunningJobsWithProcessHints()) {
+        if (store.getMcpTask(job.job_id))
+            continue;
         if (!isStaleEnoughToSweep(job)) {
             continue;
         }
@@ -109,7 +117,7 @@ export async function sweepStaleJobs(store, paths) {
         await markJobFailed(store, paths, job, new RuntimeError("FOREGROUND_PROCESS_DISAPPEARED", describeMissingForegroundProcess(job, companionMissing, kimiMissing), "jobs.sweep"), "Foreground Kimi job disappeared before reporting a terminal state.", job.command_type === "ask" || job.command_type === "rescue" ? { phase: "failed" } : undefined);
     }
 }
-const STALE_SWEEP_GRACE_MS = 15_000;
+export const STALE_SWEEP_GRACE_MS = 15_000;
 function isStaleEnoughToSweep(job) {
     const updatedAt = Date.parse(job.updated_at);
     return Number.isFinite(updatedAt) && Date.now() - updatedAt >= STALE_SWEEP_GRACE_MS;

package/plugins/kimi-codex/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 },
+    });
+}