larkin 0.4.29 → 0.5.1

package/dist/runtime/pi-compaction-recovery.mjs

@@ -2,7 +2,8 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { BUNDLED_PI_VERSION } from "./pi-provider-config.mjs";
+/** External `pi` must be this version or newer; handshake still guards protocol compatibility. */
+export const MINIMUM_PI_VERSION = "0.84.2";
 /** Fallback values used while importing a Pi profile, before Pi reports its model. */
 export const PI_CONTEXT_WINDOW = 272_000;
 export const COMPACTION_RESERVE_TOKENS = 40_800;
@@ -232,23 +233,53 @@ export function readOwnedPiSettings(directory) {
     }
     return { compaction: { enabled, reserveTokens: values.reserveTokens, keepRecentTokens: values.keepRecentTokens } };
 }
+const PI_VERSION_LINE = /^(?:pi(?:-coding-agent)?(?:\s+version)?\s+v?)?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/i;
+const PI_VERSION_CORE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?$/;
+function comparePiNumericVersions(left, right) {
+    const leftParts = left.split(".").map(Number);
+    const rightParts = right.split(".").map(Number);
+    for (let index = 0; index < 3; index += 1) {
+        if (leftParts[index] !== rightParts[index])
+            return Math.sign(leftParts[index] - rightParts[index]);
+    }
+    return 0;
+}
+export function olderThanMinimumPiVersionMessage(version) {
+    return `Pi executable version ${version} is older than the minimum ${MINIMUM_PI_VERSION}`;
+}
+function assertSupportedPiVersion(version) {
+    if (typeof version !== "string")
+        throw new Error(`Pi executable version ${MINIMUM_PI_VERSION} or newer is required`);
+    const raw = version.trim();
+    const match = PI_VERSION_CORE.exec(raw);
+    if (!match)
+        throw new Error(`Pi executable version ${raw || "missing"} is not a supported version`);
+    const numeric = `${match[1]}.${match[2]}.${match[3]}`;
+    if (match[4]) {
+        throw new Error(`Pi executable version ${raw} is unsupported: SemVer ${raw} < ${numeric}; Larkin supports stable external pi only`);
+    }
+    if (comparePiNumericVersions(numeric, MINIMUM_PI_VERSION) < 0) {
+        throw new Error(olderThanMinimumPiVersionMessage(numeric));
+    }
+    return numeric;
+}
 export function parsePiExecutableVersion(output) {
     const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
     if (lines.length !== 1)
         throw new Error("Pi executable version output must contain exactly one version line");
-    const line = lines[0];
-    // Pi's bare version is canonical; permit only the fixed official display prefix.
-    const escapedVersion = BUNDLED_PI_VERSION.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    if (!new RegExp(`^(?:${escapedVersion}|pi(?:-coding-agent)?(?:\\s+version)?\\s+v?${escapedVersion})$`, "i").test(line)) {
-        throw new Error(`Pi executable version must be exactly ${BUNDLED_PI_VERSION}`);
-    }
-    return BUNDLED_PI_VERSION;
+    const match = PI_VERSION_LINE.exec(lines[0]);
+    if (!match)
+        throw new Error("Pi executable version output is not a supported version line");
+    const version = `${match[1]}.${match[2]}.${match[3]}`;
+    if (comparePiNumericVersions(version, MINIMUM_PI_VERSION) < 0) {
+        throw new Error(olderThanMinimumPiVersionMessage(version));
+    }
+    return version;
 }
 export function verifyPiCapabilities(capabilities) {
-    if (capabilities.version !== BUNDLED_PI_VERSION)
-        throw new Error(`trusted Pi version ${BUNDLED_PI_VERSION} is required`);
-    if (capabilities.distribution === "external" && capabilities.trustedProtocol === true) {
-        throw new Error("external Pi cannot use the bundled trusted protocol bypass");
+    assertSupportedPiVersion(capabilities.version);
+    if (capabilities.trustedProtocol === true) {
+        throw new Error("external Pi cannot use a trusted protocol bypass");
     }
     const contextWindow = capabilities.contextWindow ?? capabilities.model?.contextWindow;
     const expected = (() => {
@@ -264,8 +295,6 @@ export function verifyPiCapabilities(capabilities) {
     }
     if (capabilities.compactRpc !== true)
         throw new Error("Pi compact RPC capability is missing");
-    if (capabilities.distribution === "builtin" && capabilities.trustedProtocol === true)
-        return;
     if (capabilities.reserveTokens !== expected.reserveTokens
         || capabilities.keepRecentTokens !== expected.keepRecentTokens) {
         throw new Error(`Pi external effective compaction reserve/keep settings are unproven for context window ${contextWindow}`);

package/dist/runtime/pi-extension-api.mjs

@@ -0,0 +1 @@
+export {};

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

@@ -41,7 +41,6 @@ exports.findExactPiModel = findExactPiModel;
 exports.discoverPiModelCatalog = discoverPiModelCatalog;
 const node_child_process_1 = require("node:child_process");
 const path = __importStar(require("node:path"));
-const builtin_pi_assets_js_1 = require("./builtin-pi-assets.cjs");
 const pi_rpc_client_js_1 = require("./pi-rpc-client.cjs");
 const runtime_readiness_js_1 = require("./runtime-readiness.cjs");
 exports.PI_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
@@ -73,16 +72,16 @@ function findExactPiModel(reference, models) {
 const discoveryCache = new Map();
 /** Discover only through Pi's structured RPC protocol; no table parsing or static fallback. */
 function piCatalogChildEnv(options) {
-    const mergedEnv = {
+    const env = {
         ...process.env,
         ...options.env,
-        ...(options.agentDir ? { PI_CODING_AGENT_DIR: path.resolve(options.agentDir) } : {}),
         NO_COLOR: "1",
     };
-    return (0, builtin_pi_assets_js_1.applyPiPackageDirForChild)(mergedEnv, {
-        distribution: (0, builtin_pi_assets_js_1.catalogPiChildDistribution)(options.commandArgs),
-        explicitPackageDir: options.packageDir,
-    });
+    if (options.agentDir)
+        env.PI_CODING_AGENT_DIR = path.resolve(options.agentDir);
+    else
+        delete env.PI_CODING_AGENT_DIR;
+    return env;
 }
 async function discoverPiModelCatalog(options) {
     if (!options.spawn) {
@@ -118,7 +117,7 @@ async function discoverPiModelCatalogUncached(options) {
         ]);
         const available = [...(availableResponse?.models ?? [])].sort((left, right) => piModelId(left).localeCompare(piModelId(right)));
         if (!available.length)
-            throw new Error("Pi has no authenticated available models. Run the official `pi` login flow or configure provider credentials; Larkin will not create a fallback session.");
+            throw new Error("Pi has no authenticated available models. Run the official `pi` login flow; Larkin will not create a fallback session.");
         const effectiveModel = state.model ? piModelId(state.model) : null;
         if (!effectiveModel || !available.some((model) => piModelId(model) === effectiveModel)) {
             throw new Error(`Pi official default resolution returned an unavailable model (${effectiveModel || "none"}); refusing implicit fallback`);

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

@@ -1,6 +1,5 @@
 import { spawn as nodeSpawn } from "node:child_process";
 import * as path from "node:path";
-import { applyPiPackageDirForChild, catalogPiChildDistribution } from "./builtin-pi-assets.mjs";
 import { PiRpcClient } from "./pi-rpc-client.mjs";
 import { classifyRuntimePrerequisite, RuntimePrerequisiteError } from "./runtime-readiness.mjs";
 export const PI_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
@@ -32,16 +31,16 @@ export function findExactPiModel(reference, models) {
 const discoveryCache = new Map();
 /** Discover only through Pi's structured RPC protocol; no table parsing or static fallback. */
 function piCatalogChildEnv(options) {
-    const mergedEnv = {
+    const env = {
         ...process.env,
         ...options.env,
-        ...(options.agentDir ? { PI_CODING_AGENT_DIR: path.resolve(options.agentDir) } : {}),
         NO_COLOR: "1",
     };
-    return applyPiPackageDirForChild(mergedEnv, {
-        distribution: catalogPiChildDistribution(options.commandArgs),
-        explicitPackageDir: options.packageDir,
-    });
+    if (options.agentDir)
+        env.PI_CODING_AGENT_DIR = path.resolve(options.agentDir);
+    else
+        delete env.PI_CODING_AGENT_DIR;
+    return env;
 }
 export async function discoverPiModelCatalog(options) {
     if (!options.spawn) {
@@ -77,7 +76,7 @@ async function discoverPiModelCatalogUncached(options) {
         ]);
         const available = [...(availableResponse?.models ?? [])].sort((left, right) => piModelId(left).localeCompare(piModelId(right)));
         if (!available.length)
-            throw new Error("Pi has no authenticated available models. Run the official `pi` login flow or configure provider credentials; Larkin will not create a fallback session.");
+            throw new Error("Pi has no authenticated available models. Run the official `pi` login flow; Larkin will not create a fallback session.");
         const effectiveModel = state.model ? piModelId(state.model) : null;
         if (!effectiveModel || !available.some((model) => piModelId(model) === effectiveModel)) {
             throw new Error(`Pi official default resolution returned an unavailable model (${effectiveModel || "none"}); refusing implicit fallback`);

package/dist/runtime/pi-subagent-injection.mjs

@@ -160,12 +160,25 @@ export function piVersionSupportsSubagents(version) {
         return false;
     return version.major > 0 || (version.major === 0 && version.minor >= 80);
 }
-/** 解析 external `pi --version`；无法确认版本时视为不支持，不注入。 */
+const externalPiVersionProbeCache = new Map();
+function externalPiVersionProbeKey(piCommand, env) {
+    return JSON.stringify([piCommand, env.PATH ?? ""]);
+}
+/** 测试用：清空进程内 `pi --version` 探测缓存。 */
+export function resetExternalPiVersionProbeCache() {
+    externalPiVersionProbeCache.clear();
+}
+/** 解析 external `pi --version`；无法确认版本时视为不支持，不注入。按 piCommand+PATH 缓存。 */
 export function probeExternalPiVersion(piCommand, env) {
+    const key = externalPiVersionProbeKey(piCommand, env);
+    if (externalPiVersionProbeCache.has(key))
+        return externalPiVersionProbeCache.get(key) ?? null;
     const result = spawnSync(piCommand, ["--version"], { env, encoding: "utf8", timeout: 5_000, maxBuffer: 64 * 1024 });
-    if (result.error || result.status !== 0)
-        return null;
-    return parsePiVersion(String(result.stdout || result.stderr || ""));
+    const version = result.error || result.status !== 0
+        ? null
+        : parsePiVersion(String(result.stdout || result.stderr || ""));
+    externalPiVersionProbeCache.set(key, version);
+    return version;
 }
 /**
  * 用户 pi 是否已自行安装 pi-subagents（settings.json packages 或包目录）。

package/dist/runtime/runtime-adapters.mjs

@@ -3,11 +3,8 @@ import crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { createInterface } from "node:readline";
-import { applyPiPackageDirForChild, piChildDistributionFromOverrides } from "./builtin-pi-assets.mjs";
 import { isPiThinkingLevel } from "./pi-model-catalog.mjs";
 import { PiRpcClient } from "./pi-rpc-client.mjs";
-import { internalCommandSpec } from "../app/internal-command.mjs";
-import { BUNDLED_PI_VERSION, piAgentDirectory } from "./pi-provider-config.mjs";
 import { recordPiRuntimeArtifactProvenance } from "./pi-artifact-provenance.mjs";
 import { traceProcessBoundary } from "../platform/process-boundary-trace.mjs";
 import { resolvePiSubagentExtensionArg } from "./pi-subagent-injection.mjs";
@@ -15,9 +12,12 @@ import { extractCanonicalPiSubagentNotification, ledgerStatusFromPiNotificationS
 import { resolvePiSubagentRecordWatchdogExtensionArg } from "./pi-subagent-record-watchdog-injection.mjs";
 import { effectivePiStateDir, extractBackgroundPiSubagentDispatch } from "./pi-subagent-ledger.mjs";
 import { resolvePiBashTimeoutExtensionArg } from "./pi-bash-timeout-injection.mjs";
-import { classifyPiMissingCredentialRejection, classifyRuntimePrerequisite, isBuiltinPiDistribution, missingProviderCredentialReadiness, probeNativeRuntimeReadiness, providerAuthenticationFailureReadiness, RuntimePrerequisiteError, } from "./runtime-readiness.mjs";
+import { classifyPiMissingCredentialRejection, classifyRuntimePrerequisite, missingProviderCredentialReadiness, probeNativeRuntimeReadiness, providerAuthenticationFailureReadiness, RuntimePrerequisiteError, } from "./runtime-readiness.mjs";
 import { buildStrictProviderErrorInput, classifyStrictProviderError, INTERNAL_CONTEXT_WINDOW_PROJECTION_REASON, } from "./provider-error-classifier.mjs";
-import { assertEffectivePiCompactionSettings, assertNoProjectPiCompactionOverride, calculatePiCompactionSettings, parsePiExecutableVersion, prepareOwnedPiDirectory, readOwnedPiSettings, verifyPiCapabilities, writeOwnedPiSettings, } from "./pi-compaction-recovery.mjs";
+import { assertEffectivePiCompactionSettings, assertNoProjectPiCompactionOverride, MINIMUM_PI_VERSION, calculatePiCompactionSettings, parsePiExecutableVersion, prepareOwnedPiDirectory, readOwnedPiSettings, verifyPiCapabilities, writeOwnedPiSettings, } from "./pi-compaction-recovery.mjs";
+function piAgentDirectory(configDir, agentId) {
+    return path.join(path.resolve(configDir), "providers", "pi", agentId);
+}
 class EventSession {
     listeners = new Set();
     subscribe(listener) {
@@ -462,7 +462,7 @@ class PiSession extends EventSession {
     firstOutputObserved = false;
     toolCallOpen = false;
     piPolicyManaged;
-    constructor(sdk, distribution) {
+    constructor(sdk, distribution = "external") {
         super();
         this.sdk = sdk;
         this.distribution = distribution;
@@ -538,17 +538,16 @@ class PiSession extends EventSession {
             this.ownedInputIds.delete(input.inputId);
             this.inputEpochs.delete(input.inputId);
             const rawReason = error instanceof Error ? error.message : String(error);
-            const missing = isBuiltinPiDistribution(this.distribution)
-                ? classifyPiMissingCredentialRejection(rawReason)
-                : null;
+            const missing = classifyPiMissingCredentialRejection(rawReason);
             if (missing) {
-                const classified = classifyPiProviderError({ provider: missing.provider, message: missing.diagnostic }, { distribution: this.distribution });
+                const classified = classifyPiProviderError({ provider: missing.provider, message: missing.diagnostic });
                 this.emit({
                     type: "input-error", inputId: input.inputId, retryable: false, willRetry: false,
                     message: classified.reason, errorCategory: classified.category, nextAction: classified.nextAction,
                     upstream: { provider: missing.provider, message: missing.diagnostic },
                 });
-                return { status: "rejected", inputId: input.inputId, retryable: false, reason: classified.reason };
+                // 拒绝原因保留 Pi 原文，方便 RuntimeHost 独立分类，不依赖 input-error 事件顺序。
+                return { status: "rejected", inputId: input.inputId, retryable: false, reason: rawReason };
             }
             return { status: "rejected", inputId: input.inputId, retryable: true, reason: rawReason };
         }
@@ -831,9 +830,7 @@ export function classifyPiProviderError(error, scope) {
         return {
             category: "rate_limit", reason, nextAction: "Wait for the provider rate-limit window, then retry.",
         };
-    const missing = isBuiltinPiDistribution(scope?.distribution)
-        ? classifyPiMissingCredentialRejection(reason)
-        : null;
+    const missing = classifyPiMissingCredentialRejection(reason);
     if (missing) {
         const readiness = missingProviderCredentialReadiness("pi", missing.provider);
         return { category: "auth", reason: readiness.reason, nextAction: readiness.nextAction };
@@ -1003,10 +1000,6 @@ class PiRpcBackend {
     }
 }
 export function resolvePiProcessExtensionArgs(input, resolvers = {}) {
-    // Builtin factories are passed directly to Pi main on every platform. The platform
-    // field makes that invariant explicit and testable without changing process.platform.
-    if (input.distribution === "builtin")
-        return [];
     const resolverInput = { distribution: "external", piCommand: input.piCommand, env: input.env };
     const args = [];
     // Watchdog must load before the subagent extension so session_shutdown still
@@ -1044,31 +1037,23 @@ async function createPiRpcBackend(input, dependencies, spawn, productionSpawn =
         ...(session.sessionFile ? ["--session", session.sessionFile] : []),
         ...(requestedModel ? ["--model", requestedModel] : []),
         ...(requestedEffort ? ["--thinking", requestedEffort] : [])];
-    const builtin = piChildDistributionFromOverrides(dependencies.env, input.env) === "builtin";
-    if (!builtin && mergedEnv.LARKIN_PI_DISTRIBUTION === "builtin")
+    if (mergedEnv.LARKIN_PI_DISTRIBUTION === "builtin")
         delete mergedEnv.LARKIN_PI_DISTRIBUTION;
-    const builtinSpec = builtin ? internalCommandSpec("pi-rpc", [], mergedEnv) : null;
-    const command = builtinSpec?.command ?? dependencies.piCommand ?? dependencies.env?.LARKIN_PI_COMMAND ?? process.env.LARKIN_PI_COMMAND ?? "pi";
-    const commandPrefix = builtinSpec?.args ?? dependencies.piCommandArgs ?? [];
+    const command = dependencies.piCommand ?? dependencies.env?.LARKIN_PI_COMMAND ?? process.env.LARKIN_PI_COMMAND ?? "pi";
+    const commandPrefix = dependencies.piCommandArgs ?? [];
     const commandArgs = [...commandPrefix, ...args];
     mergedEnv.PI_CODING_AGENT_DIR = ownedPiDirectory;
-    if (builtin)
-        mergedEnv.PI_TELEMETRY = "0";
-    const childEnv = applyPiPackageDirForChild(mergedEnv, {
-        distribution: builtin ? "builtin" : "external",
-        explicitPackageDir: input.env?.PI_PACKAGE_DIR ?? dependencies.env?.PI_PACKAGE_DIR,
-    });
-    const reportedVersion = productionSpawn && !builtin
+    const childEnv = { ...mergedEnv };
+    const reportedVersion = productionSpawn
         ? parsePiExecutableVersion(String(spawnSync(command, [...commandPrefix, "--version"], {
             cwd: input.workspaceDir, env: childEnv, encoding: "utf8", timeout: 5_000,
         }).stdout || ""))
-        : BUNDLED_PI_VERSION;
-    const extensionArgs = (dependencies.resolvePiProcessExtensionArgs ?? resolvePiProcessExtensionArgs)({
-        distribution: builtin ? "builtin" : "external",
-        piCommand: command,
-        env: childEnv,
-        platform: process.platform,
-    });
+        : MINIMUM_PI_VERSION;
+    const extensionInput = { piCommand: command, env: childEnv, platform: process.platform };
+    // 假 spawn 不需要真实 extension 路径；默认 resolver 会 spawnSync(`pi --version`)。
+    const extensionArgs = dependencies.resolvePiProcessExtensionArgs
+        ? dependencies.resolvePiProcessExtensionArgs(extensionInput)
+        : productionSpawn ? resolvePiProcessExtensionArgs(extensionInput) : [];
     commandArgs.push(...extensionArgs);
     let probedModel = null;
     if (productionSpawn) {
@@ -1094,7 +1079,7 @@ async function createPiRpcBackend(input, dependencies, spawn, productionSpawn =
             client.request("get_available_models"),
         ]);
         if (!available?.models?.length)
-            throw new Error("Pi has no authenticated available models. Run the official `pi` login flow or configure provider credentials; Larkin will not create a fallback session.");
+            throw new Error("Pi has no authenticated available models. Run the official `pi` login flow; Larkin will not create a fallback session.");
         const effectiveModel = state.model?.provider && state.model.id ? `${state.model.provider}/${state.model.id}` : null;
         if (productionSpawn) {
             if (!effectiveModel || !probedModel || effectiveModel !== probedModel.model
@@ -1108,11 +1093,10 @@ async function createPiRpcBackend(input, dependencies, spawn, productionSpawn =
                     keepRecentTokens: ownedSettings.compaction?.keepRecentTokens,
                 } });
             const handshake = state.compactionCapabilities;
-            verifyPiCapabilities({ distribution: builtin ? "builtin" : "external", version: reportedVersion,
+            verifyPiCapabilities({ distribution: "external", version: reportedVersion,
                 contextWindow: state.model?.contextWindow, autoCompactionEnabled: state.autoCompactionEnabled,
                 reserveTokens: handshake?.reserveTokens, keepRecentTokens: handshake?.keepRecentTokens,
-                compactRpc: true, events: handshake?.events,
-                trustedProtocol: builtin });
+                compactRpc: true, events: handshake?.events });
         }
         // 严格对账（Owner 决策）：模型必须来自 pi 的权威可用列表，不做后缀猜测——
         // 配置的模型与 pi 可用列表不符即报错，并在错误里列出可用模型。
@@ -1247,10 +1231,9 @@ export function createNativeRuntimeAdapter(id, dependencies = {}) {
                     throw new RuntimePrerequisiteError(readiness);
             }
             if (id === "pi") {
-                const distribution = piChildDistributionFromOverrides(dependencies.env, input.env);
                 return new PiSession(await (dependencies.createPiSession
                     ? dependencies.createPiSession(input)
-                    : createPiRpcBackend(input, { ...dependencies, piCommand: resolvedExecutable }, spawn, productionSpawn)), distribution);
+                    : createPiRpcBackend(input, { ...dependencies, piCommand: resolvedExecutable }, spawn, productionSpawn)));
             }
             if (id === "codex") {
                 const codexInput = dependencies.codexModelOverride?.trim()

package/dist/runtime/runtime-host.cjs

@@ -14,7 +14,6 @@ const inbox_projection_js_1 = require("../agent/inbox-projection.cjs");
 const api_1 = require("@opentelemetry/api");
 const provider_error_classifier_js_1 = require("./provider-error-classifier.cjs");
 const runtime_readiness_js_1 = require("./runtime-readiness.cjs");
-const pi_official_auth_js_1 = require("./pi-official-auth.cjs");
 const official_lark_cli_js_1 = require("../app/official-lark-cli.cjs");
 const agent_lark_cli_workspace_js_1 = require("../app/agent-lark-cli-workspace.cjs");
 const pi_compaction_recovery_js_1 = require("./pi-compaction-recovery.cjs");
@@ -103,37 +102,23 @@ function persistPreviousSession(agent, previous) {
         // In-memory ref still holds for this process; restart will miss it only if this write failed.
     }
 }
-function isBuiltinPiAgent(agent) {
-    return agent.adapter.id === "pi"
-        && ((0, runtime_readiness_js_1.isBuiltinPiDistribution)(agent.config.piDistribution) || agent.config.runtime === "builtin-pi");
-}
 function authFailureScopeOf(agent) {
     return {
         runtime: agent.config.runtime,
         model: agent.config.model,
-        piDistribution: agent.config.piDistribution,
         adapterId: agent.adapter.id,
     };
 }
 function currentAuthFailure(agent) {
     if (!agent.authFailureActive)
         return null;
-    const kind = agent.authFailureKind
-        ?? (agent.authFailureProvider ? "missing-provider" : "generic");
-    if (kind === "missing-provider") {
-        if (!agent.authFailureProvider)
-            return null;
-        return { kind: "missing-provider", runtime: "pi", piDistribution: "builtin", provider: agent.authFailureProvider };
-    }
     const runtime = agent.adapter.id === "codex" || agent.adapter.id === "claude" || agent.adapter.id === "pi"
         ? agent.adapter.id : null;
     if (!runtime)
         return null;
     return {
-        kind: "generic",
+        kind: agent.authFailureKind === "missing-provider" ? "missing-provider" : "generic",
         runtime,
-        ...(runtime === "pi" && (agent.config.piDistribution === "builtin" || agent.config.piDistribution === "external")
-            ? { piDistribution: agent.config.piDistribution } : {}),
         provider: agent.authFailureProvider,
     };
 }
@@ -344,7 +329,6 @@ 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: (0, pi_subagent_ledger_js_1.effectivePiStateDir)(config),
             ...(process.env.HOME ? { HOME: process.env.HOME } : {}),
             ...(process.env.SHELL ? { SHELL: process.env.SHELL } : {}),
@@ -606,10 +590,6 @@ function createRuntimeHost(options) {
                 messageId: record.messageId, status: "consumed" });
         }
     };
-    const ownedConfigDir = () => {
-        const value = process.env.LARKIN_CONFIG_DIR?.trim();
-        return value || null;
-    };
     const projectAuthFailure = (agent, readiness, failure) => {
         agent.authFailureActive = true;
         agent.authFailureKind = failure.kind;
@@ -627,12 +607,7 @@ function createRuntimeHost(options) {
         if (agent.authFailureKind !== "missing-provider" || !agent.authFailureProvider)
             return true;
         const failure = currentAuthFailure(agent);
-        if (!failure || !(0, runtime_readiness_js_1.authFailureAppliesTo)(authFailureScopeOf(agent), failure))
-            return false;
-        const configDir = ownedConfigDir();
-        if (!configDir)
-            return false;
-        return (0, pi_official_auth_js_1.officialPiHasStoredProvider)(configDir, agent.config.agentId, agent.authFailureProvider);
+        return Boolean(failure && (0, runtime_readiness_js_1.authFailureAppliesTo)(authFailureScopeOf(agent), failure));
     };
     const resultFor = (agent, record, result) => {
         if (result.status === "accepted") {
@@ -647,12 +622,12 @@ function createRuntimeHost(options) {
                     deliveryId: record.deliveryId, messageId: record.messageId, status: "accepted" });
             return { status: "accepted", deliveryId: record.deliveryId };
         }
-        const missing = result.status === "rejected" && isBuiltinPiAgent(agent)
+        const missing = result.status === "rejected" && agent.adapter.id === "pi"
             ? (0, runtime_readiness_js_1.classifyPiMissingCredentialRejection)(result.reason)
             : null;
         if (missing) {
             const readiness = (0, runtime_readiness_js_1.missingProviderCredentialReadiness)(agent.adapter.id, missing.provider);
-            const reason = readiness.reason ?? `Provider ${missing.provider} is missing from this Agent's official credential store.`;
+            const reason = readiness.reason ?? result.reason;
             if (record.status !== "error") {
                 record.reason = reason;
                 record.retryable = false;
@@ -1629,26 +1604,30 @@ function createRuntimeHost(options) {
                 record.errorCategory = classifiedCategory;
             else
                 delete record.errorCategory;
-            const missing = event.errorCategory === "auth" && !event.retryable && isBuiltinPiAgent(agent)
+            const missing = agent.adapter.id === "pi"
                 ? (0, runtime_readiness_js_1.classifyPiMissingCredentialRejection)(event.upstream?.message)
                     ?? (0, runtime_readiness_js_1.classifyPiMissingCredentialRejection)(event.message)
                 : null;
-            if (missing)
+            if (missing) {
+                record.retryable = false;
+                record.errorCategory = "auth";
                 record.authProvider = missing.provider;
-            const finalRecord = setRecord(agent, record, event.retryable ? "pending" : "error");
+            }
+            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) {
-                const readiness = missing
-                    ? (0, runtime_readiness_js_1.missingProviderCredentialReadiness)(agent.adapter.id, missing.provider)
-                    : (0, runtime_readiness_js_1.providerAuthenticationFailureReadiness)(agent.adapter.id, event.upstream?.provider);
-                projectAuthFailure(agent, readiness, missing
-                    ? { kind: "missing-provider", provider: missing.provider }
-                    : { kind: "generic", provider: genericAuthProvider(agent, event.upstream) });
-            }
-            if (event.retryable && !agent.busy && !agent.turnInProgress)
+                    status: terminal ? "error" : "deferred", reason: event.message });
+            if (missing) {
+                const readiness = (0, runtime_readiness_js_1.missingProviderCredentialReadiness)(agent.adapter.id, missing.provider);
+                projectAuthFailure(agent, readiness, { kind: "missing-provider", provider: missing.provider });
+            }
+            else if (event.errorCategory === "auth" && !event.retryable) {
+                const readiness = (0, runtime_readiness_js_1.providerAuthenticationFailureReadiness)(agent.adapter.id, event.upstream?.provider);
+                projectAuthFailure(agent, readiness, { kind: "generic", provider: genericAuthProvider(agent, event.upstream) });
+            }
+            if (!terminal && event.retryable && !agent.busy && !agent.turnInProgress)
                 void retryPending(agent);
         }
         else if (event.type === "configuration-error") {
@@ -1923,7 +1902,6 @@ function createRuntimeHost(options) {
                         && (0, runtime_readiness_js_1.authFailureAppliesTo)({
                             runtime: config.runtime,
                             model: config.model,
-                            piDistribution: config.piDistribution,
                             adapterId: adapter.id,
                         }, previousFailure));
                     const candidate = {