kimi-plugin-cc 2.0.8 → 2.2.1

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

@@ -19,6 +19,7 @@
 import { spawn } from "node:child_process";
 import { appendFile, mkdir } from "node:fs/promises";
 import path from "node:path";
+import { createHookEscapeMonitor } from "./hook-escape.js";
 import { RuntimeError, formatError } from "./errors.js";
 import { assertNoUnsafeExperimentalSelector, assertExecutionPlanMatchesSpawn, } from "./kimi-engine.js";
 import { assertPrefixArgsSafe } from "./kimi-command.js";
@@ -84,7 +85,9 @@ export async function runCliPrompt(opts) {
         });
     }
     let child;
+    let spawnedAt;
     try {
+        spawnedAt = Date.now();
         child = spawn(opts.command, args, {
             cwd: opts.cwd,
             env,
@@ -124,6 +127,14 @@ export async function runCliPrompt(opts) {
     let announcedSessionId;
     let announcedGoalSummary;
     let announcedSystemVersion;
+    const hookMonitor = createHookEscapeMonitor({ commandLabel: opts.commandLabel,
+        operationKind: opts.executionPlan.operationKind, trustedWorkspaceRoot: opts.trustedWorkspaceRoot, cwd: opts.cwd });
+    const hookEscapes = [];
+    const noteHookEscape = (escape) => {
+        hookEscapes.push(escape);
+        appendLogLine({ event: "hook_escape", ...escape, command_label: opts.commandLabel,
+            operation_kind: opts.executionPlan.operationKind });
+    };
     let engineMismatchDetected = false;
     let handleEngineMismatch;
     const plannedEngine = opts.executionPlan.intendedEngine;
@@ -281,6 +292,9 @@ export async function runCliPrompt(opts) {
                 }
                 if (requireMarkerBeforeOutput(`a ${outcome.record.role} record`))
                     return;
+                const escape = hookMonitor.observe(outcome.record);
+                if (escape)
+                    noteHookEscape(escape);
                 records.push(outcome.record);
                 appendLogLine({ event: "record", record: outcome.record });
                 invokeOnRecord(outcome.record);
@@ -312,6 +326,13 @@ export async function runCliPrompt(opts) {
         const settle = (kind, payload) => {
             if (settlementStarted)
                 return;
+            // Denied calls still without a result (a cancel/budget race, an abnormal
+            // exit, or a turn that ended without the denial the hook owes) are reported
+            // alongside the real outcome, never instead of it.
+            for (const escape of hookMonitor.settle())
+                noteHookEscape(escape);
+            if (kind === "resolve" && hookEscapes.length > 0)
+                payload = { ...payload, hookEscapes: [...hookEscapes] };
             settlementStarted = true;
             opts.signal?.removeEventListener("abort", onAbort);
             // Abort teardown can outlive the direct child's close event while a
@@ -329,7 +350,7 @@ export async function runCliPrompt(opts) {
                     return;
                 }
                 if (kind === "resolve")
-                    resolve(payload);
+                    resolve({ ...payload, settledAt: Date.now() });
                 else
                     reject(payload);
             });
@@ -470,6 +491,11 @@ export async function runCliPrompt(opts) {
                 }
             }
         };
+        const stopForPolicyFailure = (error) => {
+            engineMismatchDetected = true; // Stops all further consumer output.
+            cancellationTeardown ??= teardownChildTree().then(() => ({ ok: true }), (error) => ({ ok: false, error }));
+            settle("reject", error);
+        };
         let engineMismatchError;
         handleEngineMismatch = (mismatch) => {
             if (engineMismatchError !== undefined)
@@ -491,8 +517,7 @@ export async function runCliPrompt(opts) {
                 system_version: mismatch.systemVersion ?? null,
                 reason: mismatch.reason,
             });
-            cancellationTeardown = teardownChildTree().then(() => ({ ok: true }), (error) => ({ ok: false, error }));
-            settle("reject", engineMismatchError);
+            stopForPolicyFailure(engineMismatchError);
         };
         const onAbort = () => {
             if (aborted)
@@ -580,6 +605,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,7 +683,9 @@ export function requireSessionId(result, context) {
         },
     });
 }
