larkin 0.2.70

package/dist/runtime/runtime-model-catalog.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CURRENT_RUNTIME_MODELS = void 0;
+// Larkin supports exactly these three native Runtime adapters. Pi, Codex and Claude replace
+// these placeholders/fallbacks at runtime with their machine-readable catalogs.
+// Claude's supported stdin control-channel list is the live authority; its entries below
+// remain explicit compatibility candidates for config loading and discovery failures.
+exports.CURRENT_RUNTIME_MODELS = {
+    codex: [
+        { id: "default", label: "default", verified: "dynamic" },
+        { id: "gpt-5.6-sol", label: "GPT-5.6 Sol · 静态兼容目录", supportedReasoningEfforts: ["low", "medium", "high", "xhigh", "max", "ultra"], defaultReasoningEffort: "low", verified: "authored-compatibility" },
+        { id: "gpt-5.6-terra", label: "GPT-5.6 Terra · 静态兼容目录", supportedReasoningEfforts: ["low", "medium", "high", "xhigh", "max", "ultra"], defaultReasoningEffort: "medium", verified: "authored-compatibility" },
+        { id: "gpt-5.6-luna", label: "GPT-5.6 Luna · 静态兼容目录", supportedReasoningEfforts: ["low", "medium", "high", "xhigh", "max"], defaultReasoningEffort: "medium", verified: "authored-compatibility" },
+        { id: "gpt-5.5", label: "GPT-5.5 · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.4", label: "GPT-5.4 · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.4-mini", label: "GPT-5.4 Mini · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.3-codex", label: "GPT-5.3 Codex · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.3-codex-spark", label: "GPT-5.3 Codex Spark · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.2-codex", label: "GPT-5.2 Codex · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.2", label: "GPT-5.2 · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.1-codex-max", label: "GPT-5.1 Codex Max · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.1-codex", label: "GPT-5.1 Codex · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5-codex", label: "GPT-5 Codex · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5", label: "GPT-5 · 静态兼容目录", verified: "authored-compatibility" },
+    ],
+    claude: [
+        { id: "default", label: "default", verified: "dynamic" },
+        { id: "opus", label: "Claude Opus · 静态候选", verified: "authored-candidate" },
+        { id: "opus[1m]", label: "Claude Opus 1M · 静态候选", verified: "authored-candidate" },
+        { id: "fable", label: "Claude Fable · 静态候选", verified: "authored-candidate" },
+        { id: "sonnet", label: "Claude Sonnet · 静态候选", verified: "authored-candidate" },
+        { id: "haiku", label: "Claude Haiku · 静态候选", verified: "authored-candidate" },
+        { id: "claude-opus-4-8", label: "Claude Opus 4.8 · 静态候选", verified: "authored-candidate" },
+        { id: "claude-opus-4-7", label: "Claude Opus 4.7 · 静态候选", verified: "authored-candidate" },
+        { id: "claude-opus-4-6", label: "Claude Opus 4.6 · 静态候选", verified: "authored-candidate" },
+        { id: "claude-fable-5", label: "Claude Fable 5 · 静态候选", verified: "authored-candidate" },
+        { id: "claude-fable-5[1m]", label: "Claude Fable 5 1M · 静态候选", verified: "authored-candidate" },
+        { id: "claude-sonnet-5", label: "Claude Sonnet 5 · 静态候选", verified: "authored-candidate" },
+        { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6 · 静态候选", verified: "authored-candidate" },
+        { id: "claude-haiku-4-5", label: "Claude Haiku 4.5 · 静态候选", verified: "authored-candidate" },
+    ],
+    pi: [{ id: "default", label: "default", verified: "dynamic" }],
+};

package/dist/runtime/runtime-model-catalog.mjs

@@ -0,0 +1,40 @@
+// Larkin supports exactly these three native Runtime adapters. Pi, Codex and Claude replace
+// these placeholders/fallbacks at runtime with their machine-readable catalogs.
+// Claude's supported stdin control-channel list is the live authority; its entries below
+// remain explicit compatibility candidates for config loading and discovery failures.
+export const CURRENT_RUNTIME_MODELS = {
+    codex: [
+        { id: "default", label: "default", verified: "dynamic" },
+        { id: "gpt-5.6-sol", label: "GPT-5.6 Sol · 静态兼容目录", supportedReasoningEfforts: ["low", "medium", "high", "xhigh", "max", "ultra"], defaultReasoningEffort: "low", verified: "authored-compatibility" },
+        { id: "gpt-5.6-terra", label: "GPT-5.6 Terra · 静态兼容目录", supportedReasoningEfforts: ["low", "medium", "high", "xhigh", "max", "ultra"], defaultReasoningEffort: "medium", verified: "authored-compatibility" },
+        { id: "gpt-5.6-luna", label: "GPT-5.6 Luna · 静态兼容目录", supportedReasoningEfforts: ["low", "medium", "high", "xhigh", "max"], defaultReasoningEffort: "medium", verified: "authored-compatibility" },
+        { id: "gpt-5.5", label: "GPT-5.5 · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.4", label: "GPT-5.4 · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.4-mini", label: "GPT-5.4 Mini · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.3-codex", label: "GPT-5.3 Codex · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.3-codex-spark", label: "GPT-5.3 Codex Spark · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.2-codex", label: "GPT-5.2 Codex · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.2", label: "GPT-5.2 · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.1-codex-max", label: "GPT-5.1 Codex Max · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5.1-codex", label: "GPT-5.1 Codex · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5-codex", label: "GPT-5 Codex · 静态兼容目录", verified: "authored-compatibility" },
+        { id: "gpt-5", label: "GPT-5 · 静态兼容目录", verified: "authored-compatibility" },
+    ],
+    claude: [
+        { id: "default", label: "default", verified: "dynamic" },
+        { id: "opus", label: "Claude Opus · 静态候选", verified: "authored-candidate" },
+        { id: "opus[1m]", label: "Claude Opus 1M · 静态候选", verified: "authored-candidate" },
+        { id: "fable", label: "Claude Fable · 静态候选", verified: "authored-candidate" },
+        { id: "sonnet", label: "Claude Sonnet · 静态候选", verified: "authored-candidate" },
+        { id: "haiku", label: "Claude Haiku · 静态候选", verified: "authored-candidate" },
+        { id: "claude-opus-4-8", label: "Claude Opus 4.8 · 静态候选", verified: "authored-candidate" },
+        { id: "claude-opus-4-7", label: "Claude Opus 4.7 · 静态候选", verified: "authored-candidate" },
+        { id: "claude-opus-4-6", label: "Claude Opus 4.6 · 静态候选", verified: "authored-candidate" },
+        { id: "claude-fable-5", label: "Claude Fable 5 · 静态候选", verified: "authored-candidate" },
+        { id: "claude-fable-5[1m]", label: "Claude Fable 5 1M · 静态候选", verified: "authored-candidate" },
+        { id: "claude-sonnet-5", label: "Claude Sonnet 5 · 静态候选", verified: "authored-candidate" },
+        { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6 · 静态候选", verified: "authored-candidate" },
+        { id: "claude-haiku-4-5", label: "Claude Haiku 4.5 · 静态候选", verified: "authored-candidate" },
+    ],
+    pi: [{ id: "default", label: "default", verified: "dynamic" }],
+};

package/dist/runtime/runtime-readiness.cjs

@@ -0,0 +1,177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimePrerequisiteError = void 0;
+exports.providerAuthenticationFailureReadiness = providerAuthenticationFailureReadiness;
+exports.resolveRuntimeExecutable = resolveRuntimeExecutable;
+exports.classifyRuntimePrerequisite = classifyRuntimePrerequisite;
+exports.probeNativeRuntimeReadiness = probeNativeRuntimeReadiness;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const pi_provider_config_js_1 = require("./pi-provider-config.cjs");
+function safeProviderLabel(value) {
+    const provider = typeof value === "string" ? value.trim() : "";
+    return /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/.test(provider) ? provider : null;
+}
+function providerAuthenticationFailureReadiness(runtime, provider) {
+    const label = safeProviderLabel(provider);
+    return {
+        runtime,
+        state: "unauthenticated",
+        reason: label
+            ? `Provider ${label} API-key authentication failed during a Runtime turn.`
+            : "Configured provider API-key authentication failed during a Runtime turn.",
+        nextAction: "Check the provider login or API-key resolver command, then retry the Agent turn.",
+    };
+}
+class RuntimePrerequisiteError extends Error {
+    readiness;
+    constructor(readiness) {
+        super(readiness.reason || `${readiness.runtime} runtime is ${readiness.state}`);
+        this.readiness = readiness;
+        this.name = "RuntimePrerequisiteError";
+    }
+}
+exports.RuntimePrerequisiteError = RuntimePrerequisiteError;
+function resolveRuntimeExecutable(command, env = process.env) {
+    const value = command.trim();
+    if (!value || /[\r\n\0]/.test(value))
+        return null;
+    const candidates = value.includes(node_path_1.default.sep)
+        ? [node_path_1.default.resolve(value)]
+        : String(env.PATH || "").split(node_path_1.default.delimiter).filter(Boolean).map((directory) => node_path_1.default.join(directory, value));
+    return candidates.find((candidate) => {
+        try {
+            node_fs_1.default.accessSync(candidate, node_fs_1.default.constants.X_OK);
+            return node_fs_1.default.statSync(candidate).isFile();
+        }
+        catch {
+            return false;
+        }
+    }) ?? null;
+}
+function classifyRuntimePrerequisite(runtime, error, executable) {
+    const reason = (error instanceof Error ? error.message : String(error)).replace(/[\r\n]+/g, " ").slice(0, 500);
+    if (/ENOENT|not found|no such file|spawn .* failed/i.test(reason))
+        return {
+            runtime, state: "missing", ...(executable ? { executable } : {}), reason,
+            nextAction: runtime === "pi" ? "Install Pi and ensure `pi` is on PATH, or set LARKIN_PI_COMMAND." : `Install ${runtime} and ensure it is on PATH.`,
+        };
+    if (/no authenticated available models|login|credential|unauthenticated|unauthorized|oauth/i.test(reason))
+        return {
+            runtime, state: "unauthenticated", ...(executable ? { executable } : {}), reason,
+            nextAction: runtime === "pi" ? "Run the official `pi` login flow, then retry." : `Authenticate ${runtime}, then retry.`,
+        };
+    if (/protocol (?:version )?(?:mismatch|unsupported|incompatible)|unsupported (?:rpc|protocol|schema)|schema (?:mismatch|incompatible)|requires (?:a )?newer version/i.test(reason))
+        return {
+            runtime, state: "incompatible", ...(executable ? { executable } : {}), reason,
+            nextAction: runtime === "pi" ? "Upgrade local Pi to a version that supports the documented RPC protocol." : `Upgrade ${runtime}, then retry.`,
+        };
+    if (/timeout|timed out|unexpected EOF|\bEOF\b|TLS|ECONNRESET|socket hang up|network|temporar(?:y|ily)|unavailable/i.test(reason))
+        return {
+            runtime, state: "unavailable", ...(executable ? { executable } : {}), reason,
+            nextAction: `Retry ${runtime}; Larkin will use its bounded Runtime recreate/backoff policy.`,
+        };
+    return {
+        runtime, state: "unavailable", ...(executable ? { executable } : {}), reason,
+        nextAction: `Retry ${runtime}; the failure is not proven to be a protocol incompatibility.`,
+    };
+}
+function selectedCommand(options) {
+    if (options.command)
+        return options.command;
+    if (options.runtime === "pi")
+        return options.env?.LARKIN_PI_COMMAND || process.env.LARKIN_PI_COMMAND || "pi";
+    if (options.runtime === "codex")
+        return options.env?.LARKIN_CODEX_COMMAND || process.env.LARKIN_CODEX_COMMAND || "codex";
+    return options.env?.LARKIN_CLAUDE_COMMAND || process.env.LARKIN_CLAUDE_COMMAND || "claude";
+}
+function executableVersion(executable, env) {
+    const result = (0, node_child_process_1.spawnSync)(executable, ["--version"], { env, encoding: "utf8", timeout: 5_000, maxBuffer: 64 * 1024 });
+    if (result.status !== 0)
+        return undefined;
+    return String(result.stdout || result.stderr || "").replace(/[\r\n]+/g, " ").trim().slice(0, 120) || undefined;
+}
+/** Resolve and handshake through each runtime's structured native control protocol. */
+async function probeNativeRuntimeReadiness(options) {
+    const env = { ...process.env, ...options.env };
+    if (options.runtime === "pi" && env.LARKIN_PI_DISTRIBUTION === "builtin") {
+        try {
+            if (!options.agentId || !env.LARKIN_CONFIG_DIR)
+                throw new Error("内置 Pi readiness 缺少 Agent/config identity");
+            (0, pi_provider_config_js_1.assertBuiltinPiAgentDirectory)((0, pi_provider_config_js_1.piAgentDirectory)(env.LARKIN_CONFIG_DIR, options.agentId));
+            return { runtime: "pi", state: "ready", executable: process.execPath, version: `official-pi ${pi_provider_config_js_1.BUNDLED_PI_VERSION} (bundled)` };
+        }
+        catch (error) {
+            return { runtime: "pi", state: "unauthenticated", reason: error instanceof Error ? error.message : String(error),
+                nextAction: "重新运行 larkin setup，选择内置 Pi 并配置有效 API Key。" };
+        }
+    }
+    const command = selectedCommand(options);
+    const executable = resolveRuntimeExecutable(command, env);
+    if (!executable)
+        return {
+            runtime: options.runtime, state: "missing",
+            reason: `${command} executable was not found`,
+            nextAction: options.runtime === "pi"
+                ? "Install Pi and ensure `pi` is on PATH, or set LARKIN_PI_COMMAND."
+                : `Install ${options.runtime} and ensure it is on PATH.`,
+        };
+    const version = executableVersion(executable, env);
+    try {
+        if (options.runtime === "pi") {
+            const { discoverPiModelCatalog } = await Promise.resolve().then(() => __importStar(require("./pi-model-catalog.cjs")));
+            await discoverPiModelCatalog({ cwd: options.cwd, command: executable, env });
+        }
+        else if (options.runtime === "codex") {
+            const { discoverCodexModelCatalog } = await Promise.resolve().then(() => __importStar(require("./codex-model-catalog.cjs")));
+            await discoverCodexModelCatalog({ cwd: options.cwd, command: executable, env });
+        }
+        else {
+            const { discoverClaudeModelCatalog } = await Promise.resolve().then(() => __importStar(require("./claude-model-catalog.cjs")));
+            await discoverClaudeModelCatalog({ cwd: options.cwd, command: executable, env });
+        }
+        return { runtime: options.runtime, state: "ready", executable, ...(version ? { version } : {}) };
+    }
+    catch (error) {
+        const classified = error instanceof RuntimePrerequisiteError ? error.readiness
+            : classifyRuntimePrerequisite(options.runtime, error, executable);
+        return { ...classified, executable, ...(version ? { version } : {}) };
+    }
+}

package/dist/runtime/runtime-readiness.mjs

@@ -0,0 +1,133 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { assertBuiltinPiAgentDirectory, BUNDLED_PI_VERSION, piAgentDirectory } from "./pi-provider-config.mjs";
+function safeProviderLabel(value) {
+    const provider = typeof value === "string" ? value.trim() : "";
+    return /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/.test(provider) ? provider : null;
+}
+export function providerAuthenticationFailureReadiness(runtime, provider) {
+    const label = safeProviderLabel(provider);
+    return {
+        runtime,
+        state: "unauthenticated",
+        reason: label
+            ? `Provider ${label} API-key authentication failed during a Runtime turn.`
+            : "Configured provider API-key authentication failed during a Runtime turn.",
+        nextAction: "Check the provider login or API-key resolver command, then retry the Agent turn.",
+    };
+}
+export class RuntimePrerequisiteError extends Error {
+    readiness;
+    constructor(readiness) {
+        super(readiness.reason || `${readiness.runtime} runtime is ${readiness.state}`);
+        this.readiness = readiness;
+        this.name = "RuntimePrerequisiteError";
+    }
+}
+export function resolveRuntimeExecutable(command, env = process.env) {
+    const value = command.trim();
+    if (!value || /[\r\n\0]/.test(value))
+        return null;
+    const candidates = value.includes(path.sep)
+        ? [path.resolve(value)]
+        : String(env.PATH || "").split(path.delimiter).filter(Boolean).map((directory) => path.join(directory, value));
+    return candidates.find((candidate) => {
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            return fs.statSync(candidate).isFile();
+        }
+        catch {
+            return false;
+        }
+    }) ?? null;
+}
+export function classifyRuntimePrerequisite(runtime, error, executable) {
+    const reason = (error instanceof Error ? error.message : String(error)).replace(/[\r\n]+/g, " ").slice(0, 500);
+    if (/ENOENT|not found|no such file|spawn .* failed/i.test(reason))
+        return {
+            runtime, state: "missing", ...(executable ? { executable } : {}), reason,
+            nextAction: runtime === "pi" ? "Install Pi and ensure `pi` is on PATH, or set LARKIN_PI_COMMAND." : `Install ${runtime} and ensure it is on PATH.`,
+        };
+    if (/no authenticated available models|login|credential|unauthenticated|unauthorized|oauth/i.test(reason))
+        return {
+            runtime, state: "unauthenticated", ...(executable ? { executable } : {}), reason,
+            nextAction: runtime === "pi" ? "Run the official `pi` login flow, then retry." : `Authenticate ${runtime}, then retry.`,
+        };
+    if (/protocol (?:version )?(?:mismatch|unsupported|incompatible)|unsupported (?:rpc|protocol|schema)|schema (?:mismatch|incompatible)|requires (?:a )?newer version/i.test(reason))
+        return {
+            runtime, state: "incompatible", ...(executable ? { executable } : {}), reason,
+            nextAction: runtime === "pi" ? "Upgrade local Pi to a version that supports the documented RPC protocol." : `Upgrade ${runtime}, then retry.`,
+        };
+    if (/timeout|timed out|unexpected EOF|\bEOF\b|TLS|ECONNRESET|socket hang up|network|temporar(?:y|ily)|unavailable/i.test(reason))
+        return {
+            runtime, state: "unavailable", ...(executable ? { executable } : {}), reason,
+            nextAction: `Retry ${runtime}; Larkin will use its bounded Runtime recreate/backoff policy.`,
+        };
+    return {
+        runtime, state: "unavailable", ...(executable ? { executable } : {}), reason,
+        nextAction: `Retry ${runtime}; the failure is not proven to be a protocol incompatibility.`,
+    };
+}
+function selectedCommand(options) {
+    if (options.command)
+        return options.command;
+    if (options.runtime === "pi")
+        return options.env?.LARKIN_PI_COMMAND || process.env.LARKIN_PI_COMMAND || "pi";
+    if (options.runtime === "codex")
+        return options.env?.LARKIN_CODEX_COMMAND || process.env.LARKIN_CODEX_COMMAND || "codex";
+    return options.env?.LARKIN_CLAUDE_COMMAND || process.env.LARKIN_CLAUDE_COMMAND || "claude";
+}
+function executableVersion(executable, env) {
+    const result = spawnSync(executable, ["--version"], { env, encoding: "utf8", timeout: 5_000, maxBuffer: 64 * 1024 });
+    if (result.status !== 0)
+        return undefined;
+    return String(result.stdout || result.stderr || "").replace(/[\r\n]+/g, " ").trim().slice(0, 120) || undefined;
+}
+/** Resolve and handshake through each runtime's structured native control protocol. */
+export async function probeNativeRuntimeReadiness(options) {
+    const env = { ...process.env, ...options.env };
+    if (options.runtime === "pi" && env.LARKIN_PI_DISTRIBUTION === "builtin") {
+        try {
+            if (!options.agentId || !env.LARKIN_CONFIG_DIR)
+                throw new Error("内置 Pi readiness 缺少 Agent/config identity");
+            assertBuiltinPiAgentDirectory(piAgentDirectory(env.LARKIN_CONFIG_DIR, options.agentId));
+            return { runtime: "pi", state: "ready", executable: process.execPath, version: `official-pi ${BUNDLED_PI_VERSION} (bundled)` };
+        }
+        catch (error) {
+            return { runtime: "pi", state: "unauthenticated", reason: error instanceof Error ? error.message : String(error),
+                nextAction: "重新运行 larkin setup，选择内置 Pi 并配置有效 API Key。" };
+        }
+    }
+    const command = selectedCommand(options);
+    const executable = resolveRuntimeExecutable(command, env);
+    if (!executable)
+        return {
+            runtime: options.runtime, state: "missing",
+            reason: `${command} executable was not found`,
+            nextAction: options.runtime === "pi"
+                ? "Install Pi and ensure `pi` is on PATH, or set LARKIN_PI_COMMAND."
+                : `Install ${options.runtime} and ensure it is on PATH.`,
+        };
+    const version = executableVersion(executable, env);
+    try {
+        if (options.runtime === "pi") {
+            const { discoverPiModelCatalog } = await import("./pi-model-catalog.mjs");
+            await discoverPiModelCatalog({ cwd: options.cwd, command: executable, env });
+        }
+        else if (options.runtime === "codex") {
+            const { discoverCodexModelCatalog } = await import("./codex-model-catalog.mjs");
+            await discoverCodexModelCatalog({ cwd: options.cwd, command: executable, env });
+        }
+        else {
+            const { discoverClaudeModelCatalog } = await import("./claude-model-catalog.mjs");
+            await discoverClaudeModelCatalog({ cwd: options.cwd, command: executable, env });
+        }
+        return { runtime: options.runtime, state: "ready", executable, ...(version ? { version } : {}) };
+    }
+    catch (error) {
+        const classified = error instanceof RuntimePrerequisiteError ? error.readiness
+            : classifyRuntimePrerequisite(options.runtime, error, executable);
+        return { ...classified, executable, ...(version ? { version } : {}) };
+    }
+}