kimi-plugin-cc 2.0.7

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

@@ -0,0 +1,553 @@
+import { RuntimeError } from "./errors.js";
+/**
+ * Tokens like `--foo` or `-x` that aren't in a command's known-flags set are
+ * almost certainly typos (e.g. `--from HEAD~2` instead of `--base HEAD~2`)
+ * or — for agent-mediated callers — hallucinated flag names (e.g. wrappers
+ * inventing `--file` / `--context` because that shape is common in other
+ * CLIs). The historical behavior — silently treating them as free-form
+ * trailing prompt/focus text with an advisory stderr warning — produced
+ * misleading runs (Kimi chewing on a bloated blob, or hitting the prompt
+ * timeout). All command parsers now hard-fail on unknown flag-shaped tokens
+ * while still preserving prose mode after the first non-flag token and the
+ * `--` escape.
+ */
+function looksLikeFlag(token) {
+    if (!token.startsWith("-")) {
+        return false;
+    }
+    if (token.startsWith("--") && token.length > 2) {
+        return true;
+    }
+    // Short flag: a single dash followed by exactly one letter (`-r`, `-m`).
+    return /^-[a-zA-Z]$/.test(token);
+}
+const ASK_SUPPORTED_FLAGS = "-m/--model <name>, --background, --wait, --fresh, -r, --resume <job-id|session-id>";
+const RESCUE_SUPPORTED_FLAGS = "-m/--model <name>, --background, --wait, --fresh, -r, --resume <job-id|session-id>";
+// Thinking-on is always-on for user-facing commands in v1.0. review-gate
+// pins thinking=false via the cli-client options bag instead of an argv
+// flag (see runtime/cli-client.ts::CliClientOptions). The parser rejects
+// --thinking and --no-thinking with a hard error so a documented-removed
+// flag doesn't get silently accepted as a no-op. Both bare (`--thinking`)
+// and assignment (`--thinking=true`) forms are rejected — otherwise the
+// assignment form would fall through to the generic "Unknown flag" path
+// and a wrapper agent reading the error would think the cure is to drop
+// the `=value` rather than the flag itself.
+const THINKING_FLAG_REMOVED_MESSAGE = "--thinking / --no-thinking were removed in v1.0. Thinking is always on for user-facing commands.";
+function isRemovedThinkingFlag(token) {
+    return (token === "--thinking" ||
+        token === "--no-thinking" ||
+        token.startsWith("--thinking=") ||
+        token.startsWith("--no-thinking="));
+}
+const PURSUE_SUPPORTED_FLAGS = "-m/--model <name>, --budget <30m|1h|90s>, --turns <N>";
+const SWARM_SUPPORTED_FLAGS = "-m/--model <name>, --budget <30m|1h|90s>, --cap <N>, --max-concurrency <N>, --write";
+/**
+ * Parser for /kimi:swarm (read-only parallel fan-out). Foreground-only:
+ * no --background/--fresh/--resume. Trailing tokens are the objective.
+ */
+export function parseSwarmArgs(argv) {
+    let model;
+    const thinking = true;
+    let budgetMs;
+    let cap;
+    let maxConcurrency;
+    let write = false;
+    let trailingTokens;
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--") {
+            trailingTokens = argv.slice(index + 1);
+            break;
+        }
+        if (!token.startsWith("-")) {
+            trailingTokens = argv.slice(index);
+            break;
+        }
+        switch (token) {
+            case "-m":
+            case "--model": {
+                const value = argv[index + 1];
+                if (!value) {
+                    throw new RuntimeError("INVALID_ARGS", `${token} requires a model value.`, "swarm.parse");
+                }
+                if (value.startsWith("-")) {
+                    throw new RuntimeError("INVALID_ARGS", `${token} value cannot start with '-'; pass a model name`, "swarm.parse");
+                }
+                model = value;
+                index += 1;
+                break;
+            }
+            case "--write":
+                write = true;
+                break;
+            case "--budget": {
+                const value = argv[index + 1];
+                if (!value || value.startsWith("-")) {
+                    throw new RuntimeError("INVALID_ARGS", "--budget requires a duration (e.g. 30m, 1h, 90s).", "swarm.parse");
+                }
+                budgetMs = parseDurationMs(value, "--budget");
+                index += 1;
+                break;
+            }
+            case "--cap": {
+                cap = parsePositiveIntFlag("--cap", argv[index + 1]);
+                index += 1;
+                break;
+            }
+            case "--max-concurrency": {
+                maxConcurrency = parsePositiveIntFlag("--max-concurrency", argv[index + 1]);
+                index += 1;
+                break;
+            }
+            default:
+                if (isRemovedThinkingFlag(token)) {
+                    throw new RuntimeError("INVALID_ARGS", THINKING_FLAG_REMOVED_MESSAGE, "swarm.parse");
+                }
+                if (looksLikeFlag(token)) {
+                    throw new RuntimeError("INVALID_ARGS", `Unknown flag ${token} for swarm. Supported flags: ${SWARM_SUPPORTED_FLAGS}. Use \`--\` before flag-shaped objective text to pass it through.`, "swarm.parse");
+                }
+                trailingTokens = argv.slice(index);
+                index = argv.length;
+                break;
+        }
+    }
+    return {
+        budgetMs,
+        cap,
+        maxConcurrency,
+        write,
+        model,
+        thinking,
+        objective: trailingTokens?.join(" "),
+    };
+}
+/**
+ * Shared positive-integer flag parser for swarm's `--cap` / `--max-concurrency`.
+ * Both must be a strict positive integer; `--max-concurrency` in particular maps
+ * to kimi-code's `KIMI_CODE_AGENT_SWARM_MAX_CONCURRENCY`, whose upstream resolver
+ * THROWS on a non-positive-integer — so the same `Number.isInteger && > 0`
+ * predicate guarantees every accepted value round-trips through `String()`.
+ */
+function parsePositiveIntFlag(flag, value) {
+    if (!value || value.startsWith("-")) {
+        throw new RuntimeError("INVALID_ARGS", `${flag} requires a positive integer.`, "swarm.parse");
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new RuntimeError("INVALID_ARGS", `${flag} must be a positive integer.`, "swarm.parse");
+    }
+    return parsed;
+}
+/**
+ * Upper bound for any `--budget` duration. The budget is the SOLE hard
+ * wall-clock bound on the plugin's autonomous/fan-out surfaces (pursue, swarm),
+ * so a typo'd or absurd value (`999999h`, a pasted nanosecond count) would
+ * effectively disable that bound — defeating the one guarantee these modes rest
+ * on. 24h is far above any legitimate budget (pursue defaults to 45m, swarm to
+ * 30m) yet still finite, so the AbortController always fires. Above it we
+ * hard-fail INVALID_ARGS rather than silently clamp — a wrapper LLM passing a
+ * runaway budget should see the rejection, not a quietly-different value.
+ */
+export const MAX_DURATION_MS = 24 * 60 * 60 * 1_000;
+/**
+ * Parse a duration token (`30m`, `1h`, `90s`, or a bare integer = minutes)
+ * into milliseconds. Throws INVALID_ARGS on a malformed, non-positive, or
+ * absurdly large value (> {@link MAX_DURATION_MS}).
+ */
+export function parseDurationMs(token, flag) {
+    const match = /^(\d+)(s|m|h)?$/.exec(token.trim());
+    if (!match) {
+        throw new RuntimeError("INVALID_ARGS", `${flag} expects a duration like 30m, 1h, or 90s (bare number = minutes); got "${token}".`, "pursue.parse");
+    }
+    const value = Number(match[1]);
+    const unit = match[2] ?? "m";
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new RuntimeError("INVALID_ARGS", `${flag} must be a positive duration.`, "pursue.parse");
+    }
+    const unitMs = unit === "s" ? 1_000 : unit === "h" ? 3_600_000 : 60_000;
+    const ms = value * unitMs;
+    if (ms > MAX_DURATION_MS) {
+        throw new RuntimeError("INVALID_ARGS", `${flag} must be at most 24h (got "${token}"); the budget is a safety ceiling, not a scheduler.`, "pursue.parse");
+    }
+    return ms;
+}
+/**
+ * Parser for /kimi:pursue (autonomous goal mode). Foreground-only in the
+ * prototype: no --background/--fresh/--resume (the goalId/sessionId split makes
+ * session resume unreliable — see pursue.ts). Trailing tokens are the objective.
+ */
+export function parsePursueArgs(argv) {
+    let model;
+    const thinking = true;
+    let budgetMs;
+    let turns;
+    let trailingTokens;
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--") {
+            trailingTokens = argv.slice(index + 1);
+            break;
+        }
+        if (!token.startsWith("-")) {
+            trailingTokens = argv.slice(index);
+            break;
+        }
+        switch (token) {
+            case "-m":
+            case "--model": {
+                const value = argv[index + 1];
+                if (!value) {
+                    throw new RuntimeError("INVALID_ARGS", `${token} requires a model value.`, "pursue.parse");
+                }
+                if (value.startsWith("-")) {
+                    throw new RuntimeError("INVALID_ARGS", `${token} value cannot start with '-'; pass a model name`, "pursue.parse");
+                }
+                model = value;
+                index += 1;
+                break;
+            }
+            case "--budget": {
+                const value = argv[index + 1];
+                if (!value || value.startsWith("-")) {
+                    throw new RuntimeError("INVALID_ARGS", "--budget requires a duration (e.g. 30m, 1h, 90s).", "pursue.parse");
+                }
+                budgetMs = parseDurationMs(value, "--budget");
+                index += 1;
+                break;
+            }
+            case "--turns": {
+                const value = argv[index + 1];
+                if (!value || value.startsWith("-")) {
+                    throw new RuntimeError("INVALID_ARGS", "--turns requires a positive integer.", "pursue.parse");
+                }
+                const parsedTurns = Number(value);
+                if (!Number.isInteger(parsedTurns) || parsedTurns <= 0) {
+                    throw new RuntimeError("INVALID_ARGS", "--turns must be a positive integer.", "pursue.parse");
+                }
+                turns = parsedTurns;
+                index += 1;
+                break;
+            }
+            default:
+                if (isRemovedThinkingFlag(token)) {
+                    throw new RuntimeError("INVALID_ARGS", THINKING_FLAG_REMOVED_MESSAGE, "pursue.parse");
+                }
+                if (looksLikeFlag(token)) {
+                    throw new RuntimeError("INVALID_ARGS", `Unknown flag ${token} for pursue. Supported flags: ${PURSUE_SUPPORTED_FLAGS}. Use \`--\` before flag-shaped objective text to pass it through.`, "pursue.parse");
+                }
+                trailingTokens = argv.slice(index);
+                index = argv.length;
+                break;
+        }
+    }
+    return {
+        budgetMs,
+        turns,
+        model,
+        thinking,
+        objective: trailingTokens?.join(" "),
+    };
+}
+export function parseAskArgs(argv) {
+    let model;
+    // Thinking is on by default across ask/review/challenge/rescue. The
+    // parser rejects --thinking / --no-thinking; review-gate's runtime
+    // caller pins thinking=false via CliClientOptions instead.
+    let thinking = true;
+    let background = false;
+    let wait = false;
+    let fresh = false;
+    let resume = false;
+    let resumeTarget;
+    let explicitResumeTarget = false;
+    let trailingTokens;
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--") {
+            trailingTokens = argv.slice(index + 1);
+            break;
+        }
+        if (!token.startsWith("-")) {
+            trailingTokens = argv.slice(index);
+            break;
+        }
+        switch (token) {
+            case "-m":
+            case "--model": {
+                const value = argv[index + 1];
+                if (!value) {
+                    throw new RuntimeError("INVALID_ARGS", `${token} requires a model value.`, "args.parse");
+                }
+                if (value.startsWith("-")) {
+                    throw new RuntimeError("INVALID_ARGS", `${token} value cannot start with '-'; pass a model name`, "args.parse");
+                }
+                model = value;
+                index += 1;
+                break;
+            }
+            case "--background":
+                background = true;
+                break;
+            case "--wait":
+                wait = true;
+                break;
+            case "--fresh":
+                fresh = true;
+                break;
+            case "-r":
+                resume = true;
+                break;
+            case "--resume": {
+                const value = argv[index + 1];
+                if (!value || value.startsWith("-")) {
+                    throw new RuntimeError("INVALID_ARGS", "--resume requires a job-id or session-id. Use -r to resume the latest ask session for this repo.", "ask.parse");
+                }
+                resume = true;
+                resumeTarget = value;
+                explicitResumeTarget = true;
+                index += 1;
+                break;
+            }
+            default:
+                if (isRemovedThinkingFlag(token)) {
+                    throw new RuntimeError("INVALID_ARGS", THINKING_FLAG_REMOVED_MESSAGE, "args.parse");
+                }
+                if (looksLikeFlag(token)) {
+                    throw new RuntimeError("INVALID_ARGS", `Unknown flag ${token} for ask. Supported flags: ${ASK_SUPPORTED_FLAGS}. Use \`--\` before flag-shaped prompt text to pass it through.`, "args.parse");
+                }
+                trailingTokens = argv.slice(index);
+                index = argv.length;
+                break;
+        }
+    }
+    if (fresh && resume) {
+        throw new RuntimeError("INVALID_ARGS", "ask does not allow --fresh and --resume together.", "ask.parse");
+    }
+    if (explicitResumeTarget && trailingTokens?.length) {
+        throw new RuntimeError("INVALID_ARGS", "--resume only accepts a job-id or session-id. Use -r to resume the latest ask session with a prompt.", "ask.parse");
+    }
+    return {
+        background,
+        wait,
+        fresh,
+        resume,
+        resumeTarget,
+        model,
+        thinking,
+        prompt: trailingTokens?.join(" "),
+    };
+}
+export function parseReviewArgs(argv, commandName = "review") {
+    const parsed = parseKnownFlags(argv, new Set(["--base", "--background", "--wait", "-m", "--model"]), commandName);
+    return {
+        base: parsed.base,
+        background: parsed.background,
+        wait: parsed.wait,
+        model: parsed.model,
+        thinking: parsed.thinking,
+        focus: parsed.trailingText,
+    };
+}
+export function parseRescueArgs(argv) {
+    let model;
+    let thinking = true;
+    let background = false;
+    let wait = false;
+    let fresh = false;
+    let resume = false;
+    let resumeTarget;
+    let explicitResumeTarget = false;
+    let trailingTokens;
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--") {
+            trailingTokens = argv.slice(index + 1);
+            break;
+        }
+        if (!token.startsWith("-")) {
+            trailingTokens = argv.slice(index);
+            break;
+        }
+        switch (token) {
+            case "-m":
+            case "--model": {
+                const value = argv[index + 1];
+                if (!value) {
+                    throw new RuntimeError("INVALID_ARGS", `${token} requires a model value.`, "args.parse");
+                }
+                if (value.startsWith("-")) {
+                    throw new RuntimeError("INVALID_ARGS", `${token} value cannot start with '-'; pass a model name`, "args.parse");
+                }
+                model = value;
+                index += 1;
+                break;
+            }
+            case "--background":
+                background = true;
+                break;
+            case "--wait":
+                wait = true;
+                break;
+            case "--fresh":
+                fresh = true;
+                break;
+            case "-r":
+                resume = true;
+                break;
+            case "--resume": {
+                const value = argv[index + 1];
+                if (!value || value.startsWith("-")) {
+                    throw new RuntimeError("INVALID_ARGS", "--resume requires a job-id or session-id. Use -r to resume the latest rescue session for this repo.", "rescue.parse");
+                }
+                resume = true;
+                resumeTarget = value;
+                explicitResumeTarget = true;
+                index += 1;
+                break;
+            }
+            default:
+                if (isRemovedThinkingFlag(token)) {
+                    throw new RuntimeError("INVALID_ARGS", THINKING_FLAG_REMOVED_MESSAGE, "args.parse");
+                }
+                if (looksLikeFlag(token)) {
+                    throw new RuntimeError("INVALID_ARGS", `Unknown flag ${token} for rescue. Supported flags: ${RESCUE_SUPPORTED_FLAGS}. Use \`--\` before flag-shaped prompt text to pass it through.`, "args.parse");
+                }
+                trailingTokens = argv.slice(index);
+                index = argv.length;
+                break;
+        }
+    }
+    if (fresh && resume) {
+        throw new RuntimeError("INVALID_ARGS", "rescue does not allow --fresh and --resume together.", "rescue.parse");
+    }
+    if (explicitResumeTarget && trailingTokens?.length) {
+        throw new RuntimeError("INVALID_ARGS", "--resume only accepts a job-id or session-id. Use -r to resume the latest rescue session with a prompt.", "rescue.parse");
+    }
+    return {
+        background,
+        wait,
+        fresh,
+        resume,
+        resumeTarget,
+        model,
+        thinking,
+        prompt: trailingTokens?.join(" "),
+    };
+}
+export function parseJobLookupArgs(argv) {
+    let type;
+    let jobId;
+    let json = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--type") {
+            const value = argv[index + 1];
+            if (!value || !isManagedCommandType(value)) {
+                throw new RuntimeError("INVALID_ARGS", "--type requires one of review, challenge, rescue, review_gate, ask.", "args.parse");
+            }
+            type = value;
+            index += 1;
+            continue;
+        }
+        if (token === "--json") {
+            json = true;
+            continue;
+        }
+        if (token.startsWith("-")) {
+            throw new RuntimeError("INVALID_ARGS", `Unknown flag ${token}. Supported flags: --type <review|challenge|rescue|review_gate|ask>, --json.`, "args.parse");
+        }
+        if (jobId) {
+            throw new RuntimeError("INVALID_ARGS", "Only one optional job id may be supplied.", "args.parse");
+        }
+        jobId = token;
+    }
+    return {
+        jobId,
+        type,
+        json,
+    };
+}
+function isManagedCommandType(value) {
+    return (value === "review" ||
+        value === "challenge" ||
+        value === "rescue" ||
+        value === "review_gate" ||
+        value === "ask");
+}
+function parseKnownFlags(argv, knownFlags, commandName) {
+    let model;
+    let thinking = true;
+    let base;
+    let background = false;
+    let wait = false;
+    let trailingTokens;
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--") {
+            trailingTokens = argv.slice(index + 1);
+            break;
+        }
+        if (!knownFlags.has(token)) {
+            if (isRemovedThinkingFlag(token)) {
+                throw new RuntimeError("INVALID_ARGS", THINKING_FLAG_REMOVED_MESSAGE, "args.parse");
+            }
+            if (looksLikeFlag(token)) {
+                // Wrapper agents routinely hallucinate flags like `--file` /
+                // `--context` because that shape is common in other CLIs. Silently
+                // slurping them into focus text produced a bloated prompt that
+                // looked like a hang. Hard-fail with the supported list inline so
+                // the error message itself is the correction.
+                throw new RuntimeError("INVALID_ARGS", `Unknown flag ${token} for ${commandName}. Supported flags: --base <ref>, -m/--model <name>. Use \`--\` before flag-shaped focus text to pass it through.`, "args.parse");
+            }
+            trailingTokens = argv.slice(index);
+            break;
+        }
+        switch (token) {
+            case "-m":
+            case "--model": {
+                const value = argv[index + 1];
+                if (!value) {
+                    throw new RuntimeError("INVALID_ARGS", `${token} requires a model value.`, "args.parse");
+                }
+                if (value.startsWith("-")) {
+                    throw new RuntimeError("INVALID_ARGS", `${token} value cannot start with '-'; pass a model name`, "args.parse");
+                }
+                model = value;
+                index += 1;
+                break;
+            }
+            case "--base": {
+                const value = argv[index + 1];
+                if (!value) {
+                    throw new RuntimeError("INVALID_ARGS", "--base requires a ref value.", "args.parse");
+                }
+                if (value.startsWith("-")) {
+                    throw new RuntimeError("INVALID_ARGS", "--base value cannot start with '-'; pass a branch, tag, or commit ref.", "args.parse");
+                }
+                base = value;
+                index += 1;
+                break;
+            }
+            case "--background":
+                background = true;
+                break;
+            case "--wait":
+                wait = true;
+                break;
+            // The early `if (!knownFlags.has(token))` gate above means we only
+            // reach this switch with tokens that ARE in knownFlags, and every
+            // member is handled above. A `default` arm would be unreachable.
+            // --thinking and --no-thinking are NOT in knownFlags any more (v1.0
+            // removed them); the early gate above hard-fails on them with
+            // THINKING_FLAG_REMOVED_MESSAGE.
+        }
+    }
+    return {
+        base,
+        background,
+        wait,
+        model,
+        thinking,
+        trailingText: trailingTokens?.join(" "),
+    };
+}

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