-/** Settled timeout data; stream records are deliberately non-serializable. */
+/** 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, {
@@ -666,8 +695,9 @@ export class ResponseTimeoutError extends RuntimeError {
                 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: true,
+                aborted: partialResult?.aborted ?? true,
                 ...(partialResult ? { settled_post_abort: true } : {}),
+                ...(partialResult?.hookEscapes?.length ? { hook_escapes: partialResult.hookEscapes } : {}),
             },
         });
         this.name = "ResponseTimeoutError";
@@ -772,11 +802,11 @@ function buildArgs(opts) {
             args.push("--skills-dir", dir);
         }
     }
-    // NOTE: `opts.thinking === false` is intentionally NOT translated into a
-    // `--no-thinking` argv flag. kimi-code 0.1.1 rejects unknown options and
-    // has no per-spawn thinking control — the Round 2 multi-agent review
-    // caught this. The option stays in CliClientOptions for future wiring
-    // when upstream adds the flag (see field doc).
+    // NOTE: thinking effort is requested through the env binding, never CLI argv.
+    // Non-trait-driven providers or a base level already off ignore it silently;
+    // an alwaysThinking model receives off unnormalized. stream-json carries no
+    // thinking deltas (writeThinkingDelta() {} in the JSON writer), so the plugin
+    // cannot observe whether the request was honoured.
     // -p accepts the prompt as the option value. We pass it as a separate argv
     // entry so prompts with leading dashes or whitespace are not interpreted as
     // additional flags.
@@ -785,6 +815,8 @@ function buildArgs(opts) {
 }
 function buildEnv(opts) {
     const env = { ...opts.env };
+    if (opts.thinkingEffort !== undefined)
+        env.KIMI_MODEL_THINKING_EFFORT = opts.thinkingEffort;
     // 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`

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

@@ -17,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 { captureTimeoutPartialOutput, assertCliResultSuccess, reassembleProseFromRecords, warnIfSessionIdMissing } from "./cli-helpers.js";
+import { warnInheritedBudget, captureTimeoutPartialOutput, assertCliResultSuccess, reassembleProseFromRecords, warnIfSessionIdMissing, warnHookEscapes } from "./cli-helpers.js";
 import { buildKimiSessionTitle, syncKimiSessionTitle } from "../session-title.js";
 // v1.0 cutover note (PR 2):
 //
@@ -77,13 +77,17 @@ export async function runAsk(argv, context) {
             command_type: "ask",
             cwd: context.cwd,
             model: parsed.model ?? null,
-            thinking: parsed.thinking ?? null,
+            thinking: null,
+            thinking_effort: parsed.thinkingEffort ?? 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),
@@ -105,6 +109,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",
@@ -170,6 +175,7 @@ export async function executeAskJob(jobId, prompt, context, options) {
             prompt,
             commandLabel: "ask",
             model: job.model ?? undefined,
+            thinkingEffort: job.thinking_effort ?? undefined,
             resumeSessionId: job.kimi_session_id ?? undefined,
             logPath: job.stream_log_path,
             signal: handlers.signal,
@@ -179,17 +185,17 @@ export async function executeAskJob(jobId, prompt, context, options) {
             throw new RuntimeError(cancel.errorCodes.cancelled, cancel.cancelMessages.afterPrompt, "ask.runtime");
         }
         assertCliResultSuccess(result, "ask.runtime");
+        warnHookEscapes(result, "ask", context.stderr);
         // Persist whichever session id kimi actually announced. For fresh
         // sessions this is the only chance to record it. For resumed
         // 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,
@@ -219,6 +225,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" });
@@ -231,8 +240,6 @@ 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, { background: job.background, budgetMs: job.budget_ms ?? KIMI_ASK_PROMPT_TIMEOUT_MS });
-        const partialOutput = captureTimeoutPartialOutput(classified, store, job);
         await markJobFailed(store, paths, job, classified, cancel.failedSummary, { phase: "failed", partialOutput });
         throw classified;
     }

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

@@ -1,6 +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.
  *
@@ -112,12 +115,42 @@ export function assertCliResultSuccess(result, stage) {
         });
     }
 }
-/** Timeout-only capture, called after cancellation has taken precedence. No title sync on failure. */
-export function captureTimeoutPartialOutput(classified, store, job) {
+/** 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
@@ -125,11 +158,22 @@ export function captureTimeoutPartialOutput(classified, store, job) {
     // than the metadata, so swallow and fall through.
     try {
         store.updateRunningJob(job.job_id, observedExecutionFields(result));
-        if (result.sessionId !== undefined && result.sessionId.length > 0 && result.sessionId !== job.kimi_session_id) {
-            store.updateRunningJob(job.job_id, { kimi_session_id: result.sessionId });
+        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 {
@@ -141,3 +185,21 @@ export function captureTimeoutPartialOutput(classified, store, job) {
         budgetMs: timeout.details.budget_ms,
     };
 }
+/** One-line human summary of hook-escape findings, or undefined when none. */
+export function describeHookEscapes(result) {
+    const escapes = result.hookEscapes ?? [];
+    if (escapes.length === 0)
+        return undefined;
+    const first = escapes[0];
+    return `safety hook notice: ${escapes.length} policy-denied tool call(s) did not come back as the managed hook's denial (first: ${first.tool_name} ${first.kind}). Detection evidence only — the call may have been rejected upstream before the hook ran, blocked by another hook, or executed because the hook drifted. Run /kimi:setup --check; details in \`result <jobId> --json\` (hook_escapes).`;
+}
+export function warnHookEscapes(result, commandType, stderr) {
+    const note = describeHookEscapes(result);
+    if (note !== undefined)
+        stderr.write(`[${commandType}] ${note}\n`);
+}
+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

@@ -14,7 +14,7 @@ import { ensurePluginPaths, resolvePluginPaths } from "../paths.js";
 import { parsePursueArgs } from "../parsing.js";
 import { readArtifact, renderManagedJobOutput, writeArtifact } from "../render.js";
 import { hookRefusalDetails, hookRefusalRetryProtocol, maybeWarnHookMissing, verifyHookInstalled, } from "../hooks/install.js";
-import { assertCliResultSuccess, reassembleProseFromRecords, warnIfSessionIdMissing } from "./cli-helpers.js";
+import { assertCliResultSuccess, reassembleProseFromRecords, warnIfSessionIdMissing, warnHookEscapes } from "./cli-helpers.js";
 import { buildKimiSessionTitle, syncKimiSessionTitle } from "../session-title.js";
 // /kimi:pursue — autonomous goal mode (kimi-code 0.8.0+ headless `/goal`).
 //
@@ -141,9 +141,11 @@ export async function runPursue(argv, context) {
             command_type: "rescue",
             cwd: context.cwd,
             model: parsed.model ?? null,
-            thinking: parsed.thinking ?? null,
+            thinking: null,
+            thinking_effort: parsed.thinkingEffort ?? 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",
@@ -232,10 +234,12 @@ async function executePursueJob(jobId, prompt, objective, budgetMs, context) {
             commandLabel: "rescue",
             trustedWorkspaceRoot: job.cwd,
             model: job.model ?? undefined,
+            thinkingEffort: job.thinking_effort ?? undefined,
             logPath: job.stream_log_path,
             signal: handlers.signal,
         }, budgetMs, "pursue.prompt");
         store.updateRunningJob(job.job_id, observedExecutionFields(result));
+        warnHookEscapes(result, "pursue", context.stderr);
         if (handlers.cancelling) {
             throw new RuntimeError("PURSUE_CANCELLED", "Pursue cancelled by user request.", "pursue.runtime");
         }
@@ -250,7 +254,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/rescue.js

@@ -17,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 { captureTimeoutPartialOutput, assertCliResultSuccess, reassembleProseFromRecords, warnIfSessionIdMissing } from "./cli-helpers.js";
+import { warnInheritedBudget, captureTimeoutPartialOutput, assertCliResultSuccess, reassembleProseFromRecords, warnIfSessionIdMissing, warnHookEscapes } from "./cli-helpers.js";
 import { buildKimiSessionTitle, syncKimiSessionTitle } from "../session-title.js";
 export { describeMissingResult } from "../background-spawn.js";
 // v1.0 cutover note (PR 3):
@@ -69,13 +69,17 @@ export async function runRescue(argv, context) {
             command_type: "rescue",
             cwd: context.cwd,
             model: parsed.model ?? null,
-            thinking: parsed.thinking ?? null,
+            thinking: null,
+            thinking_effort: parsed.thinkingEffort ?? 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),
@@ -97,6 +101,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",
@@ -184,6 +189,7 @@ export async function executeRescueJob(jobId, prompt, context, options) {
             commandLabel: "rescue",
             trustedWorkspaceRoot: job.cwd,
             model: job.model ?? undefined,
+            thinkingEffort: job.thinking_effort ?? undefined,
             resumeSessionId: job.kimi_session_id ?? undefined,
             logPath: job.stream_log_path,
             signal: handlers.signal,
@@ -195,12 +201,12 @@ export async function executeRescueJob(jobId, prompt, context, options) {
             throw new RuntimeError(cancel.errorCodes.cancelled, cancel.cancelMessages.afterPrompt, "rescue.runtime");
         }
         assertCliResultSuccess(result, "rescue.runtime");
+        warnHookEscapes(result, "rescue", context.stderr);
         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,
@@ -246,16 +252,16 @@ export async function executeRescueJob(jobId, prompt, context, options) {
         }) ?? job);
     }
     catch (error) {
-        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,
             background: job.background,
             budgetMs: job.budget_ms ?? KIMI_RESCUE_PROMPT_TIMEOUT_MS,
         });
