kimi-plugin-cc 2.0.7 → 2.2.0

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

@@ -84,7 +84,9 @@ export async function runCliPrompt(opts) {
         });
     }
     let child;
+    let spawnedAt;
     try {
+        spawnedAt = Date.now();
         child = spawn(opts.command, args, {
             cwd: opts.cwd,
             env,
@@ -329,7 +331,7 @@ export async function runCliPrompt(opts) {
                     return;
                 }
                 if (kind === "resolve")
-                    resolve(payload);
+                    resolve({ ...payload, settledAt: Date.now() });
                 else
                     reject(payload);
             });
@@ -580,6 +582,8 @@ export async function runCliPrompt(opts) {
             // The result itself is in memory; diagnostics are best-effort.
             await raceWithTimeout(logChain, LOG_DRAIN_TIMEOUT_MS);
             settle("resolve", {
+                spawnedAt,
+                settledAt: 0, // Filled at settlement, after the teardown barrier.
                 sessionId,
                 goalSummary: announcedGoalSummary,
                 systemVersion: announcedSystemVersion,
@@ -656,6 +660,27 @@ export function requireSessionId(result, context) {
         },
     });
 }
+/** Settled timeout data; stream records are deliberately non-serializable.
+ * Without a partial result (teardown rejection), aborted means abort was issued,
+ * not that the process was observed aborting. */
+export class ResponseTimeoutError extends RuntimeError {
+    constructor(budgetMs, stage, commandLabel, partialResult, cause) {
+        super("RESPONSE_TIMEOUT", `${stage} timed out after ${budgetMs}ms.`, stage, {
+            ...(cause instanceof Error ? { cause } : {}),
+            details: {
+                budget_ms: budgetMs,
+                command_label: commandLabel ?? null,
+                record_count: partialResult?.records.length ?? 0,
+                partial_output_chars: partialResult?.records.reduce((count, record) => count + (record.role === "assistant" && typeof record.content === "string" ? record.content.length : 0), 0) ?? 0,
+                aborted: partialResult?.aborted ?? true,
+                ...(partialResult ? { settled_post_abort: true } : {}),
+            },
+        });
+        this.name = "ResponseTimeoutError";
+        // Never serialize stream records into job error details or error envelopes.
+        Object.defineProperty(this, "partialResult", { value: partialResult, enumerable: false });
+    }
+}
 /**
  * Run `kimi -p` under a budget that also tells the subprocess to die
  * when the budget expires.
@@ -682,7 +707,8 @@ export function requireSessionId(result, context) {
  *     subprocess/tree teardown, then reject with
  *     `RuntimeError("RESPONSE_TIMEOUT", …)` matching the legacy
  *     `withTimeout` code shape.
- *   - Result success path is unchanged from `runCliPrompt`.
+ *   - A clean non-aborted exit-0 result wins same-tick budget expiry.
+ *     Otherwise a settled result on timeout is carried as partial output.
  */
 export async function runCliPromptWithBudget(opts, budgetMs, stage) {
     const controller = new AbortController();
@@ -698,12 +724,7 @@ export async function runCliPromptWithBudget(opts, budgetMs, stage) {
         controller.abort();
     }, budgetMs);
     timer.unref();
-    const timeoutError = (raceDetected = false) => new RuntimeError("RESPONSE_TIMEOUT", `${stage} timed out after ${budgetMs}ms${raceDetected ? " (race detected post-result)" : ""}.`, stage, {
-        details: {
-            budget_ms: budgetMs,
-            command_label: opts.commandLabel ?? null,
-        },
-    });
+    const timeoutError = (partialResult, cause) => new ResponseTimeoutError(budgetMs, stage, opts.commandLabel, partialResult, cause);
     try {
         let result;
         try {
@@ -714,13 +735,13 @@ export async function runCliPromptWithBudget(opts, budgetMs, stage) {
         }
         catch (error) {
             if (timeoutFired)
-                throw timeoutError();
+                throw timeoutError(undefined, error);
             throw error;
         }
-        if (timeoutFired) {
-            // The timer and close can become runnable in the same event-loop turn.
-            // Teardown has still completed because runCliPrompt settled first.
-            throw timeoutError(true);
+        if (timeoutFired && (result.aborted || result.exitCode !== 0)) {
+            // A clean, non-aborted result won the settle/timeout boundary and is success.
+            // Budget aborts normally resolve with records, after owned teardown settles.
+            throw timeoutError(result);
         }
         return result;
     }
@@ -770,6 +791,8 @@ function buildArgs(opts) {
 }
 function buildEnv(opts) {
     const env = { ...opts.env };
+    // 2.2.0 audit: ambient trust starts project MCP stdio servers outside PreToolUse.
+    delete env.KIMI_CODE_TRUST_WORKSPACE;
     // kimi-code 0.33.0 inverted its CLI engine default: an unflagged `kimi -p`
     // now selects native agent-core-v2, while this upstream-documented flag pins
     // the legacy-v1 path. Native v2 still has a final-allow plan-file path that

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

@@ -1,3 +1,4 @@
+import { companionHelp } from "../help.js";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { createCliCancellationHandlers } from "../cli-cancellation.js";
@@ -16,7 +17,7 @@ import { readArtifact, renderManagedJobOutput, writeArtifact } from "../render.j
 import { classifyManagedCommandFailure } from "../kimi-errors.js";
 import { startBackgroundJob } from "../background-spawn.js";
 import { hookRefusalDetails, hookRefusalRetryProtocol, maybeWarnHookMissing, verifyHookInstalled, } from "../hooks/install.js";
-import { assertCliResultSuccess, reassembleProseFromRecords, warnIfSessionIdMissing } from "./cli-helpers.js";
+import { warnInheritedBudget, captureTimeoutPartialOutput, assertCliResultSuccess, reassembleProseFromRecords, warnIfSessionIdMissing } from "./cli-helpers.js";
 import { buildKimiSessionTitle, syncKimiSessionTitle } from "../session-title.js";
 // v1.0 cutover note (PR 2):
 //
@@ -46,6 +47,8 @@ const ASK_PROMPT_PREFIX = [
 ].join("\n");
 export async function runAsk(argv, context) {
     const parsed = parseAskArgs(argv);
+    if (parsed.help)
+        return companionHelp(["ask", ...argv]);
     if (context.env.KIMI_PLUGIN_CC_SKIP_HOOK_CHECK !== "1") {
         await requireAskHookInstalled(context);
     }
@@ -76,10 +79,14 @@ export async function runAsk(argv, context) {
             model: parsed.model ?? null,
             thinking: parsed.thinking ?? null,
             background: parsed.background,
+            budget_ms: parsed.budgetMs ?? (sessionResolution.sourceJob?.operation_kind === "ask" ? sessionResolution.sourceJob.budget_ms : null) ?? null,
+            budget_source: parsed.budgetMs !== undefined ? "explicit"
+                : sessionResolution.sourceJob?.operation_kind === "ask" && sessionResolution.sourceJob.budget_ms !== null ? "inherited" : "default",
             pid: parsed.background ? null : process.pid,
             kimi_pid: null,
             status: "running",
             kimi_session_id: sessionResolution.kimiSessionId,
+            kimi_session_id_source: sessionResolution.sourceJob?.kimi_session_id_source ?? null,
             ...persistedExecutionPlanFields(executionPlan),
             agent_profile: ASK_AGENT_PROFILE_PLACEHOLDER,
             prompt_digest: digestPrompt(askPrompt),
@@ -101,6 +108,7 @@ export async function runAsk(argv, context) {
             await markJobFailed(store, paths, job, classified, askConfig.cancellation.failedSummary, { phase: "failed" });
             throw classified;
         }
+        warnInheritedBudget(job, context.stderr);
         if (parsed.background) {
             return startBackgroundJob(job, askPrompt, context, paths, {
                 workerKind: "ask",
@@ -169,7 +177,7 @@ export async function executeAskJob(jobId, prompt, context, options) {
             resumeSessionId: job.kimi_session_id ?? undefined,
             logPath: job.stream_log_path,
             signal: handlers.signal,
-        }, KIMI_ASK_PROMPT_TIMEOUT_MS, "ask.prompt");
+        }, job.budget_ms ?? KIMI_ASK_PROMPT_TIMEOUT_MS, "ask.prompt");
         store.updateRunningJob(job.job_id, observedExecutionFields(result));
         if (handlers.cancelling) {
             throw new RuntimeError(cancel.errorCodes.cancelled, cancel.cancelMessages.afterPrompt, "ask.runtime");
@@ -180,12 +188,11 @@ export async function executeAskJob(jobId, prompt, context, options) {
         // sessions it should match the input, but capture anyway in case
         // kimi-code mints a new id on each turn.
         if (result.sessionId !== undefined &&
-            result.sessionId.length > 0 &&
-            result.sessionId !== job.kimi_session_id) {
+            result.sessionId.length > 0) {
             // length>0 guard: empty-string capture would poison the row. The
             // warning helper's null-ish check would also fire but only after
             // the bad write. (Kimi alpha.4 challenge finding #3.)
-            store.updateRunningJob(job.job_id, { kimi_session_id: result.sessionId });
+            store.updateRunningJob(job.job_id, { kimi_session_id_source: "announced", kimi_session_id: result.sessionId });
         }
         await syncKimiSessionTitle({
             promptText: prompt,
@@ -215,6 +222,9 @@ export async function executeAskJob(jobId, prompt, context, options) {
         }) ?? job);
     }
     catch (error) {
+        const classified = error instanceof RuntimeError && error.stage === "ask.hook-check" ? error
+            : classifyManagedCommandFailure(error, "ask", job.job_id, { background: job.background, budgetMs: job.budget_ms ?? KIMI_ASK_PROMPT_TIMEOUT_MS });
+        const partialOutput = await captureTimeoutPartialOutput(classified, store, job, context.env, handlers?.signal);
         if (handlers?.cancelling) {
             const cancelledError = new RuntimeError(cancel.errorCodes.cancelled, cancel.cancelMessages.default, "ask.runtime", error instanceof Error ? { cause: error } : undefined);
             return await markJobCancelled(store, paths, job, cancel.cancelledSummary, cancelledError, { phase: "cancelled" });
@@ -227,8 +237,7 @@ export async function executeAskJob(jobId, prompt, context, options) {
             await markJobFailed(store, paths, job, error, cancel.failedSummary, { phase: "failed" });
             throw error;
         }
-        const classified = classifyManagedCommandFailure(error, "ask", job.job_id);
-        await markJobFailed(store, paths, job, classified, cancel.failedSummary, { phase: "failed" });
+        await markJobFailed(store, paths, job, classified, cancel.failedSummary, { phase: "failed", partialOutput });
         throw classified;
     }
     finally {

package/plugins/kimi-codex/dist/commands/cli-helpers.js

@@ -1,4 +1,9 @@
 import { RuntimeError } from "../errors.js";
+import { ResponseTimeoutError } from "../cli-client.js";
+import { observedExecutionFields } from "../kimi-engine.js";
+import { resolveKimiHome } from "../kimi-home.js";
+import { recoverSessionIdFromStore } from "../session-recovery.js";
+import { formatBudgetDuration } from "../render.js";
 /**
  * Reassemble prose final text from cli-client records.
  *
@@ -110,3 +115,78 @@ export function assertCliResultSuccess(result, stage) {
         });
     }
 }
+/** Timeout-only capture. Cancellation takes precedence, including while the
+ * asynchronous store scan is in flight. No title sync on failure. */
+export async function captureTimeoutPartialOutput(classified, store, job, env, cancellationSignal) {
+    if (cancellationSignal?.aborted)
+        return undefined;
+    const timeout = classified.cause;
+    if (!(timeout instanceof ResponseTimeoutError) || !timeout.partialResult)
+        return undefined;
+    const result = timeout.partialResult;
+    let sessionId = result.sessionId;
+    let source = sessionId ? "announced" : null;
+    const details = classified instanceof RuntimeError ? classified.details : timeout.details;
+    details.kimi_session_id_source = job.kimi_session_id_source;
+    // The persisted plan is plugin-owned. Recovery never runs on cancellation,
+    // v1, successful turns, teardown rejection, or an already-known resume id.
+    if (!sessionId && !job.kimi_session_id && job.intended_engine === "native-v2") {
+        // Without the system.version marker the row has no proven engine, and
+        // resume would refuse the id as lineage-unknown; do not advertise one.
+        if (result.observedEngine === null) {
+            details.session_recovery = "engine_unobserved";
+        }
+        else {
+            const recovered = await recoverSessionIdFromStore({
+                kimiHome: resolveKimiHome(env, job.cwd), cwd: job.cwd,
+                spawnedAt: result.spawnedAt, settledAt: result.settledAt, promptDigest: job.prompt_digest,
+                store, jobId: job.job_id,
+            });
+            sessionId = recovered.sessionId;
+            if (sessionId)
+                source = "recovered_session_dir";
+            else
+                details.session_recovery = recovered.reason;
+        }
+    }
+    if (cancellationSignal?.aborted)
+        return undefined;
+    // Best-effort metadata only. The row is still `running`, and a session id
+    // written here can collide with `jobs_running_session_idx` when a resume of
+    // the same session was started while this job ran. A store error must never
+    // prevent markJobFailed from running — the partial artifact matters more
+    // than the metadata, so swallow and fall through.
+    try {
+        store.updateRunningJob(job.job_id, observedExecutionFields(result));
+        if (sessionId) {
+            const updated = source === "recovered_session_dir"
+                ? store.claimRecoveredSessionId(job.job_id, sessionId)
+                : store.updateRunningJob(job.job_id, { kimi_session_id: sessionId, kimi_session_id_source: source });
+            if (updated?.kimi_session_id === sessionId && updated.kimi_session_id_source === source) {
+                details.kimi_session_id = sessionId;
+                details.kimi_session_id_source = source;
+            }
+            else
+                details[source === "recovered_session_dir" ? "session_recovery" : "session_id_persistence"] = "persistence_failed";
+        }
+    }
+    catch {
+        // `session_recovery` describes only the recovery branch; an announced id or
+        // the provenance update failing is a different fact.
+        details[source === "recovered_session_dir" ? "session_recovery" : "session_id_persistence"] = "persistence_failed";
+        // Diagnostics stay in the stream log; the failure transition proceeds.
+    }
+    return {
+        text: reassembleProseFromRecords(result.records),
+        toolCalls: result.records.some((record) => record.role === "tool" ||
+            (record.role === "assistant" && Array.isArray(record.tool_calls) &&
+                record.tool_calls.length > 0)),
+        recordCount: result.records.length,
+        budgetMs: timeout.details.budget_ms,
+    };
+}
+export function warnInheritedBudget(job, stderr) {
+    if (job.budget_source === "inherited" && job.budget_ms !== null) {
+        stderr.write(`[${job.command_type}] budget ${formatBudgetDuration(job.budget_ms)} inherited from job ${job.resumed_from_job_id}; pass --budget to override\n`);
+    }
+}

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

@@ -143,6 +143,8 @@ export async function runPursue(argv, context) {
             model: parsed.model ?? null,
             thinking: parsed.thinking ?? null,
             background: false,
+            budget_ms: parsed.budgetMs ?? KIMI_PURSUE_DEFAULT_BUDGET_MS,
+            budget_source: parsed.budgetMs !== undefined ? "explicit" : "default",
             pid: process.pid,
             kimi_pid: null,
             status: "running",
@@ -168,7 +170,7 @@ export async function runPursue(argv, context) {
             await markJobFailed(store, paths, job, classified, "Pursue failed.", { phase: "failed" });
             throw classified;
         }
-        const completed = await executePursueJob(job.job_id, prompt, objective, parsed.budgetMs ?? KIMI_PURSUE_DEFAULT_BUDGET_MS, context);
+        const completed = await executePursueJob(job.job_id, prompt, objective, job.budget_ms, context);
         if (!completed.final_output_path) {
             throw new RuntimeError("PURSUE_RESULT_MISSING", "Pursue finished without a rendered result.", "pursue.result");
         }
@@ -249,7 +251,7 @@ async function executePursueJob(jobId, prompt, objective, budgetMs, context) {
         if (result.sessionId !== undefined &&
             result.sessionId.length > 0 &&
             result.sessionId !== job.kimi_session_id) {
-            store.updateRunningJob(job.job_id, { kimi_session_id: result.sessionId });
+            store.updateRunningJob(job.job_id, { kimi_session_id_source: "announced", kimi_session_id: result.sessionId });
         }
         await syncKimiSessionTitle({
             promptText: objective,

package/plugins/kimi-codex/dist/commands/repair-sessions.js

@@ -1,3 +1,4 @@
+import { REPAIR_SESSIONS_SUPPORTED_FLAGS } from "../parsing.js";
 import { constants } from "node:fs";
 import { lstat, open } from "node:fs/promises";
 import { createRequire } from "node:module";
@@ -15,7 +16,7 @@ export async function runRepairSessions(argv, context) {
     const seen = new Set();
     for (const arg of argv) {
         if ((arg !== "--apply" && arg !== "--all") || seen.has(arg)) {
-            throw new RuntimeError("INVALID_ARGS", "Usage: repair-sessions [--apply] [--all]", "repair-sessions.args");
+            throw new RuntimeError("INVALID_ARGS", `Usage: repair-sessions. Supported flags: ${REPAIR_SESSIONS_SUPPORTED_FLAGS}.`, "repair-sessions.args");
         }
         seen.add(arg);
     }

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

@@ -1,3 +1,4 @@
+import { REPLAY_SUPPORTED_FLAGS } from "../parsing.js";
 import { access, stat, readFile } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
 import { RuntimeError } from "../errors.js";
@@ -9,8 +10,8 @@ import { sweepStaleJobs } from "../jobs.js";
 const MAX_REPLAY_LOG_BYTES = 32 * 1024 * 1024;
 export async function runReplay(argv, context) {
     const [jobId, ...rest] = argv;
-    if (!jobId || rest.length > 0) {
-        throw new RuntimeError("INVALID_ARGS", "replay expects exactly one job id: replay <job-id>.", "replay.parse");
+    if (!jobId || jobId.startsWith("-") || rest.length > 0) {
+        throw new RuntimeError("INVALID_ARGS", `replay expects exactly one job id: replay <job-id>. Supported flags: ${REPLAY_SUPPORTED_FLAGS}.`, "replay.parse");
     }
     const paths = resolvePluginPaths(context.env);
     await ensurePluginPaths(paths);

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

@@ -1,3 +1,4 @@
+import { companionHelp } from "../help.js";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { createCliCancellationHandlers } from "../cli-cancellation.js";
@@ -16,7 +17,7 @@ import { parseRescueArgs } from "../parsing.js";
 import { readArtifact, renderManagedJobOutput, writeArtifact } from "../render.js";
 import { startBackgroundJob } from "../background-spawn.js";
 import { hookRefusalDetails, hookRefusalRetryProtocol, maybeWarnHookMissing, verifyHookInstalled, } from "../hooks/install.js";
-import { assertCliResultSuccess, reassembleProseFromRecords, warnIfSessionIdMissing } from "./cli-helpers.js";
+import { warnInheritedBudget, captureTimeoutPartialOutput, assertCliResultSuccess, reassembleProseFromRecords, warnIfSessionIdMissing } from "./cli-helpers.js";
 import { buildKimiSessionTitle, syncKimiSessionTitle } from "../session-title.js";
 export { describeMissingResult } from "../background-spawn.js";
 // v1.0 cutover note (PR 3):
@@ -41,6 +42,8 @@ const RESCUE_SUMMARY_MAX = 120;
 const RESCUE_AGENT_PROFILE_PLACEHOLDER = "<cli-client>";
 export async function runRescue(argv, context) {
     const parsed = parseRescueArgs(argv);
+    if (parsed.help)
+        return companionHelp(["task", "rescue", ...argv]);
     const paths = resolvePluginPaths(context.env);
     await ensurePluginPaths(paths);
     const repoIdentity = await resolveRepoIdentity(context.cwd);
@@ -68,10 +71,14 @@ export async function runRescue(argv, context) {
             model: parsed.model ?? null,
             thinking: parsed.thinking ?? null,
             background: parsed.background,
+            budget_ms: parsed.budgetMs ?? (sessionResolution.sourceJob?.operation_kind === "rescue" ? sessionResolution.sourceJob.budget_ms : null) ?? null,
+            budget_source: parsed.budgetMs !== undefined ? "explicit"
+                : sessionResolution.sourceJob?.operation_kind === "rescue" && sessionResolution.sourceJob.budget_ms !== null ? "inherited" : "default",
             pid: parsed.background ? null : process.pid,
             kimi_pid: null,
             status: "running",
             kimi_session_id: sessionResolution.kimiSessionId,
+            kimi_session_id_source: sessionResolution.sourceJob?.kimi_session_id_source ?? null,
             ...persistedExecutionPlanFields(executionPlan),
             agent_profile: RESCUE_AGENT_PROFILE_PLACEHOLDER,
             prompt_digest: digestPrompt(prompt),
@@ -93,6 +100,7 @@ export async function runRescue(argv, context) {
             await markJobFailed(store, paths, job, classified, rescueConfig.cancellation.failedSummary, { phase: "failed" });
             throw classified;
         }
+        warnInheritedBudget(job, context.stderr);
         if (parsed.background) {
             return startBackgroundJob(job, prompt, context, paths, {
                 workerKind: "rescue",
@@ -185,18 +193,17 @@ export async function executeRescueJob(jobId, prompt, context, options) {
             signal: handlers.signal,
             // SIGKILL escalation defaults to 1500ms inside cli-client —
             // matches v0.4's cancellation.ts behavior for the wire client.
-        }, KIMI_RESCUE_PROMPT_TIMEOUT_MS, "rescue.prompt");
+        }, job.budget_ms ?? KIMI_RESCUE_PROMPT_TIMEOUT_MS, "rescue.prompt");
         store.updateRunningJob(job.job_id, observedExecutionFields(result));
         if (handlers.cancelling) {
             throw new RuntimeError(cancel.errorCodes.cancelled, cancel.cancelMessages.afterPrompt, "rescue.runtime");
         }
         assertCliResultSuccess(result, "rescue.runtime");
         if (result.sessionId !== undefined &&
-            result.sessionId.length > 0 &&
-            result.sessionId !== job.kimi_session_id) {
+            result.sessionId.length > 0) {
             // length>0 guard: empty-string capture would poison the row. (Kimi
             // alpha.4 challenge finding #3.)
-            store.updateRunningJob(job.job_id, { kimi_session_id: result.sessionId });
+            store.updateRunningJob(job.job_id, { kimi_session_id_source: "announced", kimi_session_id: result.sessionId });
         }
         await syncKimiSessionTitle({
             promptText: prompt,
@@ -242,14 +249,17 @@ export async function executeRescueJob(jobId, prompt, context, options) {
         }) ?? job);
     }
     catch (error) {
+        const classified = classifyManagedCommandFailure(error, "rescue", job.job_id, {
+            preserveStage: true,
+            background: job.background,
+            budgetMs: job.budget_ms ?? KIMI_RESCUE_PROMPT_TIMEOUT_MS,
+        });
+        const partialOutput = await captureTimeoutPartialOutput(classified, store, job, context.env, handlers.signal);
         if (handlers.cancelling) {
             const cancelledError = new RuntimeError(cancel.errorCodes.cancelled, cancel.cancelMessages.default, "rescue.runtime", error instanceof Error ? { cause: error } : undefined);
             return await markJobCancelled(store, paths, job, cancel.cancelledSummary, cancelledError, { phase: "cancelled" });
         }
-        const classified = classifyManagedCommandFailure(error, "rescue", job.job_id, {
-            preserveStage: true,
-        });
-        return await markJobFailed(store, paths, job, classified, cancel.failedSummary, { phase: "failed" });
+        return await markJobFailed(store, paths, job, classified, cancel.failedSummary, { phase: "failed", partialOutput });
     }
     finally {
         handlers.dispose();

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

@@ -2,7 +2,7 @@ import { RuntimeError } from "../errors.js";
 import { resolveRepoIdentity } from "../git.js";
 import { sweepStaleJobs } from "../jobs.js";
 import { reconcileHistoricalJobProvenance } from "../kimi-engine.js";
-import { withJobStore } from "../job-store.js";
+import { renderBudgetSource, withJobStore } from "../job-store.js";
 import { ensurePluginPaths, resolvePluginPaths } from "../paths.js";
 import { parseJobLookupArgs } from "../parsing.js";
 import { readArtifact, renderTerminalJobArtifact } from "../render.js";
@@ -42,6 +42,12 @@ function renderResultEnvelope(job, artifactPath, body) {
         job_id: job.job_id,
         kind: job.command_type,
         status: job.status,
+        budget_ms: job.budget_ms,
+        budget_source: renderBudgetSource(job),
+        kimi_session_id_source: job.kimi_session_id_source,
+        kimi_session_id: job.kimi_session_id,
+        // True when a budget timeout preserved assistant prose in the artifact.
+        partial_output: job.status === "failed" && Number(job.error?.details?.partial_output_chars ?? 0) > 0,
         summary: job.summary,
         error: job.error,
         artifact_path: artifactPath,

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

@@ -153,6 +153,7 @@ async function executeReviewGate(payload, assistantMessage, context) {
             kimi_pid: null,
             status: "running",
             kimi_session_id: null,
+            budget_source: "default",
             ...persistedExecutionPlanFields(executionPlan),
             agent_profile: REVIEW_GATE_AGENT_PROFILE_PLACEHOLDER,
             prompt_digest: digestPrompt(prompt),
@@ -195,7 +196,7 @@ async function executeReviewGate(payload, assistantMessage, context) {
                 // can't synthesize empty strings today, but the guard locks the
                 // SQLite contract independent of upstream behavior).
                 activeStore.updateRunningJob(job.job_id, {
-                    kimi_session_id: result.sessionId,
+                    kimi_session_id_source: "announced", kimi_session_id: result.sessionId,
                 });
             }
             const finalText = reassembleProseFromRecords(result.records);

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

@@ -17,7 +17,7 @@ import { renderManagedJobOutput, writeArtifact } from "../render.js";
 import { RuntimeError } from "../errors.js";
 import { resolveRepoIdentity } from "../git.js";
 import { hookRefusalDetails, hookRefusalRetryProtocol, maybeWarnHookMissing, verifyHookInstalled, } from "../hooks/install.js";
-import { assertCliResultSuccess, reassembleProseFromRecords, warnIfSessionIdMissing } from "./cli-helpers.js";
+import { captureTimeoutPartialOutput, assertCliResultSuccess, reassembleProseFromRecords, warnIfSessionIdMissing } from "./cli-helpers.js";
 import { buildKimiSessionTitle, syncKimiSessionTitle } from "../session-title.js";
 // v1.0 cutover note (PR 2):
 //
@@ -81,6 +81,8 @@ export async function runReview(argv, context, commandType) {
         model: parsed.model ?? null,
         thinking: parsed.thinking ?? null,
         background: false,
+        budget_ms: parsed.budgetMs ?? null,
+        budget_source: parsed.budgetMs !== undefined ? "explicit" : "default",
         pid: process.pid,
         kimi_pid: null,
         status: "running",
@@ -113,7 +115,7 @@ export async function runReview(argv, context, commandType) {
             model: parsed.model,
             logPath,
             signal: handlers.signal,
-        }, KIMI_REVIEW_PROMPT_TIMEOUT_MS, `${commandType}.prompt`);
+        }, job.budget_ms ?? KIMI_REVIEW_PROMPT_TIMEOUT_MS, `${commandType}.prompt`);
         store.updateRunningJob(job.job_id, observedExecutionFields(result));
         if (handlers.cancelling) {
             throw new RuntimeError(cancel.errorCodes.cancelled, cancel.cancelMessages.afterPrompt, `${commandType}.runtime`);
@@ -127,7 +129,7 @@ export async function runReview(argv, context, commandType) {
             // poison the row — consumers reading SQLite distinguish "missing"
             // (NULL) from "captured" (non-empty UUID) only via NULL-ness.
             // (Kimi alpha.4 challenge finding #3.)
-            store.updateRunningJob(job.job_id, { kimi_session_id: result.sessionId });
+            store.updateRunningJob(job.job_id, { kimi_session_id_source: "announced", kimi_session_id: result.sessionId });
         }
         await syncKimiSessionTitle({
             promptText: previewPrompt,
@@ -158,13 +160,14 @@ export async function runReview(argv, context, commandType) {
         return rendered.output;
     }
     catch (error) {
+        const classified = classifyManagedCommandFailure(error, commandType, job.job_id, { background: job.background, budgetMs: job.budget_ms ?? KIMI_REVIEW_PROMPT_TIMEOUT_MS });
+        const partialOutput = await captureTimeoutPartialOutput(classified, store, job, context.env, handlers.signal);
         if (handlers.cancelling) {
             const cancelledError = new RuntimeError(cancel.errorCodes.cancelled, cancel.cancelMessages.default, `${commandType}.runtime`, error instanceof Error ? { cause: error } : undefined);
             await markJobCancelled(store, paths, job, cancel.cancelledSummary, cancelledError);
             throw cancelledError;
         }
-        const classified = classifyManagedCommandFailure(error, commandType, job.job_id);
-        await markJobFailed(store, paths, job, classified, cancel.failedSummary);
+        await markJobFailed(store, paths, job, classified, cancel.failedSummary, { partialOutput });
         throw classified;
     }
     finally {

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

@@ -1,3 +1,4 @@
+import { SETUP_SUPPORTED_FLAGS } from "../parsing.js";
 // Managed-block installer for the kimi-code PreToolUse hook.
 //
 // Replaces the v0.4 Wire-based setup probe. In v1.0 the load-bearing
@@ -127,7 +128,7 @@ function parseArgs(argv) {
                 disableReviewGate = true;
                 break;
             default:
-                throw new RuntimeError("INVALID_ARGS", `Unknown setup flag ${token}. Supported flags: --check, --uninstall, --all (with --uninstall), --enable-review-gate, --disable-review-gate.`, "setup.parse");
+                throw new RuntimeError("INVALID_ARGS", `Unknown setup flag ${token}. Supported flags: ${SETUP_SUPPORTED_FLAGS}.`, "setup.parse");
         }
     }
     if (enableReviewGate && disableReviewGate) {

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

@@ -2,7 +2,7 @@ import { RuntimeError } from "../errors.js";
 import { resolveRepoIdentity } from "../git.js";
 import { sweepStaleJobs } from "../jobs.js";
 import { reconcileHistoricalJobProvenance } from "../kimi-engine.js";
-import { withJobStore } from "../job-store.js";
+import { renderBudgetSource, withJobStore } from "../job-store.js";
 import { ensurePluginPaths, resolvePluginPaths } from "../paths.js";
 import { parseJobLookupArgs } from "../parsing.js";
 export async function runStatus(argv, context) {
@@ -22,6 +22,6 @@ export async function runStatus(argv, context) {
             throw new RuntimeError("JOB_NOT_FOUND", "No matching job was found for status.", "status.lookup");
         }
         const job = await reconcileHistoricalJobProvenance(store, found);
-        return `${JSON.stringify(job, null, 2)}\n`;
+        return `${JSON.stringify({ ...job, budget_source: renderBudgetSource(job) }, null, 2)}\n`;
     });
 }

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

@@ -210,6 +210,8 @@ async function runReadSwarm(parsed, objective, context) {
             model: parsed.model ?? null,
             thinking: parsed.thinking ?? null,
             background: false,
+            budget_ms: parsed.budgetMs ?? KIMI_SWARM_DEFAULT_BUDGET_MS,
+            budget_source: parsed.budgetMs !== undefined ? "explicit" : "default",
             pid: process.pid,
             kimi_pid: null,
             status: "running",
@@ -235,7 +237,7 @@ async function runReadSwarm(parsed, objective, context) {
             await markJobFailed(store, paths, job, classified, "Swarm failed.", { phase: "failed" });
             throw classified;
         }
-        const completed = await executeSwarmJob(job.job_id, prompt, objective, parsed.budgetMs ?? KIMI_SWARM_DEFAULT_BUDGET_MS, resolveSwarmMaxConcurrency(parsed.maxConcurrency), context);
+        const completed = await executeSwarmJob(job.job_id, prompt, objective, job.budget_ms, resolveSwarmMaxConcurrency(parsed.maxConcurrency), context);
         if (!completed.final_output_path) {
             throw new RuntimeError("SWARM_RESULT_MISSING", "Swarm finished without a rendered result.", "swarm.result");
         }
@@ -308,6 +310,8 @@ async function runWriteSwarm(parsed, objective, context) {
                 model: parsed.model ?? null,
                 thinking: parsed.thinking ?? null,
                 background: false,
+                budget_ms: parsed.budgetMs ?? KIMI_SWARM_DEFAULT_BUDGET_MS,
+                budget_source: parsed.budgetMs !== undefined ? "explicit" : "default",
                 pid: process.pid,
                 kimi_pid: null,
                 status: "running",
@@ -335,7 +339,7 @@ async function runWriteSwarm(parsed, objective, context) {
                 });
                 throw classified;
             }
-            const completed = await executeSwarmJob(job.job_id, prompt, objective, parsed.budgetMs ?? KIMI_SWARM_DEFAULT_BUDGET_MS, resolveSwarmWriteMaxConcurrency(parsed.maxConcurrency), context, { spawnCwd: worktreePath, workspaceRoot: worktreePath });
+            const completed = await executeSwarmJob(job.job_id, prompt, objective, job.budget_ms, resolveSwarmWriteMaxConcurrency(parsed.maxConcurrency), context, { spawnCwd: worktreePath, workspaceRoot: worktreePath });
             if (!completed.final_output_path) {
                 throw new RuntimeError("SWARM_RESULT_MISSING", "Swarm (write) finished without a rendered result.", "swarm.result");
             }
@@ -500,7 +504,7 @@ writeMode) {
         if (result.sessionId !== undefined &&
             result.sessionId.length > 0 &&
             result.sessionId !== job.kimi_session_id) {
-            store.updateRunningJob(job.job_id, { kimi_session_id: result.sessionId });
+            store.updateRunningJob(job.job_id, { kimi_session_id_source: "announced", kimi_session_id: result.sessionId });
         }
         await syncKimiSessionTitle({
             promptText: objective,

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

@@ -1,3 +1,4 @@
+import { companionHelp } from "./help.js";
 import { runAsk } from "./commands/ask.js";
 import { runModelInventory } from "./commands/models.js";
 import { runCancel } from "./commands/cancel.js";
@@ -15,6 +16,11 @@ import { runWorker } from "./commands/worker.js";
 import { formatError, RuntimeError } from "./errors.js";
 import { resolveKimiHome } from "./kimi-home.js";
 async function main(argv) {
+    const help = companionHelp(argv);
+    if (help !== undefined) {
+        process.stdout.write(`${help}\n`);
+        return;
+    }
     const [command, ...rest] = argv;
     const cwd = process.env.KIMI_PLUGIN_CC_WORKSPACE_CWD || process.cwd();
     const context = {