kimi-plugin-cc 2.0.7

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

@@ -0,0 +1,393 @@
+import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { runCliPromptWithBudget } from "../cli-client.js";
+import { observedExecutionFields, persistedExecutionPlanFields, prepareKimiExecutionPlan, } from "../kimi-engine.js";
+import { readPluginConfig } from "../config.js";
+import { getManagedCommandConfig } from "./registry.js";
+import { RuntimeError, formatError } from "../errors.js";
+import { resolveRepoIdentity } from "../git.js";
+import { digestPrompt, markJobFailed } from "../jobs.js";
+import { JobStore } from "../job-store.js";
+import { classifyManagedCommandFailure, summarizeKimiAvailabilityWarning } from "../kimi-errors.js";
+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 { maybeWarnHookMissing, verifyHookInstalled } from "../hooks/install.js";
+import { resolveKimiHome } from "../kimi-home.js";
+import { assertCliResultSuccess, reassembleProseFromRecords } from "./cli-helpers.js";
+const REVIEW_GATE_AGENT_PROFILE_PLACEHOLDER = "<cli-client>";
+// v1.0 cutover note (PR 2):
+//
+//   review_gate is the only command that still parses Kimi's stdout
+//   (JSON allow/block decision). The transport switched from
+//   `kimi --wire` to `kimi -p --output-format stream-json`; the parser
+//   stayed.
+//
+//   No cancellation handler — the 8s timeout is the only governor.
+//   review_gate is invoked from Claude Code's Stop hook and runs
+//   strictly foreground-synchronous.
+export async function runReviewGateStopHook(payload, context) {
+    if (payload.hook_event_name !== "Stop") {
+        throw new RuntimeError("INVALID_HOOK_EVENT", `review gate hook expected Stop input, received ${payload.hook_event_name}.`, "review_gate.hook");
+    }
+    let paths;
+    try {
+        paths = resolvePluginPaths(context.env);
+    }
+    catch (error) {
+        if (error instanceof RuntimeError && ["PLUGIN_DATA_CONFLICT", "INVALID_PLUGIN_DATA", "MISSING_PLUGIN_DATA"].includes(error.code)) {
+            return reviewGateSkipped(formatError(error));
+        }
+        throw error;
+    }
+    await ensurePluginPaths(paths);
+    const config = await readPluginConfig(paths);
+    if (!config.reviewGateEnabled) {
+        return reviewGateSkipped("disabled");
+    }
+    if (payload.stop_hook_active) {
+        return reviewGateSkipped("stop hook already active");
+    }
+    const cwd = payload.cwd || context.cwd;
+    // Resolve KIMI_CODE_HOME ONCE, against the SAME cwd the child will be
+    // spawned with, and use that env for hook verification, the execution plan
+    // and the spawn. The Stop-hook entry script runs from the plugin root, so a
+    // relative KIMI_CODE_HOME would otherwise be verified under the plugin root
+    // while the child (cwd = payload.cwd) read a different home.
+    context = {
+        ...context,
+        env: { ...context.env, KIMI_CODE_HOME: resolveKimiHome(context.env, cwd) },
+    };
+    const assistantMessage = extractText(payload.last_assistant_message) ??
+        (await extractLastAssistantMessage(payload.transcript_path));
+    if (!assistantMessage) {
+        return reviewGateSkipped("no assistant message");
+    }
+    if (context.env.KIMI_PLUGIN_CC_SKIP_HOOK_CHECK !== "1") {
+        const installStatus = await verifyHookInstalled(context.env);
+        if (!installStatus.installed) {
+            maybeWarnHookMissing(installStatus, "review_gate", context.stderr);
+            return reviewGateSkipped([
+                "canonical PreToolUse hook is missing or invalid",
+                `(${installStatus.reason ?? "unknown"})`,
+                "allowing stop without invoking Kimi",
+            ].join(" "));
+        }
+    }
+    try {
+        const output = await executeReviewGate({
+            ...payload,
+            cwd,
+        }, assistantMessage, context);
+        if (output.decision === "BLOCK" && output.confidence === "high") {
+            return {
+                decision: "block",
+                reason: buildBlockReason(output),
+            };
+        }
+        if (output.decision === "BLOCK") {
+            return {
+                systemMessage: `Kimi review gate noted concerns but allowed stop: ${output.summary}`,
+            };
+        }
+        return {};
+    }
+    catch (error) {
+        return {
+            systemMessage: buildWarningMessage(error),
+        };
+    }
+}
+function reviewGateSkipped(reason) {
+    return { systemMessage: `review-gate skipped: ${reason}` };
+}
+async function executeReviewGate(payload, assistantMessage, context) {
+    const paths = resolvePluginPaths(context.env);
+    await ensurePluginPaths(paths);
+    const repoIdentity = await resolveRepoIdentity(payload.cwd);
+    let store;
+    try {
+        store = new JobStore(paths);
+        const userRequest = extractText(payload.last_user_message ?? payload.user_request ?? payload.prompt) ??
+            (await extractLastUserMessage(payload.transcript_path));
+        const jobId = randomUUID();
+        const logPath = path.join(paths.logsDir, `review-gate-${jobId}.jsonl`);
+        const prompt = buildReviewGatePrompt({
+            assistantMessage,
+            userRequest,
+            cwd: payload.cwd,
+            repoRoot: repoIdentity.repoRoot,
+        });
+        const configuredModel = context.env.KIMI_PLUGIN_CC_REVIEW_GATE_MODEL;
+        const model = configuredModel?.trim() ? configuredModel : undefined;
+        const executionPlan = await prepareKimiExecutionPlan({
+            operationKind: "review_gate",
+            cwd: payload.cwd,
+            env: context.env,
+        });
+        // Header-before-job-row mirrors v0.4's reordering (the comment
+        // chain there explains why). If the disk-bound writeInvocationLogHeader
+        // throws (full disk, permission), we'd otherwise leave an orphan
+        // running row with pid=null,kimi_pid=null that the sweeper can't
+        // see. Keep the header first.
+        await writeInvocationLogHeader(logPath, {
+            commandType: "review_gate",
+            // kimi-code assigns the session id; we don't know it until the
+            // call returns. The header carries a "(pending)" placeholder so
+            // post-mortem log diffing still finds the right row.
+            kimiSessionId: "(pending)",
+            cwd: payload.cwd,
+        });
+        const job = store.createJob({
+            job_id: jobId,
+            repo_id: repoIdentity.repoId,
+            command_type: "review_gate",
+            cwd: payload.cwd,
+            model: model ?? null,
+            thinking: false,
+            background: false,
+            pid: null,
+            kimi_pid: null,
+            status: "running",
+            kimi_session_id: null,
+            ...persistedExecutionPlanFields(executionPlan),
+            agent_profile: REVIEW_GATE_AGENT_PROFILE_PLACEHOLDER,
+            prompt_digest: digestPrompt(prompt),
+            summary: "Running review gate.",
+            final_output_path: null,
+            stream_log_path: logPath,
+            error: null,
+        });
+        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.
+            const result = await runCliPromptWithBudget({
+                cwd: payload.cwd,
+                env: context.env,
+                command: executionPlan.command,
+                prefixArgs: [...executionPlan.prefixArgs],
+                executionPlan,
+                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,
+                logPath,
+            }, KIMI_REVIEW_GATE_TIMEOUT_MS, "review_gate.runtime");
+            activeStore.updateRunningJob(job.job_id, observedExecutionFields(result));
+            assertCliResultSuccess(result, "review_gate.runtime");
+            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
+                // extractSessionIdFromStderr returns undefined on no-match and
+                // 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,
+                });
+            }
+            const finalText = reassembleProseFromRecords(result.records);
+            const rendered = renderManagedJobOutput(job, finalText);
+            // Cancel-vs-completed race: /kimi:cancel pre-marks the row as
+            // `cancelled` and SIGTERMs the worker. If kimi managed to return
+            // in the SIGTERM→exit window before our wire-equivalent picked
+            // up the close, we'd overwrite the cancellation artifact and
+            // confuse the hook's allow/block decision. Check the persisted
+            // status before committing the success path.
+            const persisted = activeStore.getJob(job.job_id);
+            if (persisted && persisted.status !== "running") {
+                throw new RuntimeError(getManagedCommandConfig("review_gate").cancellation.errorCodes.cancelled, "review_gate cancelled before completion artifact was written.", "review_gate.runtime");
+            }
+            const artifactPath = await writeArtifact(paths, job, rendered.rendered);
+            activeStore.markCompleted(job.job_id, {
+                summary: rendered.summary,
+                final_output_path: artifactPath,
+                error: null,
+            });
+            return rendered.output;
+        }
+        catch (error) {
+            const classified = classifyManagedCommandFailure(error, "review_gate", job.job_id);
+            const summary = isTimeoutError(classified) ? "Review gate timed out." : "Review gate failed.";
+            await markJobFailed(store, paths, job, classified, summary);
+            throw classified;
+        }
+    }
+    finally {
+        store?.close();
+    }
+}
+function buildReviewGatePrompt(input) {
+    return [
+        "Review the just-finished Claude response and decide whether Claude should be allowed to stop.",
+        "Block only for concrete, high-confidence problems that require an immediate corrective follow-up turn.",
+        "Do not block for style nits, optional improvements, or low-confidence concerns.",
+        "Return exactly one JSON object with no prose wrapper and no code fences.",
+        "",
+        "Required output schema:",
+        '{"decision":"ALLOW|BLOCK","confidence":"low|medium|high","summary":"string","issues":[{"title":"string","body":"string","severity":"low|medium|high"}]}',
+        "",
+        `Workspace cwd: ${input.cwd}`,
+        `Repository root: ${input.repoRoot}`,
+        "",
+        "User request:",
+        input.userRequest ?? "(unavailable from transcript)",
+        "",
+        "Claude response under review:",
+        input.assistantMessage,
+    ].join("\n");
+}
+function buildBlockReason(output) {
+    const issueLines = output.issues
+        .slice(0, 5)
+        .map((issue) => `- [${issue.severity}] ${issue.title}: ${issue.body}`);
+    return [
+        "Kimi review gate blocked stop. Revise the previous response before ending the turn.",
+        `Summary: ${output.summary}`,
+        ...(issueLines.length > 0 ? ["Issues:", ...issueLines] : []),
+    ].join("\n");
+}
+function isTimeoutError(error) {
+    if (!(error instanceof RuntimeError)) {
+        return false;
+    }
+    return (isTimeoutCode(error.code) ||
+        error.code === "REVIEW_GATE_KIMI_TIMEOUT" ||
+        error.code === "REVIEW_GATE_KIMI_STARTUP_TIMEOUT" ||
+        error.code === "REVIEW_GATE_KIMI_INITIALIZE_TIMEOUT" ||
+        error.code === "REVIEW_GATE_KIMI_RESPONSE_TIMEOUT");
+}
+function buildWarningMessage(error) {
+    if (isTimeoutError(error)) {
+        return "Kimi review gate timed out after 8s; allowing stop.";
+    }
+    if (error instanceof RuntimeError) {
+        if (error.code === "REVIEW_GATE_PARSE_FAILED" ||
+            error.code === "MISSING_TURN_END" ||
+            error.code === "TURN_INTERRUPTED") {
+            return "Kimi review gate returned malformed output; allowing stop.";
+        }
+        if (error.code === "MAX_STEPS_REACHED") {
+            return "Kimi review gate exhausted its step budget; allowing stop.";
+        }
+        // v0.4 codes from the deleted wire/* path. Kept here so a stale
+        // job row or in-flight test that still produces them maps to the
+        // same allowing-stop language. The v1.0 equivalents
+        // (CLI_NONZERO_EXIT, CLI_PROCESS_ERROR, CLI_ABORTED) get the same
+        // user-visible warning.
+        if (error.code === "WIRE_SPAWN_FAILED" ||
+            error.code === "WIRE_PROCESS_EXITED" ||
+            error.code === "WIRE_REQUEST_FAILED" ||
+            error.code === "CLI_SPAWN_FAILED" ||
+            error.code === "CLI_PROCESS_ERROR" ||
+            error.code === "CLI_NONZERO_EXIT" ||
+            error.code === "CLI_ABORTED" ||
+            error.code === "CLI_NO_SESSION_ID") {
+            return "Kimi review gate is unavailable in this environment; allowing stop.";
+        }
+    }
+    const warning = summarizeKimiAvailabilityWarning(error, "review_gate");
+    if (warning) {
+        return warning;
+    }
+    return "Kimi review gate failed unexpectedly; allowing stop.";
+}
+async function extractLastUserMessage(transcriptPath) {
+    return scanTranscriptForLastRoleText(transcriptPath, "user");
+}
+async function extractLastAssistantMessage(transcriptPath) {
+    return scanTranscriptForLastRoleText(transcriptPath, "assistant");
+}
+async function scanTranscriptForLastRoleText(transcriptPath, role) {
+    if (!transcriptPath) {
+        return null;
+    }
+    try {
+        const raw = await readFile(expandHomeDir(transcriptPath), "utf8");
+        let lastMatch = null;
+        for (const line of raw.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            let entry;
+            try {
+                entry = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            const extracted = extractRoleText(entry, role);
+            if (extracted) {
+                lastMatch = extracted;
+            }
+        }
+        return lastMatch;
+    }
+    catch {
+        return null;
+    }
+}
+function extractRoleText(entry, role) {
+    if (!isObject(entry)) {
+        return null;
+    }
+    if (role === "user" &&
+        entry.hook_event_name === "UserPromptSubmit" &&
+        typeof entry.prompt === "string") {
+        return entry.prompt.trim() || null;
+    }
+    if (entry.role === role) {
+        return extractText(entry.content ?? entry.message ?? entry.text ?? entry.prompt);
+    }
+    if (entry.type === role) {
+        return extractText(entry.content ?? entry.message ?? entry.text ?? entry.prompt);
+    }
+    if (isObject(entry.message) && entry.message.role === role) {
+        return extractText(entry.message.content ?? entry.message.text);
+    }
+    return null;
+}
+function extractText(value) {
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    if (Array.isArray(value)) {
+        const parts = value
+            .map((part) => extractText(part))
+            .filter((part) => Boolean(part));
+        return parts.length > 0 ? parts.join("\n") : null;
+    }
+    if (isObject(value)) {
+        if (value.type === "text" && typeof value.text === "string") {
+            return value.text.trim() || null;
+        }
+        return extractText(value.text ?? value.content ?? value.message);
+    }
+    return null;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function expandHomeDir(filePath) {
+    if (filePath === "~") {
+        return os.homedir();
+    }
+    if (filePath.startsWith("~/")) {
+        return path.join(os.homedir(), filePath.slice(2));
+    }
+    return filePath;
+}

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

@@ -0,0 +1,218 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import process from "node:process";
+import { createCliCancellationHandlers } from "../cli-cancellation.js";
+import { runCliPromptWithBudget } from "../cli-client.js";
+import { observedExecutionFields, persistedExecutionPlanFields, prepareKimiExecutionPlan, } from "../kimi-engine.js";
+import { getManagedCommandConfig } from "./registry.js";
+import { collectReviewContext } from "../git.js";
+import { digestPrompt, markJobCancelled, markJobFailed } from "../jobs.js";
+import { JobStore } from "../job-store.js";
+import { classifyManagedCommandFailure } from "../kimi-errors.js";
+import { KIMI_REVIEW_PROMPT_TIMEOUT_MS } from "../kimi-timeouts.js";
+import { writeInvocationLogHeader } from "../logging.js";
+import { ensurePluginPaths, resolvePluginPaths } from "../paths.js";
+import { parseReviewArgs } from "../parsing.js";
+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 { buildKimiSessionTitle, syncKimiSessionTitle } from "../session-title.js";
+// v1.0 cutover note (PR 2):
+//
+//   Replaced the v0.4 wire client + initialize + prompt sequence with a
+//   single `runCliPrompt` call against `kimi -p --output-format
+//   stream-json`. The PreToolUse hook (installed via /kimi:setup) reads
+//   `KIMI_PLUGIN_CC_CMD=review` (or `=challenge`) and denies anything
+//   but Read/Grep/Glob — so the read-only contract that v0.4 enforced
+//   via WireClient.approvalPolicy is now enforced out-of-band by the
+//   hook. The command no longer needs to wire its own approval policy.
+//
+// What stays:
+//
+//   - SQLite job store, prompt digest, artifact rendering, withTimeout
+//     for the prompt phase.
+//   - Cancellation: still SIGTERM/SIGINT-driven, but via AbortController
+//     instead of WireClient.cancel().
+//   - Job error classification via classifyManagedCommandFailure.
+//
+// What's gone:
+//
+//   - announceSessionTitle — vis-server has no PATCH endpoint; the
+//     kimi-web title cannot be written from the plugin in v1.0.
+//   - agent_profile — kimi-code doesn't load YAML agent profiles. The
+//     SQLite column stays for backward compatibility; we write a
+//     placeholder "<cli-client>" until PR 4 makes it nullable.
+//   - KIMI_INITIALIZE_TIMEOUT_MS / KIMI_START_TIMEOUT_MS — there's no
+//     separate initialize/start phase under -p mode.
+const REVIEW_AGENT_PROFILE_PLACEHOLDER = "<cli-client>";
+export async function runReview(argv, context, commandType) {
+    const parsed = parseReviewArgs(argv, commandType);
+    if (parsed.background || parsed.wait) {
+        throw new RuntimeError("INVALID_FLAGS", `${commandType} does not support --background or --wait in v1; review runs foreground-synchronously.`, `${commandType}.parse`);
+    }
+    if (context.env.KIMI_PLUGIN_CC_SKIP_HOOK_CHECK !== "1") {
+        await requireReadOnlyHookInstalled(context, commandType);
+    }
+    const reviewContext = await collectReviewContext(context.cwd, parsed.base);
+    const paths = resolvePluginPaths(context.env);
+    await ensurePluginPaths(paths);
+    const repoIdentity = await resolveRepoIdentity(context.cwd);
+    const executionPlan = await prepareKimiExecutionPlan({
+        operationKind: commandType,
+        cwd: context.cwd,
+        env: context.env,
+    });
+    const store = new JobStore(paths);
+    const jobId = randomUUID();
+    // kimi-code mints the actual session id and announces it on stderr;
+    // we leave the row's kimi_session_id NULL until the call returns to
+    // avoid storing a fictional id that no on-disk session matches.
+    // (See PR 2 review feedback in reports/17-pr2-claude-review.md.)
+    const reviewSessionId = null;
+    const logPath = path.join(paths.logsDir, `${commandType}-${jobId}.jsonl`);
+    const previewPrompt = buildReviewPrompt(commandType, reviewContext, parsed.focus);
+    const job = store.createJob({
+        job_id: jobId,
+        repo_id: repoIdentity.repoId,
+        command_type: commandType,
+        cwd: context.cwd,
+        model: parsed.model ?? null,
+        thinking: parsed.thinking ?? null,
+        background: false,
+        pid: process.pid,
+        kimi_pid: null,
+        status: "running",
+        kimi_session_id: reviewSessionId,
+        ...persistedExecutionPlanFields(executionPlan),
+        agent_profile: REVIEW_AGENT_PROFILE_PLACEHOLDER,
+        prompt_digest: digestPrompt(previewPrompt),
+        summary: `Running ${commandType}.`,
+        final_output_path: null,
+        stream_log_path: logPath,
+        error: null,
+    });
+    await writeInvocationLogHeader(logPath, {
+        commandType,
+        kimiSessionId: reviewSessionId ?? "(pending)",
+        cwd: context.cwd,
+    });
+    const reviewConfig = getManagedCommandConfig(commandType);
+    const cancel = reviewConfig.cancellation;
+    const handlers = createCliCancellationHandlers();
+    try {
+        const result = await runCliPromptWithBudget({
+            cwd: context.cwd,
+            env: context.env,
+            command: executionPlan.command,
+            prefixArgs: [...executionPlan.prefixArgs],
+            executionPlan,
+            prompt: previewPrompt,
+            commandLabel: commandType,
+            model: parsed.model,
+            logPath,
+            signal: handlers.signal,
+        }, 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`);
+        }
+        assertCliResultSuccess(result, `${commandType}.runtime`);
+        // Persist whichever session id kimi announced. Review never resumes,
+        // but the id is the only handle for post-hoc replay against
+        // ~/.kimi-code/sessions/.
+        if (result.sessionId !== undefined && result.sessionId.length > 0) {
+            // Tighten on length>0 so a degenerate empty-string capture doesn't
+            // 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 });
+        }
+        await syncKimiSessionTitle({
+            promptText: previewPrompt,
+            env: context.env,
+            cwd: job.cwd,
+            sessionId: result.sessionId ?? job.kimi_session_id,
+            title: buildKimiSessionTitle(commandType, parsed.focus ?? reviewContext.targetDescription),
+            stderr: context.stderr,
+        });
+        // Match ask/rescue: gate on the JOB row's pre-call session id so that
+        // a future --resume code path won't warn on a resumed review whose
+        // prior session id remains valid even if this turn didn't re-announce.
+        // Today review never resumes, so the gate is always true at call time.
+        if (job.kimi_session_id === null) {
+            warnIfSessionIdMissing(result, commandType, job.job_id, context.stderr);
+        }
+        const finalText = reassembleProseFromRecords(result.records);
+        const rendered = renderManagedJobOutput(job, finalText);
+        const artifactPath = await writeArtifact(paths, job, rendered.rendered);
+        if (handlers.cancelling) {
+            throw new RuntimeError(cancel.errorCodes.cancelled, cancel.cancelMessages.afterArtifact, `${commandType}.runtime`);
+        }
+        store.markCompleted(job.job_id, {
+            summary: rendered.summary,
+            final_output_path: artifactPath,
+            error: null,
+        });
+        return rendered.output;
+    }
+    catch (error) {
+        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);
+        throw classified;
+    }
+    finally {
+        handlers.dispose();
+        store.close();
+    }
+}
+async function requireReadOnlyHookInstalled(context, commandType) {
+    if (context.env.KIMI_PLUGIN_CC_SKIP_HOOK_CHECK === "1") {
+        return;
+    }
+    const installStatus = await verifyHookInstalled(context.env);
+    if (installStatus.installed) {
+        return;
+    }
+    maybeWarnHookMissing(installStatus, commandType, context.stderr);
+    throw new RuntimeError(`${commandType.toUpperCase()}_HOOK_NOT_INSTALLED`, [
+        `${commandType} refuses to run without the canonical kimi-plugin-cc PreToolUse hook.`,
+        `Hook check failed: ${installStatus.reason ?? "unknown"}.`,
+        "Run /kimi:setup or $kimi-setup to install or repair this host's managed block.",
+        "Set KIMI_PLUGIN_CC_SKIP_HOOK_CHECK=1 only if you intentionally accept un-enforced execution.",
+        hookRefusalRetryProtocol(context.env),
+    ].join(" "), `${commandType}.hook-check`, { details: hookRefusalDetails(installStatus) });
+}
+function buildReviewPrompt(commandType, reviewContext, focus) {
+    const modeInstructions = commandType === "challenge"
+        ? [
+            "Take a challenging stance.",
+            "Challenge assumptions, identify brittle design choices, and surface safer alternatives.",
+        ]
+        : ["Focus on concrete bugs, regressions, and missing safeguards in the supplied changes."];
+    return [
+        "Perform a read-only code review of the supplied repository changes.",
+        ...modeInstructions,
+        "Use repository read tools as needed, but do not attempt any write, shell, background, or delegated operations.",
+        "Return your review as plain markdown — a short verdict line (approve / concern / block), then a brief summary, then one section per finding with file:line refs. No JSON wrapper, no code fences around the whole response.",
+        "If the supplied diff context is empty or shows no changes to review, return immediately with a one-line note that there were no changes — do not explore the repository.",
+        focus ? `Review focus: ${focus}` : undefined,
+        "",
+        `Target: ${reviewContext.targetDescription}`,
+        `Repository root: ${reviewContext.repoRoot}`,
+        "",
+        "git status --short:",
+        reviewContext.statusSummary || "(clean)",
+        "",
+        "Unified diff context:",
+        reviewContext.diffText || "(no diff text available)",
+    ]
+        .filter((line) => typeof line === "string")
+        .join("\n");
+}