-        const partialOutput = captureTimeoutPartialOutput(classified, store, job);
+        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" });
+        }
         return await markJobFailed(store, paths, job, classified, cancel.failedSummary, { phase: "failed", partialOutput });
     }
     finally {

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, parseHookEscapes } from "../job-store.js";
 import { ensurePluginPaths, resolvePluginPaths } from "../paths.js";
 import { parseJobLookupArgs } from "../parsing.js";
 import { readArtifact, renderTerminalJobArtifact } from "../render.js";
@@ -43,6 +43,10 @@ function renderResultEnvelope(job, artifactPath, body) {
         kind: job.command_type,
         status: job.status,
         budget_ms: job.budget_ms,
+        budget_source: renderBudgetSource(job),
+        thinking_effort_requested: job.thinking_effort ?? null,
+        hook_escapes: parseHookEscapes(job.hook_escapes),
+        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,

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

@@ -15,9 +15,10 @@ import { KIMI_REVIEW_GATE_TIMEOUT_MS, isTimeoutCode } from "../kimi-timeouts.js"
 import { writeInvocationLogHeader } from "../logging.js";
 import { ensurePluginPaths, resolvePluginPaths } from "../paths.js";
 import { renderManagedJobOutput, writeArtifact, } from "../render.js";
+import { validateThinkingEffort } from "../parsing.js";
 import { maybeWarnHookMissing, verifyHookInstalled } from "../hooks/install.js";
 import { resolveKimiHome } from "../kimi-home.js";
-import { assertCliResultSuccess, reassembleProseFromRecords } from "./cli-helpers.js";
+import { assertCliResultSuccess, describeHookEscapes, reassembleProseFromRecords } from "./cli-helpers.js";
 const REVIEW_GATE_AGENT_PROFILE_PLACEHOLDER = "<cli-client>";
 // v1.0 cutover note (PR 2):
 //
@@ -82,18 +83,19 @@ export async function runReviewGateStopHook(payload, context) {
             ...payload,
             cwd,
         }, assistantMessage, context);