@@ -0,0 +1,27 @@
+import { constants } from "node:fs";
+import { access, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { resolvePluginDataRoot } from "./plugin-data.js";
+export function resolvePluginPaths(env) {
+    const claudePluginData = resolvePluginDataRoot(env);
+    const pluginRoot = path.join(claudePluginData, "kimi-plugin-cc");
+    return {
+        claudePluginData,
+        pluginRoot,
+        stateDbPath: path.join(pluginRoot, "state.db"),
+        logsDir: path.join(pluginRoot, "logs"),
+        artifactsDir: path.join(pluginRoot, "artifacts"),
+        worktreesDir: path.join(pluginRoot, "worktrees"),
+        configPath: path.join(pluginRoot, "config.json"),
+    };
+}
+export async function ensurePluginPaths(paths) {
+    await mkdir(paths.pluginRoot, { recursive: true });
+    await mkdir(paths.logsDir, { recursive: true });
+    await mkdir(paths.artifactsDir, { recursive: true });
+    await access(paths.pluginRoot, constants.R_OK | constants.W_OK);
+    await access(paths.logsDir, constants.R_OK | constants.W_OK);
+    await access(paths.artifactsDir, constants.R_OK | constants.W_OK);
+    // worktreesDir is created lazily by the write-swarm path (not every command
+    // needs it), so it is intentionally NOT required here.
+}

package/plugins/kimi-codex/dist/plugin-data.js

@@ -0,0 +1,98 @@
+import { existsSync, lstatSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { RuntimeError } from "./errors.js";
+// Use the loaded module, not the shared PLUGIN_ROOT/CLAUDE_PLUGIN_ROOT variables.
+// Both source and compiled modules live one directory below the package root.
+const loadedPackageRoot = fileURLToPath(new URL("../", import.meta.url));
+/** Resolve state without silently trusting a different plugin's shared env. */
+export function resolvePluginDataRoot(env, packageRoot = loadedPackageRoot) {
+    const explicit = env.KIMI_PLUGIN_CC_DATA;
+    if (explicit !== undefined) {
+        if (!path.isAbsolute(explicit)) {
+            throw new RuntimeError("INVALID_PLUGIN_DATA", "KIMI_PLUGIN_CC_DATA must be an absolute directory path, not an empty or relative value.", "paths");
+        }
+        return path.normalize(explicit);
+    }
+    const expected = installedDataRoot(packageRoot);
+    const shared = [env.CLAUDE_PLUGIN_DATA, env.PLUGIN_DATA].filter((value) => Boolean(value));
+    if (expected) {
+        if (shared.some((value) => !path.isAbsolute(value) || !sameDataRoot(value, expected))) {
+            throw new RuntimeError("PLUGIN_DATA_CONFLICT", "Shared plugin data variables do not match this installation. Remove the conflicting variables or set KIMI_PLUGIN_CC_DATA to the intended Kimi data directory. No data was moved.", "paths", { details: { expected_data_root: expected, override_variable: "KIMI_PLUGIN_CC_DATA" } });
+        }
+        return expected;
+    }
+    // Checkout/custom launch compatibility: we cannot infer ownership from an
+    // arbitrary directory or from a marker that may not exist on first setup.
+    // Preserve the old location when unambiguous; require an explicit choice otherwise.
+    if (shared.length === 2 && !sameDataRoot(shared[0], shared[1])) {
+        throw new RuntimeError("PLUGIN_DATA_CONFLICT", "CLAUDE_PLUGIN_DATA and PLUGIN_DATA disagree. Set KIMI_PLUGIN_CC_DATA to the intended Kimi data directory before retrying. No data was moved.", "paths");
+    }
+    if (shared[0])
+        return shared[0];
+    if (env.KIMI_PLUGIN_CC_SHELL_LAUNCH === "1" && (env.CODEX_HOME || env.HOME)) {
+        const dataRoot = env.CODEX_HOME
+            ? path.join(env.CODEX_HOME, "plugins", "data")
+            : path.join(env.HOME, ".codex", "plugins", "data");
+        return path.join(dataRoot, "kimi-marketplace-kimi");
+    }
+    throw new RuntimeError("MISSING_PLUGIN_DATA", "Set KIMI_PLUGIN_CC_DATA to an absolute writable data directory. Custom launches may also use an unambiguous CLAUDE_PLUGIN_DATA or PLUGIN_DATA value.", "paths");
+}
+function installedDataRoot(packageRoot) {
+    const root = path.resolve(packageRoot);
+    const pluginDir = path.dirname(root);
+    const marketplaceDir = path.dirname(pluginDir);
+    const cacheDir = path.dirname(marketplaceDir);
+    const pluginsDir = path.dirname(cacheDir);
+    if (path.basename(pluginDir) !== "kimi" || path.basename(cacheDir) !== "cache" || path.basename(pluginsDir) !== "plugins") {
+        return undefined;
+    }
+    const marketplace = path.basename(marketplaceDir);
+    if (existsSync(path.join(root, ".codex-plugin", "plugin.json"))) {
+        return path.join(pluginsDir, "data", `${marketplace}-kimi`);
+    }
+    if (existsSync(path.join(root, ".claude-plugin", "plugin.json"))) {
+        // Claude documents plugin-id sanitization for persistent data directories.
+        const id = `kimi@${marketplace}`.replace(/[^a-zA-Z0-9_-]/g, "-");
+        return path.join(pluginsDir, "data", id);
+    }
+    return undefined;
+}
+function sameDataRoot(left, right) {
+    if (path.resolve(left) === path.resolve(right))
+        return true;
+    const canonicalLeft = canonicalDataRoot(left);
+    return canonicalLeft !== undefined && canonicalLeft === canonicalDataRoot(right);
+}
+/** Resolve existing ancestors without creating a first-run data directory. */
+function canonicalDataRoot(value) {
+    let cursor = path.resolve(value);
+    const missing = [];
+    for (;;) {
+        try {
+            const resolved = realpathSync(cursor);
+            if (missing.length > 0 && !statSync(cursor).isDirectory())
+                return undefined;
+            return path.join(resolved, ...missing);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                return undefined;
+            // ENOENT can also mean a dangling symlink. Do not treat an existing
+            // link as a missing directory and accidentally bypass its destination.
+            try {
+                lstatSync(cursor);
+                return undefined;
+            }
+            catch (statError) {
+                if (statError.code !== "ENOENT")
+                    return undefined;
+            }
+            const parent = path.dirname(cursor);
+            if (parent === cursor)
+                return undefined;
+            missing.unshift(path.basename(cursor));
+            cursor = parent;
+        }
+    }
+}