larkin 0.4.28 → 0.5.0

package/dist/runtime/runtime-host.mjs

@@ -6,7 +6,7 @@ import { auditReminderDelivery } from "../agent/reminder-delivery-audit.mjs";
 import { isCanonicalInboxTarget, targetKeyOfInboxEnvelope } from "../agent/inbox-projection.mjs";
 import { SpanKind } from "@opentelemetry/api";
 import { buildStrictProviderErrorInput, classifyStrictProviderError } from "./provider-error-classifier.mjs";
-import { classifyRuntimePrerequisite, providerAuthenticationFailureReadiness, RuntimePrerequisiteError, } from "./runtime-readiness.mjs";
+import { authFailureAppliesTo, classifyPiMissingCredentialRejection, classifyRuntimePrerequisite, configuredProviderId, missingProviderCredentialReadiness, parsePersistedAuthFailure, providerAuthenticationFailureReadiness, readinessForPersistedAuthFailure, safeProviderId, RuntimePrerequisiteError, } from "./runtime-readiness.mjs";
 import { resolveOfficialLarkCli } from "../app/official-lark-cli.mjs";
 import { assertAgentWorkspaceBound, managedLarkCliEnv } from "../app/agent-lark-cli-workspace.mjs";
 import { isPiNativeCompactionRequired, PiCompactionBreaker, PiCompactionRecoveryMachine, } from "./pi-compaction-recovery.mjs";
@@ -93,6 +93,107 @@ function persistPreviousSession(agent, previous) {
         // In-memory ref still holds for this process; restart will miss it only if this write failed.
     }
 }
+function authFailureScopeOf(agent) {
+    return {
+        runtime: agent.config.runtime,
+        model: agent.config.model,
+        adapterId: agent.adapter.id,
+    };
+}
+function currentAuthFailure(agent) {
+    if (!agent.authFailureActive)
+        return null;
+    const runtime = agent.adapter.id === "codex" || agent.adapter.id === "claude" || agent.adapter.id === "pi"
+        ? agent.adapter.id : null;
+    if (!runtime)
+        return null;
+    return {
+        kind: agent.authFailureKind === "missing-provider" ? "missing-provider" : "generic",
+        runtime,
+        provider: agent.authFailureProvider,
+    };
+}
+function genericAuthProvider(agent, upstream) {
+    return safeProviderId(upstream?.provider) ?? configuredProviderId(agent.config.model);
+}
+function persistAuthFailure(agent) {
+    const store = agent.stateStore;
+    if (!store)
+        return;
+    try {
+        const write = () => {
+            const current = store.readJson("agentState", { sessions: {} });
+            if (Array.isArray(current.records) && !("sessions" in current))
+                return;
+            const { authFailureProvider: _legacy, authFailure: _scoped, ...rest } = current;
+            const failure = currentAuthFailure(agent);
+            if (!failure) {
+                if (!("authFailureProvider" in current) && !("authFailure" in current))
+                    return;
+                store.writeJson("agentState", rest);
+                return;
+            }
+            store.writeJson("agentState", {
+                ...rest,
+                authFailure: failure,
+                ...(failure.kind === "missing-provider" && failure.provider
+                    ? { authFailureProvider: failure.provider } : {}),
+            });
+        };
+        if (store.withInboxTransaction)
+            store.withInboxTransaction(write);
+        else
+            write();
+    }
+    catch {
+        // In-memory flags and the delivery ledger still hold for this process.
+    }
+}
+function loadPersistedAuthFailure(store) {
+    if (!store)
+        return null;
+    try {
+        return parsePersistedAuthFailure(store.readJson("agentState", {}));
+    }
+    catch {
+        return null;
+    }
+}
+function applyAuthFailure(agent, failure) {
+    agent.authFailureActive = true;
+    agent.authFailureKind = failure.kind;
+    agent.authFailureProvider = failure.provider ?? null;
+    agent.readiness = readinessForPersistedAuthFailure(failure);
+}
+function clearAuthFailure(agent, persist = true) {
+    agent.authFailureActive = false;
+    agent.authFailureKind = null;
+    agent.authFailureProvider = null;
+    if (persist)
+        persistAuthFailure(agent);
+}
+function restoreAuthFailure(agent) {
+    const persisted = loadPersistedAuthFailure(agent.stateStore);
+    if (!persisted)
+        return;
+    // 只恢复仍绑定当前 candidate 的当前作用域 auth；不从历史 delivery 回灌。
+    if (!authFailureAppliesTo(authFailureScopeOf(agent), persisted)) {
+        clearAuthFailure(agent);
+        return;
+    }
+    applyAuthFailure(agent, persisted);
+}
+function clearLedgerAuthProviders(agent) {
+    let changed = false;
+    for (const record of agent.records.values()) {
+        if (!record.authProvider)
+            continue;
+        delete record.authProvider;
+        changed = true;
+    }
+    if (changed)
+        persist(agent);
+}
 const REPLAY_FAILURE_CODES = new Set([
     "canonical_inbox_row_missing", "canonical_inbox_malformed", "duplicate_message_id",
     "inbox_state_conflict", "delivery_target_conflict", "structured_target_invalid",
@@ -219,7 +320,6 @@ export function createRuntimeHost(options) {
             } : {}),
             LARKIN_CONFIG_DIR: process.env.LARKIN_CONFIG_DIR,
             LARKIN_HOME: process.env.LARKIN_HOME,
-            ...(config.piDistribution ? { LARKIN_PI_DISTRIBUTION: config.piDistribution } : {}),
             LARKIN_STATE_DIR: effectivePiStateDir(config),
             ...(process.env.HOME ? { HOME: process.env.HOME } : {}),
             ...(process.env.SHELL ? { SHELL: process.env.SHELL } : {}),
@@ -481,6 +581,25 @@ export function createRuntimeHost(options) {
                 messageId: record.messageId, status: "consumed" });
         }
     };