+        const note = output.hookEscapeNote !== undefined ? `Kimi review gate ${output.hookEscapeNote}` : undefined;
         if (output.decision === "BLOCK" && output.confidence === "high") {
             return {
                 decision: "block",
                 reason: buildBlockReason(output),
+                ...(note !== undefined ? { systemMessage: note } : {}),
             };
         }
         if (output.decision === "BLOCK") {
-            return {
-                systemMessage: `Kimi review gate noted concerns but allowed stop: ${output.summary}`,
-            };
+            const concern = `Kimi review gate noted concerns but allowed stop: ${output.summary}`;
+            return { systemMessage: note !== undefined ? `${concern}\n${note}` : concern };
         }
-        return {};
+        return note !== undefined ? { systemMessage: note } : {};
     }
     catch (error) {
         return {
@@ -105,6 +107,7 @@ function reviewGateSkipped(reason) {
     return { systemMessage: `review-gate skipped: ${reason}` };
 }
 async function executeReviewGate(payload, assistantMessage, context) {
+    let hookEscapeNote;
     const paths = resolvePluginPaths(context.env);
     await ensurePluginPaths(paths);
     const repoIdentity = await resolveRepoIdentity(payload.cwd);
@@ -121,6 +124,10 @@ async function executeReviewGate(payload, assistantMessage, context) {
             cwd: payload.cwd,
             repoRoot: repoIdentity.repoRoot,
         });
+        // Unset or empty → request "off" (the 8 s budget is why); "inherit" → export
+        // nothing; anything else is lowercased and syntax-checked like --thinking.
+        const gateThinking = context.env.KIMI_PLUGIN_CC_REVIEW_GATE_THINKING?.trim() || "off";
+        const thinkingEffort = gateThinking.toLowerCase() === "inherit" ? undefined : validateThinkingEffort(gateThinking, "review_gate.parse");
         const configuredModel = context.env.KIMI_PLUGIN_CC_REVIEW_GATE_MODEL;
         const model = configuredModel?.trim() ? configuredModel : undefined;
         const executionPlan = await prepareKimiExecutionPlan({
@@ -148,11 +155,13 @@ async function executeReviewGate(payload, assistantMessage, context) {
             cwd: payload.cwd,
             model: model ?? null,
             thinking: false,
+            thinking_effort: thinkingEffort ?? null,
             background: false,
             pid: null,
             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),
@@ -177,17 +186,15 @@ async function executeReviewGate(payload, assistantMessage, context) {
                 prompt,
                 commandLabel: "review_gate",
                 model,
-                // Intent: thinking-off so the 8s Stop-hook budget is achievable.
-                // Mechanism: currently advisory — kimi-code 0.1.1 has no CLI
-                // flag for this; control is config-based (default_thinking /
-                // [thinking].mode). The field carries intent through the
-                // contract; when upstream adds a per-spawn flag, buildArgs will
-                // translate it. (Round 2 Codex finding.)
-                thinking: false,
+                // Requested via env; provider/model may ignore it. The 8s budget still applies.
+                thinkingEffort,
                 logPath,
             }, KIMI_REVIEW_GATE_TIMEOUT_MS, "review_gate.runtime");
             activeStore.updateRunningJob(job.job_id, observedExecutionFields(result));
             assertCliResultSuccess(result, "review_gate.runtime");
+            // Detection evidence only (runtime/hook-escape.ts): the gate stays fail-open
+            // and annotates its decision; the finding is also on the job row.
+            hookEscapeNote = describeHookEscapes(result);
             if (result.sessionId !== undefined && result.sessionId.length > 0) {
                 // length>0 guard matches the other commands (Kimi alpha.4
                 // challenge finding #3 — defense-in-depth, since
@@ -195,7 +202,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);
@@ -216,7 +223,7 @@ async function executeReviewGate(payload, assistantMessage, context) {
                 final_output_path: artifactPath,
                 error: null,
             });
-            return rendered.output;
+            return { ...rendered.output, hookEscapeNote };
         }
         catch (error) {
             const classified = classifyManagedCommandFailure(error, "review_gate", job.job_id);

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 { captureTimeoutPartialOutput, assertCliResultSuccess, reassembleProseFromRecords, warnIfSessionIdMissing } from "./cli-helpers.js";
+import { captureTimeoutPartialOutput, assertCliResultSuccess, reassembleProseFromRecords, warnIfSessionIdMissing, warnHookEscapes } from "./cli-helpers.js";
 import { buildKimiSessionTitle, syncKimiSessionTitle } from "../session-title.js";
 // v1.0 cutover note (PR 2):
 //
@@ -79,9 +79,11 @@ export async function runReview(argv, context, commandType) {
         command_type: commandType,
         cwd: context.cwd,
         model: parsed.model ?? null,
-        thinking: parsed.thinking ?? null,
+        thinking: null,
+        thinking_effort: parsed.thinkingEffort ?? null,
         background: false,
         budget_ms: parsed.budgetMs ?? null,
+        budget_source: parsed.budgetMs !== undefined ? "explicit" : "default",
         pid: process.pid,
         kimi_pid: null,
         status: "running",
@@ -112,6 +114,7 @@ export async function runReview(argv, context, commandType) {
             prompt: previewPrompt,
             commandLabel: commandType,
             model: parsed.model,
+            thinkingEffort: parsed.thinkingEffort,
             logPath,
             signal: handlers.signal,
         }, job.budget_ms ?? KIMI_REVIEW_PROMPT_TIMEOUT_MS, `${commandType}.prompt`);
@@ -120,6 +123,7 @@ export async function runReview(argv, context, commandType) {
             throw new RuntimeError(cancel.errorCodes.cancelled, cancel.cancelMessages.afterPrompt, `${commandType}.runtime`);
         }
         assertCliResultSuccess(result, `${commandType}.runtime`);
+        warnHookEscapes(result, commandType, context.stderr);
         // Persist whichever session id kimi announced. Review never resumes,
         // but the id is the only handle for post-hoc replay against
         // ~/.kimi-code/sessions/.
@@ -128,7 +132,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,
@@ -159,13 +163,13 @@ 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, { background: job.background, budgetMs: job.budget_ms ?? KIMI_REVIEW_PROMPT_TIMEOUT_MS });
-        const partialOutput = captureTimeoutPartialOutput(classified, store, job);
         await markJobFailed(store, paths, job, classified, cancel.failedSummary, { partialOutput });
         throw classified;
     }