kimi-plugin-cc 2.0.7

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

@@ -0,0 +1,327 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { createCliCancellationHandlers } from "../cli-cancellation.js";
+import { runCliPromptWithBudget } from "../cli-client.js";
+import { assertPersistedResumeLineage, executionPlanFromPersisted, observedExecutionFields, persistedExecutionPlanFields, prepareKimiExecutionPlan, reconcileHistoricalJobProvenance, } from "../kimi-engine.js";
+import { getManagedCommandConfig } from "./registry.js";
+import { RuntimeError } from "../errors.js";
+import { resolveRepoIdentity } from "../git.js";
+import { digestPrompt, markJobCancelled, markJobFailed, sweepStaleJobs } from "../jobs.js";
+import { JobStore } from "../job-store.js";
+import { KIMI_ASK_PROMPT_TIMEOUT_MS } from "../kimi-timeouts.js";
+import { writeInvocationLogHeader } from "../logging.js";
+import { ensurePluginPaths, resolvePluginPaths } from "../paths.js";
+import { parseAskArgs } from "../parsing.js";
+import { readArtifact, renderManagedJobOutput, writeArtifact } from "../render.js";
+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 { buildKimiSessionTitle, syncKimiSessionTitle } from "../session-title.js";
+// v1.0 cutover note (PR 2):
+//
+//   The v0.4 wire client/initialize/prompt sequence is replaced with a
+//   single `runCliPrompt` against `kimi -p --output-format stream-json`.
+//   The PreToolUse hook reads `KIMI_PLUGIN_CC_CMD=ask` and applies the
+//   same read-only tool policy as review/challenge/review_gate.
+//
+// Session id handling differs from v0.4:
+//
+//   - v0.4 the client assigned the kimi session id upfront (passed via
+//     `--session <uuid>` on the wire command line).
+//   - v1.0 kimi-code assigns the session id and announces it via stderr
+//     ("To resume this session: kimi -r <uuid>"). We capture that id
+//     after the call and update the JobStore row.
+//   - For `--resume`, we pass the prior session id via `-r`; kimi-code
+//     keeps it across resumes.
+const ASK_SUMMARY_MAX = 120;
+const ASK_AGENT_PROFILE_PLACEHOLDER = "<cli-client>";
+const ASK_PROMPT_PREFIX = [
+    "Answer the user's question directly in free-form prose.",
+    "Stay read-only.",
+    "Do not emit JSON unless the user explicitly asks for it.",
+    "",
+    "User question:",
+    "",
+].join("\n");
+export async function runAsk(argv, context) {
+    const parsed = parseAskArgs(argv);
+    if (context.env.KIMI_PLUGIN_CC_SKIP_HOOK_CHECK !== "1") {
+        await requireAskHookInstalled(context);
+    }
+    const paths = resolvePluginPaths(context.env);
+    await ensurePluginPaths(paths);
+    const repoIdentity = await resolveRepoIdentity(context.cwd);
+    const askConfig = getManagedCommandConfig("ask");
+    const store = new JobStore(paths);
+    try {
+        await sweepStaleJobs(store, paths);
+        const jobId = randomUUID();
+        const sessionResolution = await resolveAskSession(store, repoIdentity.repoId, parsed.fresh, parsed.resume, parsed.resumeTarget);
+        const askPrompt = buildAskPrompt(parsed.prompt, sessionResolution.reusedSession);
+        const executionPlan = await prepareKimiExecutionPlan({
+            operationKind: "ask",
+            cwd: context.cwd,
+            env: context.env,
+            resumedFromJobId: sessionResolution.resumedFromJobId,
+            resumeSessionId: sessionResolution.kimiSessionId ?? undefined,
+            resumeSource: sessionResolution.sourceJob,
+        });
+        const logPath = path.join(paths.logsDir, `ask-${jobId}.jsonl`);
+        const job = store.createJob({
+            job_id: jobId,
+            repo_id: repoIdentity.repoId,
+            command_type: "ask",
+            cwd: context.cwd,
+            model: parsed.model ?? null,
+            thinking: parsed.thinking ?? null,
+            background: parsed.background,
+            pid: parsed.background ? null : process.pid,
+            kimi_pid: null,
+            status: "running",
+            kimi_session_id: sessionResolution.kimiSessionId,
+            ...persistedExecutionPlanFields(executionPlan),
+            agent_profile: ASK_AGENT_PROFILE_PLACEHOLDER,
+            prompt_digest: digestPrompt(askPrompt),
+            summary: shorten(parsed.prompt ?? askPrompt, ASK_SUMMARY_MAX),
+            phase: parsed.background ? "queued" : "starting",
+            final_output_path: null,
+            stream_log_path: logPath,
+            error: null,
+        });
+        try {
+            await writeInvocationLogHeader(logPath, {
+                commandType: "ask",
+                kimiSessionId: sessionResolution.kimiSessionId ?? "(pending)",
+                cwd: context.cwd,
+            });
+        }
+        catch (error) {
+            const classified = new RuntimeError("ASK_LOG_HEADER_FAILED", `Failed to write ask invocation log header: ${error.message ?? String(error)}`, "ask.log-header", error instanceof Error ? { cause: error } : undefined);
+            await markJobFailed(store, paths, job, classified, askConfig.cancellation.failedSummary, { phase: "failed" });
+            throw classified;
+        }
+        if (parsed.background) {
+            return startBackgroundJob(job, askPrompt, context, paths, {
+                workerKind: "ask",
+                wait: parsed.wait,
+                promptEnvVar: "KIMI_PLUGIN_CC_ASK_PROMPT_B64",
+                reusedSessionEnvVar: "KIMI_PLUGIN_CC_ASK_REUSED_SESSION",
+                reusedSession: sessionResolution.reusedSession,
+                failedSummary: askConfig.cancellation.failedSummary,
+                missingResultErrorCode: "ASK_RESULT_MISSING",
+                spawnFailedErrorCode: "ASK_WORKER_SPAWN_FAILED",
+                earlyExitErrorCode: "ASK_WORKER_EXITED_EARLY",
+                nodeBinInvalidErrorCode: "ASK_NODE_BIN_INVALID",
+                waitStage: "ask.wait",
+                spawnStage: "ask.worker.spawn",
+            });
+        }
+        const completed = await executeAskJob(job.job_id, askPrompt, context);
+        if (!completed.final_output_path) {
+            throw new RuntimeError("ASK_RESULT_MISSING", "Ask finished without a rendered result.", "ask.result");
+        }
+        return (await readArtifact(completed.final_output_path)).trimEnd();
+    }
+    finally {
+        store.close();
+    }
+}
+export async function executeAskJob(jobId, prompt, context, options) {
+    const paths = resolvePluginPaths(context.env);
+    await ensurePluginPaths(paths);
+    const store = new JobStore(paths);
+    const job = store.getJob(jobId);
+    if (!job) {
+        store.close();
+        throw new RuntimeError("JOB_NOT_FOUND", `Ask job ${jobId} was not found.`, "ask.worker");
+    }
+    const askConfig = getManagedCommandConfig("ask");
+    const cancel = askConfig.cancellation;
+    let handlers;
+    try {
+        // Re-verify in the worker so a background job cannot outlive or bypass
+        // enforcement drift between the user invocation and the actual Kimi spawn.
+        if (context.env.KIMI_PLUGIN_CC_SKIP_HOOK_CHECK !== "1") {
+            await requireAskHookInstalled(context);
+        }
+        handlers = createCliCancellationHandlers();
+        const executionPlan = executionPlanFromPersisted(job);
+        // Re-validate resume lineage from the store before spawning: a detached
+        // worker (or a forged queued row) reloads the persisted plan and would
+        // otherwise hand kimi_session_id to the spawn without the dispatch-time
+        // lineage check. Fresh sessions (no resumedFromJobId) are exempt.
+        if (job.kimi_session_id !== null) {
+            await assertPersistedResumeLineage(store, executionPlan, job.kimi_session_id, "ask");
+        }
+        if (options?.workerPid) {
+            store.updateRunningJob(job.job_id, { pid: options.workerPid, phase: "worker-running" });
+        }
+        const result = await runCliPromptWithBudget({
+            cwd: job.cwd,
+            env: context.env,
+            command: executionPlan.command,
+            prefixArgs: [...executionPlan.prefixArgs],
+            executionPlan,
+            prompt,
+            commandLabel: "ask",
+            model: job.model ?? undefined,
+            resumeSessionId: job.kimi_session_id ?? undefined,
+            logPath: job.stream_log_path,
+            signal: handlers.signal,
+        }, 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");
+        }
+        assertCliResultSuccess(result, "ask.runtime");
+        // 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) {
+            // 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 });
+        }
+        await syncKimiSessionTitle({
+            promptText: prompt,
+            env: context.env,
+            cwd: job.cwd,
+            sessionId: result.sessionId ?? job.kimi_session_id,
+            title: buildKimiSessionTitle("ask", prompt.startsWith(ASK_PROMPT_PREFIX) ? prompt.slice(ASK_PROMPT_PREFIX.length) : prompt),
+            stderr: context.stderr,
+        });
+        // For ask, missing session id breaks both -r (latest-resume) and
+        // explicit --resume <id>. Warn loudly so the user notices before
+        // they try to continue the conversation.
+        if (job.kimi_session_id === null) {
+            warnIfSessionIdMissing(result, "ask", 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, "ask.runtime");
+        }
+        return (store.markCompleted(job.job_id, {
+            summary: rendered.summary,
+            phase: "done",
+            final_output_path: artifactPath,
+            error: null,
+        }) ?? job);
+    }
+    catch (error) {
+        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" });
+        }
+        // Hook preflight errors are already fully classified. Running them through
+        // the generic availability classifier can mistake words in the verifier's
+        // reason (for example "timed out") for a Kimi runtime timeout and erase the
+        // load-bearing hook-check code/stage from the persisted background job.
+        if (error instanceof RuntimeError && error.stage === "ask.hook-check") {
+            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" });
+        throw classified;
+    }
+    finally {
+        handlers?.dispose();
+        store.close();
+    }
+}
+async function requireAskHookInstalled(context) {
+    if (context.env.KIMI_PLUGIN_CC_SKIP_HOOK_CHECK === "1") {
+        return;
+    }
+    const installStatus = await verifyHookInstalled(context.env);
+    if (installStatus.installed) {
+        return;
+    }
+    maybeWarnHookMissing(installStatus, "ask", context.stderr);
+    throw new RuntimeError("ASK_HOOK_NOT_INSTALLED", [
+        "ask 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(" "), "ask.hook-check", { details: hookRefusalDetails(installStatus) });
+}
+async function resolveAskSession(store, repoId, fresh, resume, resumeTarget) {
+    if (fresh) {
+        return { kimiSessionId: null, reusedSession: false, resumedFromJobId: null, sourceJob: null };
+    }
+    if (resumeTarget) {
+        const byJob = store.getJob(resumeTarget);
+        const scoped = byJob?.repo_id === repoId && byJob.command_type === "ask" ? byJob : null;
+        const exact = scoped ?? store.findAskJobBySession(repoId, resumeTarget);
+        if (!exact) {
+            throw new RuntimeError("ASK_RESUME_NOT_FOUND", `No ask job or session matched ${resumeTarget}.`, "ask.resume");
+        }
+        // Order matters: surface ASK_ALREADY_RUNNING before complaining that
+        // the session id is missing. In v1.0 a running ask row carries
+        // kimi_session_id=NULL (kimi-code assigns the id post-call), so the
+        // legacy "no session id → not found" check would mask the more
+        // accurate "already running" error.
+        const source = await reconcileHistoricalJobProvenance(store, exact);
+        ensureAskSessionIsNotRunning(source);
+        if (!source.kimi_session_id) {
+            throw new RuntimeError("ASK_RESUME_NOT_FOUND", `No ask job or session matched ${resumeTarget}.`, "ask.resume");
+        }
+        return {
+            kimiSessionId: source.kimi_session_id,
+            reusedSession: true,
+            resumedFromJobId: source.job_id,
+            sourceJob: source,
+        };
+    }
+    if (resume) {
+        const latest = store.findLatestJob({ repoId, commandType: "ask" });
+        if (!latest) {
+            throw new RuntimeError("ASK_RESUME_NOT_FOUND", "No prior ask session exists for this repository.", "ask.resume");
+        }
+        const source = await reconcileHistoricalJobProvenance(store, latest);
+        ensureAskSessionIsNotRunning(source);
+        if (!source.kimi_session_id) {
+            throw new RuntimeError("ASK_RESUME_NOT_FOUND", "No prior ask session exists for this repository.", "ask.resume");
+        }
+        return {
+            kimiSessionId: source.kimi_session_id,
+            reusedSession: true,
+            resumedFromJobId: source.job_id,
+            sourceJob: source,
+        };
+    }
+    return { kimiSessionId: null, reusedSession: false, resumedFromJobId: null, sourceJob: null };
+}
+function ensureAskSessionIsNotRunning(job) {
+    if (job.status === "running") {
+        throw new RuntimeError("ASK_ALREADY_RUNNING", `Ask session ${job.kimi_session_id ?? "<unknown>"} is already active under job ${job.job_id}.`, "ask.resume");
+    }
+}
+function buildAskPrompt(question, reusedSession) {
+    if (question?.trim()) {
+        return ASK_PROMPT_PREFIX + question.trim();
+    }
+    if (reusedSession) {
+        return [
+            "Continue the previous ask conversation in free-form prose.",
+            "Stay read-only.",
+            "Do not emit JSON unless the user explicitly asks for it.",
+        ].join("\n");
+    }
+    throw new RuntimeError("INVALID_ARGS", "ask requires a question after the flags.", "ask.parse");
+}
+function shorten(text, max) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (normalized.length <= max) {
+        return normalized;
+    }
+    return `${normalized.slice(0, Math.max(0, max - 1)).trimEnd()}…`;
+}

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

@@ -0,0 +1,178 @@
+import process from "node:process";
+import { RuntimeError } from "../errors.js";
+import { resolveRepoIdentity } from "../git.js";
+import { markJobCancelled, sweepStaleJobs } from "../jobs.js";
+import { JobStore, withJobStore } from "../job-store.js";
+import { ensurePluginPaths, resolvePluginPaths } from "../paths.js";
+import { parseJobLookupArgs } from "../parsing.js";
+import { getManagedCommandConfig } from "./registry.js";
+export async function runCancel(argv, context) {
+    const parsed = parseJobLookupArgs(argv);
+    const paths = resolvePluginPaths(context.env);
+    await ensurePluginPaths(paths);
+    const repoIdentity = await resolveRepoIdentity(context.cwd);
+    const store = new JobStore(paths);
+    try {
+        await sweepStaleJobs(store, paths);
+        const job = parsed.jobId
+            ? store.getJob(parsed.jobId)
+            : store.findLatestJob({
+                repoId: repoIdentity.repoId,
+                commandType: parsed.type,
+                runningOnly: true,
+            });
+        if (!job) {
+            throw new RuntimeError("JOB_NOT_FOUND", "No running job was found to cancel.", "cancel.lookup");
+        }
+        if (job.status !== "running") {
+            return `${JSON.stringify({
+                job_id: job.job_id,
+                status: job.status,
+                message: "cancel is a no-op for terminal jobs.",
+            }, null, 2)}\n`;
+        }
+        if (job.pid === null && job.kimi_pid === null) {
+            throw new RuntimeError("CANCEL_NOT_SUPPORTED", `Job ${job.job_id} does not have a recorded process id to cancel.`, "cancel.runtime");
+        }
+        // review_gate runs in a Stop hook; SIGTERMing kimi_pid causes the wire
+        // process to exit with WIRE_PROCESS_EXITED, which the hook's catch path
+        // would persist as `failed`. Pre-mark the row as `cancelled` here so the
+        // user's intent is recorded canonically — the subsequent wire exit is a
+        // no-op against an already-terminal row (markFailed has a WHERE
+        // status='running' guard).
+        //
+        // Because the row is now terminal, waitForCancellation returns
+        // immediately on the status check and never escalates to SIGKILL. Run
+        // an unconditional SIGTERM→1s→SIGKILL sequence on the recorded pids
+        // here and return early so the lower-level wait/escalation path does
+        // not skip cleanup. (v0.2.4)
+        if (job.command_type === "review_gate") {
+            // Pre-mark before signaling so the row persists as `cancelled` rather
+            // than the `failed` the hook's catch path would write on WIRE_PROCESS_EXITED.
+            //
+            // If the pre-mark itself fails (disk I/O, SQLite contention), we must
+            // STILL signal the Kimi child — otherwise the user's cancel command
+            // produces an alive-but-marked-cancelled stuck state. Capture the
+            // pre-mark failure, run the SIGTERM→SIGKILL escalation unconditionally,
+            // and rethrow at the end so the user sees the underlying error.
+            let preMarkError;
+            try {
+                await withJobStore(paths, async (preMarkStore) => {
+                    const reviewGateCancel = getManagedCommandConfig("review_gate").cancellation;
+                    await markJobCancelled(preMarkStore, paths, job, reviewGateCancel.cancelledSummary, new RuntimeError(reviewGateCancel.errorCodes.cancelled, reviewGateCancel.cancelMessages.default, "cancel.runtime"));
+                });
+            }
+            catch (error) {
+                preMarkError = error;
+            }
+            signalJobProcesses(job, "SIGTERM");
+            await sleep(1_000);
+            if (hasLiveRecordedProcess(job)) {
+                signalJobProcesses(job, "SIGKILL");
+            }
+            if (preMarkError) {
+                throw preMarkError;
+            }
+            return `${JSON.stringify({
+                job_id: job.job_id,
+                status: "cancelled",
+                message: "review_gate cancelled; SIGTERM→SIGKILL escalation completed.",
+            }, null, 2)}\n`;
+        }
+        signalJobProcesses(job, "SIGTERM");
+        const cancelled = await waitForCancellation(paths, job.job_id);
+        if (cancelled) {
+            return `${JSON.stringify({
+                job_id: cancelled.job_id,
+                status: cancelled.status,
+                message: "Cancellation completed.",
+            }, null, 2)}\n`;
+        }
+        signalJobProcesses(job, "SIGKILL");
+        await withJobStore(paths, async (forcedStore) => {
+            const current = forcedStore.getJob(job.job_id);
+            if (current?.status === "running") {
+                await markJobCancelled(forcedStore, paths, current, "Job was force-cancelled after recorded process termination.", undefined, current.command_type === "ask" || current.command_type === "rescue" ? { phase: "cancelled" } : undefined);
+            }
+        });
+        return `${JSON.stringify({
+            job_id: job.job_id,
+            status: "cancelled",
+            message: "Cancellation escalated to worker termination.",
+        }, null, 2)}\n`;
+    }
+    finally {
+        store.close();
+    }
+}
+function signalJobProcesses(job, signal) {
+    const pids = new Set();
+    if (job.pid !== null)
+        pids.add(job.pid);
+    if (job.kimi_pid !== null)
+        pids.add(job.kimi_pid);
+    for (const pid of pids) {
+        try {
+            process.kill(pid, signal);
+        }
+        catch (error) {
+            const code = error.code;
+            // ESRCH: process already gone. EPERM: pid was likely reused by an
+            // unrelated process we don't own — silently skip rather than surface a
+            // confusing "operation not permitted" to the user.
+            if (code !== "ESRCH" && code !== "EPERM") {
+                throw error;
+            }
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+async function waitForCancellation(paths, jobId) {
+    const deadline = Date.now() + 4_000;
+    while (Date.now() < deadline) {
+        const store = new JobStore(paths);
+        try {
+            const current = store.getJob(jobId);
+            if (current && current.status !== "running") {
+                return current;
+            }
+            if (current && !hasLiveRecordedProcess(current)) {
+                return null;
+            }
+        }
+        finally {
+            store.close();
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 200);
+        });
+    }
+    return null;
+}
+function hasLiveRecordedProcess(job) {
+    const pids = new Set();
+    if (job.pid !== null)
+        pids.add(job.pid);
+    if (job.kimi_pid !== null)
+        pids.add(job.kimi_pid);
+    for (const pid of pids) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (error) {
+            const code = error.code;
+            // ESRCH: definitively dead. EPERM: pid likely reused by an
+            // unrelated process — treat as dead for our purposes (consistent
+            // with isPidAlive in jobs.ts and signalJobProcesses above).
+            if (code !== "ESRCH" && code !== "EPERM") {
+                return true;
+            }
+        }
+    }
+    return false;
+}

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

@@ -0,0 +1,112 @@
+import { RuntimeError } from "../errors.js";
+/**
+ * Reassemble prose final text from cli-client records.
+ *
+ * The v0.4 wire client returned a single `finalText` field as the
+ * canonical assistant prose. Stream-json instead emits a sequence of
+ * records, three of which can carry assistant prose:
+ *
+ *   - `{role:"assistant", content:"..."}`           — text token
+ *   - `{role:"assistant", tool_calls:[...]}`        — no text
+ *   - `{role:"tool", tool_call_id:"...", content}`  — tool output, ignore
+ *
+ * We concatenate every assistant `content` field in arrival order. The
+ * order is preserved by stream-json's NDJSON contract — kimi-code emits
+ * one record per line, parser preserves emission order, runtime
+ * pushes to `records[]` in the same order.
+ *
+ * Two correctness notes:
+ *
+ *   1. Empty assistant records (assistant tool_calls without prose)
+ *      contribute zero characters but still appear in `records`. We
+ *      skip them without inserting a separator, otherwise back-to-back
+ *      tool calls would inject blank lines.
+ *
+ *   2. We do NOT trim individual content fragments. kimi-code emits
+ *      tokens that may include leading/trailing whitespace as part of
+ *      the model's intended formatting. Only the final concatenated
+ *      string is whitespace-managed by the caller's render layer.
+ */
+export function reassembleProseFromRecords(records) {
+    let out = "";
+    for (const record of records) {
+        if (record.role !== "assistant")
+            continue;
+        if (typeof record.content !== "string")
+            continue;
+        out += record.content;
+    }
+    return out;
+}
+/**
+ * Loud-fail warning when kimi finished a job but never announced a
+ * session id on stderr. We persist `kimi_session_id` as NULL in that
+ * case (the row is unresumable), and the user is silently surprised
+ * later when `-r` or `/kimi:replay` returns nothing.
+ *
+ * The right surface is human-readable stderr per the LLM-caller
+ * discipline invariant — load-bearing context still goes via the SQLite
+ * row (`kimi_session_id IS NULL`), but the user sees this warning
+ * inline immediately after the prompt completes so they know resume is
+ * unavailable for this job.
+ *
+ * Called at the end of every command that captures sessionId (review,
+ * challenge, ask, rescue). Review-gate intentionally skips: it's a Stop
+ * hook with no resume semantics and we don't want a runtime warning to
+ * leak into Claude Code's transcript on every assistant turn.
+ */
+export function warnIfSessionIdMissing(result, commandLabel, jobId, stderr) {
+    if (result.sessionId !== undefined && result.sessionId.length > 0) {
+        return;
+    }
+    stderr.write(`[${commandLabel}] kimi did not announce a session id for job ${jobId}. ` +
+        `Resume and replay will not work for this job. ` +
+        `If this happens repeatedly, check kimi-code's stderr format (the " To resume this session" line) and report upstream.\n`);
+}
+/**
+ * Translate a cli-client `CliClientResult` into the kind of error
+ * surface ask/review/rescue commands have always thrown when the
+ * underlying transport reported a failure.
+ *
+ * Order matters: a non-zero exit code may carry no records (process
+ * died early) or may carry partial records (model started but kimi
+ * crashed). Either way, we surface the exit-code failure first because
+ * trying to render a half-stream as `finalText` produces confusing
+ * downstream errors.
+ *
+ * `stage` is used as both the RuntimeError stage and a prefix-free
+ * label for code namespacing — callers should pass values like
+ * "ask.runtime" / "review.runtime" / "review_gate.runtime".
+ */
+export function assertCliResultSuccess(result, stage) {
+    if (result.aborted) {
+        // Aborted-by-our-signal is a cancellation, not a failure. The
+        // caller's outer handler checks `handlers.cancelling` and wraps
+        // into the canonical *_CANCELLED RuntimeError; we just need to
+        // bail without claiming the records are a complete response.
+        throw new RuntimeError("CLI_ABORTED", "kimi subprocess was cancelled before completing the response", stage, {
+            details: {
+                exit_code: result.exitCode,
+                signal: result.signal,
+                record_count: result.records.length,
+                stderr_tail_len: result.stderrTail.length,
+            },
+        });
+    }
+    if (result.exitCode !== 0) {
+        const tail = result.stderrTail.trim();
+        throw new RuntimeError("CLI_NONZERO_EXIT", [
+            `kimi subprocess exited with code ${result.exitCode}`,
+            result.signal ? ` (signal ${result.signal})` : "",
+            tail.length > 0 ? `:\n${tail}` : ".",
+        ].join(""), stage, {
+            details: {
+                exit_code: result.exitCode,
+                signal: result.signal,
+                record_count: result.records.length,
+                malformed_count: result.malformed.length,
+                stderr_tail_len: result.stderrTail.length,
+            },
+        });
+    }
+}