+    const projectAuthFailure = (agent, readiness, failure) => {
+        agent.authFailureActive = true;
+        agent.authFailureKind = failure.kind;
+        agent.authFailureProvider = failure.provider;
+        agent.readiness = {
+            ...readiness,
+            ...(agent.readiness?.executable ? { executable: agent.readiness.executable } : {}),
+            ...(agent.readiness?.version ? { version: agent.readiness.version } : {}),
+        };
+        persistAuthFailure(agent);
+        emit({ type: "agent-status", agentId: agent.config.agentId, status: "error",
+            error: `${agent.readiness.reason} ${agent.readiness.nextAction}`, readiness: agent.readiness });
+    };
+    const namedAuthProviderPresent = (agent) => {
+        if (agent.authFailureKind !== "missing-provider" || !agent.authFailureProvider)
+            return true;
+        const failure = currentAuthFailure(agent);
+        return Boolean(failure && authFailureAppliesTo(authFailureScopeOf(agent), failure));
+    };
     const resultFor = (agent, record, result) => {
         if (result.status === "accepted") {
             if (record.errorCategory !== "context_window") {
@@ -494,6 +613,28 @@ export function createRuntimeHost(options) {
                     deliveryId: record.deliveryId, messageId: record.messageId, status: "accepted" });
             return { status: "accepted", deliveryId: record.deliveryId };
         }
+        const missing = result.status === "rejected" && agent.adapter.id === "pi"
+            ? classifyPiMissingCredentialRejection(result.reason)
+            : null;
+        if (missing) {
+            const readiness = missingProviderCredentialReadiness(agent.adapter.id, missing.provider);
+            const reason = readiness.reason ?? result.reason;
+            if (record.status !== "error") {
+                record.reason = reason;
+                record.retryable = false;
+                record.errorCategory = "auth";
+                record.authProvider = missing.provider;
+                const finalRecord = setRecord(agent, record, "error");
+                if (finalRecord.status !== "consumed")
+                    emit({ type: "delivery", agentId: agent.config.agentId,
+                        deliveryId: record.deliveryId, messageId: record.messageId, status: "error", reason });
+                projectAuthFailure(agent, readiness, { kind: "missing-provider", provider: missing.provider });
+            }
+            return { status: "error", deliveryId: record.deliveryId, reason: record.reason ?? reason, retryable: false };
+        }
+        if (record.status === "error") {
+            return { status: "error", deliveryId: record.deliveryId, reason: record.reason ?? result.reason, retryable: false };
+        }
         if (record.errorCategory !== "context_window")
             delete record.errorCategory;
         const retryable = result.status === "deferred" || result.retryable;
@@ -1338,7 +1479,7 @@ export function createRuntimeHost(options) {
                     agent.compactionMachines.delete(inputId);
             }
             const recoveredAuthentication = agent.authFailureActive && agent.turnInProgress
-                && agent.turnHadAuthenticatedOutput && !agent.turnHadFailure;
+                && agent.turnHadAuthenticatedOutput && !agent.turnHadFailure && namedAuthProviderPresent(agent);
             agent.turnInProgress = false;
             agent.busy = false;
             emit({ type: "activity", agentId: agent.config.agentId, activity: "idle", activityKind: "idle", detailKind: "turn_ended" });
@@ -1360,7 +1501,8 @@ export function createRuntimeHost(options) {
             reconcileSubagentLedger(agent);
             telemetry?.runtimeEvent(agent.config.agentId, event);
             if (recoveredAuthentication) {
-                agent.authFailureActive = false;
+                clearAuthFailure(agent);
+                clearLedgerAuthProviders(agent);
                 const prior = agent.readiness;
                 agent.readiness = {
                     runtime: agent.adapter.id,
@@ -1453,23 +1595,30 @@ export function createRuntimeHost(options) {
                 record.errorCategory = classifiedCategory;
             else
                 delete record.errorCategory;
-            const finalRecord = setRecord(agent, record, event.retryable ? "pending" : "error");
+            const missing = agent.adapter.id === "pi"
+                ? classifyPiMissingCredentialRejection(event.upstream?.message)
+                    ?? classifyPiMissingCredentialRejection(event.message)
+                : null;
+            if (missing) {
+                record.retryable = false;
+                record.errorCategory = "auth";
+                record.authProvider = missing.provider;
+            }
+            const terminal = Boolean(missing) || !event.retryable;
+            const finalRecord = setRecord(agent, record, terminal ? "error" : "pending");
             if (finalRecord.status !== "consumed")
                 emit({ type: "delivery", agentId: agent.config.agentId,
                     deliveryId: record.deliveryId, messageId: record.messageId,
-                    status: event.retryable ? "deferred" : "error", reason: event.message });
-            if (event.errorCategory === "auth" && !event.retryable) {
+                    status: terminal ? "error" : "deferred", reason: event.message });
+            if (missing) {
+                const readiness = missingProviderCredentialReadiness(agent.adapter.id, missing.provider);
+                projectAuthFailure(agent, readiness, { kind: "missing-provider", provider: missing.provider });
+            }
+            else if (event.errorCategory === "auth" && !event.retryable) {
                 const readiness = providerAuthenticationFailureReadiness(agent.adapter.id, event.upstream?.provider);
-                agent.authFailureActive = true;
-                agent.readiness = {
-                    ...readiness,
-                    ...(agent.readiness?.executable ? { executable: agent.readiness.executable } : {}),
-                    ...(agent.readiness?.version ? { version: agent.readiness.version } : {}),
-                };
-                emit({ type: "agent-status", agentId: agent.config.agentId, status: "error",
-                    error: `${agent.readiness.reason} ${agent.readiness.nextAction}`, readiness: agent.readiness });
+                projectAuthFailure(agent, readiness, { kind: "generic", provider: genericAuthProvider(agent, event.upstream) });
             }
-            if (event.retryable && !agent.busy && !agent.turnInProgress)
+            if (!terminal && event.retryable && !agent.busy && !agent.turnInProgress)
                 void retryPending(agent);
         }
         else if (event.type === "configuration-error") {
@@ -1739,14 +1888,26 @@ export function createRuntimeHost(options) {
                         clearTimeout(previous.backgroundCompletionRetryTimer);
                     if (previous.subagentReconcileTimer)
                         clearInterval(previous.subagentReconcileTimer);
+                    const previousFailure = currentAuthFailure(previous);
+                    const scoped = Boolean(previousFailure
+                        && authFailureAppliesTo({
+                            runtime: config.runtime,
+                            model: config.model,
+                            adapterId: adapter.id,
+                        }, previousFailure));
                     const candidate = {
                         ...previous, config, adapter, session, launchId: crypto.randomUUID(), busy: false, submitting: false,
                         starting: null, retryAfterSubmit: false, generation: 0, poller: null, retryTimer: null,
                         recreateAttempts: 0, stabilityTimer: null, recreateReason: null, stopped: false,
                         backgroundCompletionRetryTimer: null, subagentReconcileTimer: null,
                         disabledReason: null, configurationRecovery: null,
-                        readiness: previous.authFailureActive ? previous.readiness : readiness,
+                        authFailureActive: scoped && previous.authFailureActive,
+                        authFailureKind: scoped ? previous.authFailureKind : null,
+                        authFailureProvider: scoped ? previous.authFailureProvider : null,
+                        readiness: scoped && previous.authFailureActive ? previous.readiness : readiness,
                     };
+                    if (previous.authFailureActive && !candidate.authFailureActive)
+                        clearAuthFailure(candidate);
                     managed.set(config.agentId, candidate);
                     session.subscribe((event) => observe(candidate, session, event));
                     if (session.sessionId) {
@@ -1841,7 +2002,8 @@ export function createRuntimeHost(options) {
                 agent.config.sessionId = null;
                 agent.session = fresh;
                 persistPreviousSession(agent, previousRef);
-                agent.readiness = readiness;
+                if (!agent.authFailureActive)
+                    agent.readiness = readiness;
                 agent.disabledReason = null;
             };
             try {
@@ -1862,7 +2024,13 @@ export function createRuntimeHost(options) {
                     ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}),
                     ...(agent.previousSession ? { previousSession: agent.previousSession } : {}) });
             }
-            emit({ type: "agent-status", agentId, status: "active", readiness });
+            emit({
+                type: "agent-status",
+                agentId,
+                status: agent.authFailureActive ? "error" : "active",
+                ...(agent.authFailureActive ? { error: `${agent.readiness?.reason} ${agent.readiness?.nextAction}` } : {}),
+                readiness: agent.authFailureActive ? agent.readiness ?? readiness : readiness,
+            });
             agent.piSessionOwner = probeEnv[PI_SUBAGENT_SESSION_OWNER_ENV];
             await oldSession.close("fresh session reset committed")
                 .catch((error) => log("previous runtime close after fresh reset failed", String(error)));
@@ -2000,7 +2168,8 @@ export function createRuntimeHost(options) {
                     agent.config.sessionId = null;
                     agent.session = fresh;
                     persistPreviousSession(agent, previousRef);
-                    agent.readiness = readiness;
+                    if (!agent.authFailureActive)
+                        agent.readiness = readiness;
                     agent.disabledReason = null;
                     for (const record of agent.records.values()) {
                         if (!messageIds.includes(record.messageId))
@@ -2018,7 +2187,13 @@ export function createRuntimeHost(options) {
                         ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}),
                         ...(agent.previousSession ? { previousSession: agent.previousSession } : {}) });
                 }
-                emit({ type: "agent-status", agentId, status: "active", readiness });
+                emit({
+                    type: "agent-status",
+                    agentId,
+                    status: agent.authFailureActive ? "error" : "active",
+                    ...(agent.authFailureActive ? { error: `${agent.readiness?.reason} ${agent.readiness?.nextAction}` } : {}),
+                    readiness: agent.authFailureActive ? agent.readiness ?? readiness : readiness,
+                });
                 durableRollback = null;
                 agent.piSessionOwner = probeEnv[PI_SUBAGENT_SESSION_OWNER_ENV];
                 await oldSession.close("context-window recovery committed")
@@ -2108,11 +2283,13 @@ export function createRuntimeHost(options) {
                     piProactiveCompactionFailedGeneration: null,
                     previousSession: loadPersistedPreviousSession(config, stateStore), readiness: null,
                     turnInProgress: false, turnHadFailure: false, turnHadAuthenticatedOutput: false, authFailureActive: false,
+                    authFailureKind: null, authFailureProvider: null,
                     promotedInboxUpdateIds: new Set(),
                     backgroundCompletionQueue: [], backgroundCompletionKeys: new Set(),
                     backgroundCompletionInFlight: null, backgroundCompletionWakeInputId: null,
                     backgroundCompletionRejectStreak: 0, backgroundCompletionRetryTimer: null,
                     subagentLedger: loadSubagentLedger(config), subagentReconcileTimer: null };
+                restoreAuthFailure(agent);
                 const startupConsumed = [];
                 const startupQuarantined = [];
                 for (const record of agent.records.values()) {

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CURRENT_RUNTIME_MODELS = void 0;
-// Authored catalog keys are adapter ids only. builtin-pi is a user-facing sibling, not a stored runtime.
+// Authored catalog keys are adapter ids only.
 // 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.

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

@@ -1,4 +1,4 @@
-// Authored catalog keys are adapter ids only. builtin-pi is a user-facing sibling, not a stored runtime.
+// Authored catalog keys are adapter ids only.
 // 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.

package/dist/runtime/runtime-readiness.cjs

@@ -37,22 +37,97 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimePrerequisiteError = void 0;
+exports.safeProviderId = safeProviderId;
+exports.configuredProviderId = configuredProviderId;
+exports.parsePersistedAuthFailure = parsePersistedAuthFailure;
+exports.authFailureAppliesTo = authFailureAppliesTo;
+exports.readinessForPersistedAuthFailure = readinessForPersistedAuthFailure;
+exports.classifyPiMissingCredentialRejection = classifyPiMissingCredentialRejection;
+exports.runtimeInstallNextAction = runtimeInstallNextAction;
+exports.runtimeLoginNextAction = runtimeLoginNextAction;
 exports.providerAuthenticationFailureReadiness = providerAuthenticationFailureReadiness;
+exports.missingProviderCredentialReadiness = missingProviderCredentialReadiness;
 exports.resolveRuntimeExecutable = resolveRuntimeExecutable;
 exports.classifyRuntimePrerequisite = classifyRuntimePrerequisite;
 exports.probeNativeRuntimeReadiness = probeNativeRuntimeReadiness;
 const node_fs_1 = __importDefault(require("node:fs"));
-const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
-const root_layout_js_1 = require("../platform/root-layout.cjs");
-const builtin_pi_assets_js_1 = require("./builtin-pi-assets.cjs");
-const pi_provider_config_js_1 = require("./pi-provider-config.cjs");
-const process_boundary_trace_js_1 = require("../platform/process-boundary-trace.cjs");
-function safeProviderLabel(value) {
+function safeProviderId(value) {
     const provider = typeof value === "string" ? value.trim() : "";
     return /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/.test(provider) ? provider : null;
 }
+function safeProviderLabel(value) {
+    return safeProviderId(value);
+}
+/** Model ids are `provider/model`; only the provider prefix is used for scope. */
+function configuredProviderId(model) {
+    const value = typeof model === "string" ? model.trim() : "";
+    const slash = value.indexOf("/");
+    return slash > 0 ? safeProviderId(value.slice(0, slash)) : null;
+}
+function persistedRuntime(value) {
+    return value === "pi" || value === "codex" || value === "claude" ? value : null;
+}
+function parsePersistedAuthFailure(state) {
+    if (!state || typeof state !== "object" || Array.isArray(state))
+        return null;
+    const record = state;
+    if (record.authFailure && typeof record.authFailure === "object" && !Array.isArray(record.authFailure)) {
+        const failure = record.authFailure;
+        const kind = failure.kind === "missing-provider" || failure.kind === "generic" ? failure.kind : null;
+        const runtime = persistedRuntime(failure.runtime);
+        if (!kind || !runtime)
+            return null;
+        const provider = safeProviderId(failure.provider);
+        if (kind === "missing-provider" && !provider)
+            return null;
+        return { kind, runtime, provider };
+    }
+    const legacy = safeProviderId(record.authFailureProvider);
+    return legacy ? { kind: "missing-provider", runtime: "pi", provider: legacy } : null;
+}
+function currentAdapterId(current) {
+    return current.adapterId ?? current.runtime;
+}
+function authFailureAppliesTo(current, failure) {
+    if (failure.runtime !== currentAdapterId(current))
+        return false;
+    if (!failure.provider)
+        return true;
+    const currentProvider = configuredProviderId(current.model);
+    return currentProvider ? currentProvider === failure.provider : true;
+}
+function readinessForPersistedAuthFailure(failure) {
+    if (failure.kind === "missing-provider") {
+        return missingProviderCredentialReadiness(failure.runtime, failure.provider);
+    }
+    return providerAuthenticationFailureReadiness(failure.runtime, failure.provider);
+}
+const MISSING_CREDENTIAL_REJECTION = /^(?:Pi RPC (?:prompt|steer) failed: )?(No API key found for|No login found for) ([A-Za-z0-9][A-Za-z0-9._-]{0,79})$/;
+/** Narrow match for an explicit Pi absent-key / absent-login diagnostic. */
+function classifyPiMissingCredentialRejection(message) {
+    const text = typeof message === "string"
+        ? message.replace(/[\r\n\t]+/g, " ").replace(/\s+/g, " ").trim()
+        : "";
+    const match = MISSING_CREDENTIAL_REJECTION.exec(text);
+    const provider = match ? safeProviderLabel(match[2]) : null;
+    return provider && match ? { provider, diagnostic: `${match[1]} ${provider}` } : null;
+}
+function runtimeInstallNextAction(runtime) {
+    if (runtime === "pi")
+        return "Install Pi and ensure `pi` is on PATH, or set LARKIN_PI_COMMAND.";
+    if (runtime === "codex")
+        return "Install Codex and ensure `codex` is on PATH, or set LARKIN_CODEX_COMMAND.";
+    return "Install Claude Code and ensure `claude` is on PATH, or set LARKIN_CLAUDE_COMMAND.";
+}
+function runtimeLoginNextAction(runtime) {
+    if (runtime === "pi")
+        return "Log in with the external `pi` CLI, then retry.";
+    if (runtime === "codex")
+        return "Run `codex login`, then retry.";
+    return "Run `claude login`, then retry.";
+}
 function providerAuthenticationFailureReadiness(runtime, provider) {
     const label = safeProviderLabel(provider);
     return {
@@ -61,7 +136,20 @@ function providerAuthenticationFailureReadiness(runtime, provider) {
         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.",
+        nextAction: runtimeLoginNextAction(runtime),
+    };
+}
+function missingProviderCredentialReadiness(runtime, provider) {
+    const label = safeProviderLabel(provider);
+    return {
+        runtime,
+        state: "unauthenticated",
+        reason: label
+            ? `Provider ${label} is not authenticated for this runtime.`
+            : "The configured provider is not authenticated for this runtime.",
+        nextAction: runtime === "pi" && label
+            ? `Log in with the external \`pi\` CLI for provider ${label}, then retry.`
+            : runtimeLoginNextAction(runtime),
     };
 }
 class RuntimePrerequisiteError extends Error {
@@ -94,24 +182,29 @@ 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.`,
+            runtime, state: "missing", ...(executable ? { executable } : {}),
+            reason: `${runtime} is not installed`,
+            nextAction: runtimeInstallNextAction(runtime),
         };
     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.`,
+            nextAction: runtimeLoginNextAction(runtime),
         };
-    if (/protocol (?:version )?(?:mismatch|unsupported|incompatible)|unsupported (?:rpc|protocol|schema)|schema (?:mismatch|incompatible)|requires (?:a )?newer version/i.test(reason))
+    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.`,
+            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))
+    }
+    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.`,
@@ -134,44 +227,15 @@ function executableVersion(executable, env, commandArgs = []) {
 }
 /** Resolve and handshake through each runtime's structured native control protocol. */
 async function probeNativeRuntimeReadiness(options) {
-    let env = { ...process.env, ...options.env };
-    const piDistribution = options.runtime === "pi" ? (0, builtin_pi_assets_js_1.piChildDistributionFromOverrides)(options.env) : "external";
-    if (options.runtime === "pi" && piDistribution !== "builtin") {
-        if (env.LARKIN_PI_DISTRIBUTION === "builtin")
-            delete env.LARKIN_PI_DISTRIBUTION;
-        env = (0, builtin_pi_assets_js_1.applyPiPackageDirForChild)(env, { distribution: "external" });
-    }
-    if (options.runtime === "pi" && piDistribution === "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) {
-            (0, process_boundary_trace_js_1.traceProcessBoundary)(env, "readiness:builtin-pi-failure", { configDir: env.LARKIN_CONFIG_DIR, agentId: options.agentId, targetDir: options.agentId && env.LARKIN_CONFIG_DIR ? (0, pi_provider_config_js_1.piAgentDirectory)(env.LARKIN_CONFIG_DIR, options.agentId) : undefined, error });
-            return { runtime: "pi", state: "unauthenticated", reason: error instanceof Error ? error.message : String(error),
-                nextAction: "重新运行 larkin setup，选择内置 Pi 并配置有效 API Key。" };
-        }
-    }
+    const env = { ...process.env, ...options.env };
     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 piAgentId = options.agentId;
-    if (options.runtime === "pi" && !piAgentId) {
+    if (!executable) {
         return {
-            runtime: "pi",
-            state: "unavailable",
-            executable,
-            reason: "Pi catalog readiness requires Agent ID",
-            nextAction: "Retry setup or start so Larkin can probe the Agent-owned Pi provider directory.",
+            runtime: options.runtime,
+            state: "missing",
+            reason: `${options.runtime} is not installed`,
+            nextAction: runtimeInstallNextAction(options.runtime),
         };
     }
     const version = executableVersion(executable, env, options.commandArgs);
@@ -183,7 +247,6 @@ async function probeNativeRuntimeReadiness(options) {
                 command: executable,
                 commandArgs: options.commandArgs,
                 env,
-                agentDir: (0, pi_provider_config_js_1.ownedPiCatalogAgentDir)((0, root_layout_js_1.resolveConfigDir)(env, node_os_1.default.homedir()), piAgentId),
             });
         }
         else if (options.runtime === "codex") {